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 class SALOMELAUNCHER_EXPORT SALOME_VisitorContainerLog
  43 {
  44 public:
  45   virtual void enterLogManager(SALOME_LogManager& inst) = 0;
  46   virtual void leaveLogManager(SALOME_LogManager& inst) = 0;
  47   virtual void enterContainerPerfLog(SALOME_ContainerPerfLog& inst) = 0;
  48   virtual void leaveContainerPerfLog(SALOME_ContainerPerfLog& inst) = 0;
  49   virtual void enterContainerScriptPerfLog(SALOME_ContainerScriptPerfLog& inst) = 0;
  50   virtual void leaveContainerScriptPerfLog(SALOME_ContainerScriptPerfLog& inst) = 0;
  51   virtual void visitContainerScriptExecPerfLog(SALOME_ContainerScriptExecPerfLog& inst) = 0;
  52 };
  53
  54 class SALOMELAUNCHER_EXPORT SALOME_ContainerScriptExecPerfLog : public POA_Engines::ContainerScriptExecPerfLog
  55 {
  56 public:
  57   SALOME_ContainerScriptExecPerfLog(SALOME_ContainerScriptPerfLog *father):_father(father) { }
  58   SALOME_ContainerScriptPerfLog *father() const { return _father; }
  59   void setPyObj(PyObject *obj) { _pyExecutionLog.set(obj); }
  60   PyObject *pyObj() { return _pyExecutionLog.get(); }
  61   PortableServer::POA_var getPOA();
  62   void assign(const SALOME::vectorOfByte& value) override;
  63   SALOME::vectorOfByte *getObj() override;
  64   const std::vector<char>& data() const { return _data; }
  65   void setData(std::vector<char>&& data) { _data = std::move(data); }
  66 public:
  67   void accept(SALOME_VisitorContainerLog &visitor);
  68 public:
  69   void start();
  70   AutoPyRef end();
  71   void clear() { _data.clear(); }
  72 private:
  73   AutoPyRefGilSafe _pyExecutionLog;
  74   SALOME_ContainerScriptPerfLog *_father = nullptr;
  75   std::vector<char> _data;
  76 };
  77
  78 class SALOMELAUNCHER_EXPORT SALOME_ContainerScriptPerfLog : public POA_Engines::ContainerScriptPerfLog
  79 {
  80 public:
  81   SALOME_ContainerScriptPerfLog(SALOME_ContainerPerfLog *father, const std::string& name, const std::string& code):_father(father),_name(name),_code(code) { }
  82   ~SALOME_ContainerScriptPerfLog();
  83   SALOME_ContainerPerfLog *father() const { return _father; }
  84   void setPyObj(PyObject *obj) { _pyScriptLog.set(obj); }
  85   PyObject *pyObj() { return _pyScriptLog.get(); }
  86   PortableServer::POA_var getPOA();
  87   Engines::ContainerScriptExecPerfLog_ptr addExecutionSession() override;
  88   Engines::ListOfContainerScriptExecPerfLog *listOfExecs() override;
  89   char *getCode() override;
  90   char *getName() override;
  91   const std::string& name() const { return _name; }
  92   const std::string& code() const { return _code; }
  93   void setName(const std::string& name) { _name = name; }
  94   void setCode(const std::string& code) { _code = code; }
  95   std::size_t getNumberOfSessions() const { return _sessions.size(); }
  96 public:
  97   void accept(SALOME_VisitorContainerLog &visitor);
  98 private:
  99   AutoPyRefGilSafe _pyScriptLog;
 100   SALOME_ContainerPerfLog *_father = nullptr;
 101   std::string _name;
 102   std::string _code;
 103   std::vector< Engines::ContainerScriptExecPerfLog_var > _sessions;
 104 };
 105
 106 class SALOMELAUNCHER_EXPORT SALOME_ContainerPerfLog : public POA_Engines::ContainerPerfLog
 107 {
 108 public:
 109   SALOME_ContainerPerfLog(SALOME_LogManager *father, const std::string& nameInNS, const std::string& logFile):_father(father),_name_in_ns(nameInNS),_log_file(logFile) { }
 110   ~SALOME_ContainerPerfLog();
 111   SALOME_LogManager *father() const { return _father; }
 112   void setPyObj(PyObject *obj) { _pyContLog.set(obj); }
 113   PyObject *pyObj() { return _pyContLog.get(); }
 114   PortableServer::POA_var getPOA();
 115   char *getLogFile() override;
 116   char *getContainerEntryInNS() override;
 117   Engines::ContainerScriptPerfLog_ptr addScript(const char *name, const char *code) override;
 118   Engines::ListOfContainerScriptPerfLog *listOfScripts() override;
 119   void destroy() override;
 120   const std::string& nameInNS() const { return _name_in_ns; }
 121   const std::string& logFile() const { return _log_file; }
 122   void setNameInNS(const std::string& name) { _name_in_ns = name; }
 123   void setLogFile(const std::string& logFile) { _log_file = logFile; }
 124   std::size_t getNumberOfScripts() const { return _scripts.size(); }
 125 public:
 126   void accept(SALOME_VisitorContainerLog &visitor);
 127 private:
 128   void destroyInternal();
 129 private:
 130   AutoPyRefGilSafe _pyContLog;
 131   SALOME_LogManager *_father = nullptr;
 132   std::string _name_in_ns;
 133   std::string _log_file;
 134   std::vector< Engines::ContainerScriptPerfLog_var > _scripts;
 135 };
 136
 137 enum class SafeLoggerActiveVersionType
 138 { VersionA_Activated, VersionB_Activated, NoVersion_Activated };
 139
 140 class SALOME_SafeLoggerFileHolder
 141 {
 142 public:
 143   void setFileNamePairOfLogger(const std::string& loggerFileNameA, const std::string& loggerFileNameB) { _logger_file_a = loggerFileNameA; _logger_file_b = loggerFileNameB; }
 144   void getFileNamePairOfLogger(std::string& loggerFileNameA, std::string& loggerFileNameB) { loggerFileNameA = _logger_file_a; loggerFileNameB = _logger_file_b; }
 145   void versionA_IsTheLatestValidVersion() { _version_activated = SafeLoggerActiveVersionType::VersionA_Activated; }
 146   void versionB_IsTheLatestValidVersion() { _version_activated = SafeLoggerActiveVersionType::VersionB_Activated; }
 147   std::string getLastVersionOfFileNameLogger();
 148 private:
 149   std::string _logger_file_a;
 150   std::string _logger_file_b;
 151   SafeLoggerActiveVersionType _version_activated = SafeLoggerActiveVersionType::NoVersion_Activated;
 152 };
 153
 154 class SALOMELAUNCHER_EXPORT SALOME_LogManager : public POA_Engines::LogManager
 155 {
 156  public:
 157   SALOME_LogManager(CORBA::ORB_ptr orb, PortableServer::POA_var poa, SALOME_NamingService_Abstract *ns = nullptr);
 158   PortableServer::POA_var getPOA() { return _poa; }
 159   PyObject *pyHelper() const { return _pyLogManager; }
 160   ~SALOME_LogManager();
 161   void clear() override;
 162   Engines::ContainerPerfLog_ptr declareContainer(const char *contInNS, const char *logfile) override;
 163   Engines::ListOfContainerPerfLog *listOfContainerLogs() override;
 164   SALOME::vectorOfByte *getAllStruct(bool clearMemory) override;
 165   void putStructInFileAtomic(bool clearMemory, const char *fileName) override;
 166  public:
 167   void setFileNamePairOfLogger(const char *loggerFileNameA, const char *loggerFileNameB) override;
 168   void getFileNamePairOfLogger(CORBA::String_out loggerFileNameA, CORBA::String_out loggerFileNameB) override;
 169   void versionA_IsTheLatestValidVersion() override { _safe_logger_file_holder.versionA_IsTheLatestValidVersion(); }
 170   void versionB_IsTheLatestValidVersion() override { _safe_logger_file_holder.versionB_IsTheLatestValidVersion(); }
 171   char *getLastVersionOfFileNameLogger() override;
 172  public:
 173   void removeEntryBeforeDying(SALOME_ContainerPerfLog *child);
 174  public:
 175   std::size_t getNumberOfContainers() const { return _containers.size(); }
 176  public:
 177   void accept(SALOME_VisitorContainerLog &visitor);
 178  private:
 179   std::vector<char> dumpCppInternalFrmt(bool clearMemory);
 180  private:
 181   PyObject *_pyLogManager = nullptr;
 182   std::unique_ptr<SALOME_NamingService_Abstract> _NS;
 183   PortableServer::POA_var _poa;
 184   std::vector<Engines::ContainerPerfLog_var> _containers;
 185   SALOME_SafeLoggerFileHolder _safe_logger_file_holder;
 186  public:
 187   static const char NAME_IN_NS[];
 188 };