src/Launcher/SALOME_LogManager.hxx

   1 // Copyright (C) 2024  CEA, EDF
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19
  20 #pragma once
  21
  22 #include "SALOME_Launcher_defs.hxx"
  23
  24 #include "Python.h"
  25
  26 #include "PythonCppUtils.hxx"
  27 #include "Utils_CorbaException.hxx"
  28 #include "SALOMEconfig.h"
  29
  30 #include CORBA_SERVER_HEADER(SALOME_LogManager)
  31
  32 #include <vector>
  33 #include <string>
  34 #include <memory>
  35
  36 class SALOME_NamingService_Abstract;
  37 class SALOME_LogManager;
  38 class SALOME_ContainerPerfLog;
  39 class SALOME_ContainerScriptPerfLog;
  40 class SALOME_ContainerScriptExecPerfLog;
  41
  42 namespace SALOME
  43 {
  44   auto ServantDeleter = [](PortableServer::ServantBase *serv) { if(serv) serv->_remove_ref(); };
  45   using AutoServantDeleter = std::unique_ptr<PortableServer::ServantBase, decltype(ServantDeleter)>;
  46
  47   /**
  48    * Class in charge to manage life cycle of servant instance and its associated reference.
  49    * It allows to deal cleanly with management of servant life even in case of ORB_destoy call
  50    * at exit.
  51    *
  52    * As orb_destroy automaticaly desactivates all objects activated by all POAs in this
  53    * it's impossible to deal cleanly maangement of servant lifecyle using only _ptr or _var.
  54    *
  55    */
  56   template<class TVar, class TServ>
  57   class RefAndServant
  58   {
  59   public:
  60     RefAndServant(TVar var, TServ *serv):_var(var),_serv(serv,ServantDeleter) { }
  61     RefAndServant(const RefAndServant& other):_var( other._var ),_serv(nullptr,ServantDeleter)
  62     {
  63       other.getServ()->_add_ref();
  64       _serv.reset( other.getServ() );
  65     }
  66     ~RefAndServant() = default;
  67     RefAndServant& operator=(const RefAndServant& other)
  68     {
  69       _var = other._var;
  70       other.getServ()->_add_ref();
  71       _serv.reset( other.getServ() );
  72       return *this;
  73     }
  74     TVar getVar() const { return _var; }
  75     TServ *getServ() const { return dynamic_cast<TServ *>( _serv.get() ); }
  76     void desactivateObjectFromPOA( )
  77     {
  78       PortableServer::ObjectId_var oid = getServ()->getPOA()->reference_to_id(_var);
  79       getServ()->getPOA()->deactivate_object(oid);
  80     }
  81   private:
  82     TVar _var;
  83     SALOME::AutoServantDeleter _serv;
  84   };
  85 }
  86
  87 class SALOMELAUNCHER_EXPORT SALOME_VisitorContainerLog
  88 {
  89 public:
  90   virtual void enterLogManager(SALOME_LogManager& inst) = 0;
  91   virtual void leaveLogManager(SALOME_LogManager& inst) = 0;
  92   virtual void enterContainerPerfLog(SALOME_ContainerPerfLog& inst) = 0;
  93   virtual void leaveContainerPerfLog(SALOME_ContainerPerfLog& inst) = 0;
  94   virtual void enterContainerScriptPerfLog(SALOME_ContainerScriptPerfLog& inst) = 0;
  95   virtual void leaveContainerScriptPerfLog(SALOME_ContainerScriptPerfLog& inst) = 0;
  96   virtual void visitContainerScriptExecPerfLog(SALOME_ContainerScriptExecPerfLog& inst) = 0;
  97 };
  98
  99
 100 class SALOMELAUNCHER_EXPORT SALOME_ContainerScriptExecPerfLog : public POA_Engines::ContainerScriptExecPerfLog
 101 {
 102 public:
 103   SALOME_ContainerScriptExecPerfLog(SALOME_ContainerScriptPerfLog *father):_father(father) { }
 104   SALOME_ContainerScriptPerfLog *father() const { return _father; }
 105   void setPyObj(PyObject *obj) { _pyExecutionLog.set(obj); }
 106   PyObject *pyObj() { return _pyExecutionLog.get(); }
 107   PortableServer::POA_var getPOA();
 108   void assign(const SALOME::vectorOfByte& value) override;
 109   SALOME::vectorOfByte *getObj() override;
 110   const std::vector<char>& data() const { return _data; }
 111   void setData(std::vector<char>&& data) { _data = std::move(data); }
 112 public:
 113   void accept(SALOME_VisitorContainerLog &visitor);
 114 public:
 115   void start();
 116   AutoPyRef end();
 117   void clear() { _data.clear(); }
 118 private:
 119   AutoPyRefGilSafe _pyExecutionLog;
 120   SALOME_ContainerScriptPerfLog *_father = nullptr;
 121   std::vector<char> _data;
 122 };
 123
 124 using ContainerScriptExecPerfLogPair = SALOME::RefAndServant< Engines::ContainerScriptExecPerfLog_var, SALOME_ContainerScriptExecPerfLog >;
 125
 126 class SALOMELAUNCHER_EXPORT SALOME_ContainerScriptPerfLog : public POA_Engines::ContainerScriptPerfLog
 127 {
 128 public:
 129   SALOME_ContainerScriptPerfLog(SALOME_ContainerPerfLog *father, const std::string& name, const std::string& code):_father(father),_name(name),_code(code) { }
 130   ~SALOME_ContainerScriptPerfLog();
 131   SALOME_ContainerPerfLog *father() const { return _father; }
 132   void setPyObj(PyObject *obj) { _pyScriptLog.set(obj); }
 133   PyObject *pyObj() { return _pyScriptLog.get(); }
 134   PortableServer::POA_var getPOA();
 135   Engines::ContainerScriptExecPerfLog_ptr addExecutionSession() override;
 136   Engines::ListOfContainerScriptExecPerfLog *listOfExecs() override;
 137   char *getCode() override;
 138   char *getName() override;
 139   const std::string& name() const { return _name; }
 140   const std::string& code() const { return _code; }
 141   void setName(const std::string& name) { _name = name; }
 142   void setCode(const std::string& code) { _code = code; }
 143   std::size_t getNumberOfSessions() const { return _sessions.size(); }
 144 public:
 145   void accept(SALOME_VisitorContainerLog &visitor);
 146 private:
 147   AutoPyRefGilSafe _pyScriptLog;
 148   SALOME_ContainerPerfLog *_father = nullptr;
 149   std::string _name;
 150   std::string _code;
 151   std::vector< ContainerScriptExecPerfLogPair > _sessions;
 152 };
 153
 154 using ContainerScriptPerfLogPair = SALOME::RefAndServant< Engines::ContainerScriptPerfLog_var, SALOME_ContainerScriptPerfLog >;
 155
 156 class SALOMELAUNCHER_EXPORT SALOME_ContainerPerfLog : public POA_Engines::ContainerPerfLog
 157 {
 158 public:
 159   SALOME_ContainerPerfLog(SALOME_LogManager *father, const std::string& nameInNS, const std::string& logFile):_father(father),_name_in_ns(nameInNS),_log_file(logFile) { }
 160   ~SALOME_ContainerPerfLog();
 161   SALOME_LogManager *father() const { return _father; }
 162   void setPyObj(PyObject *obj) { _pyContLog.set(obj); }
 163   PyObject *pyObj() { return _pyContLog.get(); }
 164   PortableServer::POA_var getPOA();
 165   char *getLogFile() override;
 166   char *getContainerEntryInNS() override;
 167   Engines::ContainerScriptPerfLog_ptr addScript(const char *name, const char *code) override;
 168   Engines::ListOfContainerScriptPerfLog *listOfScripts() override;
 169   /* Call that destroy this object AND unregister from POA all referecences of this*/
 170   void destroy() override;
 171   const std::string& nameInNS() const { return _name_in_ns; }
 172   const std::string& logFile() const { return _log_file; }
 173   void setNameInNS(const std::string& name) { _name_in_ns = name; }
 174   void setLogFile(const std::string& logFile) { _log_file = logFile; }
 175   std::size_t getNumberOfScripts() const { return _scripts.size(); }
 176 public:
 177   void accept(SALOME_VisitorContainerLog &visitor);
 178 private:
 179   void destroyInternal();
 180 private:
 181   AutoPyRefGilSafe _pyContLog;
 182   SALOME_LogManager *_father = nullptr;
 183   std::string _name_in_ns;
 184   std::string _log_file;
 185   std::vector< ContainerScriptPerfLogPair > _scripts;
 186 };
 187
 188 enum class SafeLoggerActiveVersionType
 189 { VersionA_Activated, VersionB_Activated, NoVersion_Activated };
 190
 191 class SALOME_SafeLoggerFileHolder
 192 {
 193 public:
 194   void setFileNamePairOfLogger(const std::string& loggerFileNameA, const std::string& loggerFileNameB) { _logger_file_a = loggerFileNameA; _logger_file_b = loggerFileNameB; }
 195   void getFileNamePairOfLogger(std::string& loggerFileNameA, std::string& loggerFileNameB) { loggerFileNameA = _logger_file_a; loggerFileNameB = _logger_file_b; }
 196   void versionA_IsTheLatestValidVersion() { _version_activated = SafeLoggerActiveVersionType::VersionA_Activated; }
 197   void versionB_IsTheLatestValidVersion() { _version_activated = SafeLoggerActiveVersionType::VersionB_Activated; }
 198   std::string getLastVersionOfFileNameLogger();
 199 private:
 200   std::string _logger_file_a;
 201   std::string _logger_file_b;
 202   SafeLoggerActiveVersionType _version_activated = SafeLoggerActiveVersionType::NoVersion_Activated;
 203 };
 204
 205 using ContainerPerfLogPair = SALOME::RefAndServant< Engines::ContainerPerfLog_var, SALOME_ContainerPerfLog >;
 206
 207 class SALOMELAUNCHER_EXPORT SALOME_LogManager : public POA_Engines::LogManager
 208 {
 209  public:
 210   SALOME_LogManager(CORBA::ORB_ptr orb, PortableServer::POA_var poa, SALOME_NamingService_Abstract *ns = nullptr);
 211   PortableServer::POA_var getPOA() { return _poa; }
 212   PyObject *pyHelper() const { return _pyLogManager; }
 213   ~SALOME_LogManager();
 214   void clear() override;
 215   Engines::ContainerPerfLog_ptr declareContainer(const char *contInNS, const char *logfile) override;
 216   Engines::ListOfContainerPerfLog *listOfContainerLogs() override;
 217   SALOME::vectorOfByte *getAllStruct(bool clearMemory) override;
 218   void putStructInFileAtomic(bool clearMemory, const char *fileName) override;
 219  public:
 220   void setFileNamePairOfLogger(const char *loggerFileNameA, const char *loggerFileNameB) override;
 221   void getFileNamePairOfLogger(CORBA::String_out loggerFileNameA, CORBA::String_out loggerFileNameB) override;
 222   void versionA_IsTheLatestValidVersion() override { _safe_logger_file_holder.versionA_IsTheLatestValidVersion(); }
 223   void versionB_IsTheLatestValidVersion() override { _safe_logger_file_holder.versionB_IsTheLatestValidVersion(); }
 224   char *getLastVersionOfFileNameLogger() override;
 225  public:
 226   void removeEntryBeforeDying(SALOME_ContainerPerfLog *child);
 227  public:
 228   std::size_t getNumberOfContainers() const { return _containers.size(); }
 229  public:
 230   void accept(SALOME_VisitorContainerLog &visitor);
 231  private:
 232   std::vector<char> dumpCppInternalFrmt(bool clearMemory);
 233  private:
 234   PyObject *_pyLogManager = nullptr;
 235   std::unique_ptr<SALOME_NamingService_Abstract> _NS;
 236   PortableServer::POA_var _poa;
 237   std::vector< ContainerPerfLogPair > _containers;
 238   SALOME_SafeLoggerFileHolder _safe_logger_file_holder;
 239  public:
 240   static const char NAME_IN_NS[];
 241 };