FlexLMTools.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2022 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* FlexLMTools.h                                               (C) 2000-2012 */
/*                                                                           */
/* Gestion des protections FlexLM.                .                          */
/*---------------------------------------------------------------------------*/
 
#ifndef ARCANE_UTILS_FLEXLMTOOLS_H_
#define ARCANE_UTILS_FLEXLMTOOLS_H_
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/ArcaneVersion.h"
#include "arcane/utils/String.h"
#include "arcane/utils/Exception.h"
#include <map>
#include <iostream>
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ARCANE_BEGIN_NAMESPACE
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class IParallelSuperMng;
class TraceInfo;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class ARCANE_IMPL_EXPORT LicenseErrorException
: public Exception
{
 public:
 
  LicenseErrorException(const String& where);
  LicenseErrorException(const TraceInfo& where);
  LicenseErrorException(const String& where, const String& message);
  LicenseErrorException(const TraceInfo& where, const String& message);
  ~LicenseErrorException() ARCANE_NOEXCEPT {}
 
 public:
 
  virtual void explain(std::ostream& m) const;
  virtual void write(std::ostream& o) const;
 
 private:
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
 
class ARCANE_IMPL_EXPORT FlexLMMng
{
 private:
 
  FlexLMMng();
 
  virtual ~FlexLMMng() {}
 
 public:
 
  static FlexLMMng* instance();
 
 public:
 
  void init(IParallelSuperMng* parallel_super_mng);
 
 
  void setCheckInterval(const Integer t = 120);
 
 
  bool checkLicense(const String name, const Real version, bool do_fatal = true) const;
 
 
  void getLicense(const String name, const Real version, Integer nb_licenses = 1);
 
 
  void releaseLicense(const String name, Integer nb_licenses = 0);
 
 
  void releaseAllLicenses();
 
  String featureInfo(const String name, const Real version) const;
 
 private:
 
  typedef std::map<String, Integer> FeatureMapType;
  FeatureMapType m_features;
  static FlexLMMng* m_instance;
  IParallelSuperMng* m_parallel_super_mng;
  bool m_is_master; 
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename FeatureModel>
class FlexLMTools
{
 public:
 
  FlexLMTools() {}
 
  virtual ~FlexLMTools() {}
 
 public:
 
 
  bool checkLicense(typename FeatureModel::eFeature feature, const bool do_fatal) const
  {
    const String name = FeatureModel::getName(feature);
    const Real version = FeatureModel::getVersion(feature);
    return FlexLMMng::instance()->checkLicense(name, version, do_fatal);
  }
 
 
  bool checkLicense(typename FeatureModel::eFeature feature, const Real version, const bool do_fatal) const
  {
    const String name = FeatureModel::getName(feature);
    return FlexLMMng::instance()->checkLicense(name, version, do_fatal);
  }
 
 
  void getLicense(typename FeatureModel::eFeature feature, Integer nb_licenses = 1)
  {
    const String name = FeatureModel::getName(feature);
    const Real version = FeatureModel::getVersion(feature);
    return FlexLMMng::instance()->getLicense(name, version, nb_licenses);
  }
 
 
  void releaseLicense(typename FeatureModel::eFeature feature, Integer nb_licenses = 0)
  {
    const String name = FeatureModel::getName(feature);
    return FlexLMMng::instance()->releaseLicense(name, nb_licenses);
  }
 
  String featureInfo(typename FeatureModel::eFeature feature) const
  {
    const String name = FeatureModel::getName(feature);
    const Real version = FeatureModel::getVersion(feature);
    return FlexLMMng::instance()->featureInfo(name, version);
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class ArcaneFeatureModel
{
 public:
 
  typedef enum
  {
    ArcaneCore = 0, //<! Fonctionnalité noyau (liée à l'exécution)
  } eFeature;
 
  static String getName(eFeature feature)
  {
    return m_arcane_feature_name[feature];
  }
 
  static Real getVersion(eFeature feature)
  {
    ARCANE_UNUSED(feature);
    // Ecrit une version comparable numériquement; ex: 1.0610 (au lieu de 1.6.1)
    return (Real)ARCANE_VERSION_MAJOR + (Real)ARCANE_VERSION_MINOR / 100 + (Real)ARCANE_VERSION_RELEASE / 1000 + (Real)ARCANE_VERSION_BETA / 10000;
  }
 
 private:
 
  static const String m_arcane_feature_name[];
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ARCANE_END_NAMESPACE
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif /*FLEXLMTOOLS_H_*/