{
std::cerr << msg << std::endl << std::flush;
}
+
+namespace SALOME
+{
+ enum class PyExecutionMode { NotSet, InProcess, OutOfProcessNoReplay, OutOfProcessWithReplay };
+
+ static constexpr char IN_PROCESS_VALUE = 0;
+ static constexpr char IN_PROCESS_VALUE_STR[] = "InProcess";
+ static constexpr char OUT_OF_PROCESS_NO_REPLAY_VALUE = 1;
+ static constexpr char OUT_OF_PROCESS_NO_REPLAY_VALUE_STR[] = "OutOfProcessNoReplay";
+ static constexpr char OUT_OF_PROCESS_WITH_REPLAY_VALUE = 2;
+ static constexpr char OUT_OF_PROCESS_WITH_REPLAY_VALUE_STR[] = "OutOfProcessWithReplay";
+
+ static PyExecutionMode FromIntToPyExecutionMode(char value)
+ {
+ switch(value)
+ {
+ case IN_PROCESS_VALUE:
+ return PyExecutionMode::InProcess;
+ case OUT_OF_PROCESS_NO_REPLAY_VALUE:
+ return PyExecutionMode::OutOfProcessNoReplay;
+ case OUT_OF_PROCESS_WITH_REPLAY_VALUE:
+ return PyExecutionMode::OutOfProcessWithReplay;
+ }
+ throw std::range_error("FromIntToPyExecutionMode : Invalid value for Py Execution Mode ! Must be in 0 (InProcess), 1 (OutOfProcessNoReplay) or 2 (OutOfProcessWithReplay) !");
+ }
+
+ static PyExecutionMode FromStrToPyExecutionMode(const std::string& value)
+ {
+ if(value == IN_PROCESS_VALUE_STR)
+ return PyExecutionMode::InProcess;
+ if(value == OUT_OF_PROCESS_NO_REPLAY_VALUE_STR)
+ return PyExecutionMode::OutOfProcessNoReplay;
+ if(value == OUT_OF_PROCESS_WITH_REPLAY_VALUE_STR)
+ return PyExecutionMode::OutOfProcessWithReplay;
+ throw std::range_error("FromStrToPyExecutionMode : Invalid str value for py execution mode !");
+ }
+
+ static std::string FromExecutionModeToStr(PyExecutionMode execMode)
+ {
+ switch(execMode)
+ {
+ case PyExecutionMode::InProcess:
+ return IN_PROCESS_VALUE_STR;
+ case PyExecutionMode::OutOfProcessNoReplay:
+ return OUT_OF_PROCESS_NO_REPLAY_VALUE_STR;
+ case PyExecutionMode::OutOfProcessWithReplay:
+ return OUT_OF_PROCESS_WITH_REPLAY_VALUE_STR;
+ default:
+ throw std::range_error("FromExecutionModeToStr : Invalid str value for py execution mode !");
+ }
+ }
+}
+
+static SALOME::PyExecutionMode DefaultPyExecMode = SALOME::PyExecutionMode::NotSet;
+
+void SALOME::SetPyExecutionMode(PyExecutionMode mode)
+{
+ DefaultPyExecMode = mode;
+}
+
+void SALOME::SetPyExecutionModeStr(const std::string& mode)
+{
+ SALOME::SetPyExecutionMode( SALOME::FromStrToPyExecutionMode(mode) );
+}
+
+std::vector<std::string> SALOME::GetAllPyExecutionModes()
+{
+ return {IN_PROCESS_VALUE_STR,OUT_OF_PROCESS_NO_REPLAY_VALUE_STR,OUT_OF_PROCESS_WITH_REPLAY_VALUE_STR};
+}
+
+std::string SALOME::GetPyExecutionModeStr()
+{
+ return SALOME::FromExecutionModeToStr( SALOME::GetPyExecutionMode() );
+}
+
+SALOME::PyExecutionMode SALOME::GetPyExecutionMode()
+{
+ auto isEnvVarSet = []() -> SALOME::PyExecutionMode
+ {
+ const char *envVar = std::getenv("SALOME_PY_EXECUTION_MODE");
+ if (envVar && (envVar[0] != '\0'))
+ {
+ const int numValue = std::stoi(envVar);
+ return SALOME::FromIntToPyExecutionMode( static_cast<char>(numValue) );
+ }
+ return SALOME::PyExecutionMode::InProcess;
+ };
+ if(DefaultPyExecMode == SALOME::PyExecutionMode::NotSet)
+ DefaultPyExecMode = isEnvVarSet();
+ return DefaultPyExecMode;
+}
#include "SALOME_Basics.hxx"
#include <string>
+#include <vector>
bool BASICS_EXPORT getSSLMode();
void BASICS_EXPORT setSSLMode(bool sslMode);
void BASICS_EXPORT WriteInStdout(const std::string& msg);
void BASICS_EXPORT WriteInStderr(const std::string& msg);
+
+namespace SALOME
+{
+ enum class PyExecutionMode;
+ void BASICS_EXPORT SetPyExecutionMode(PyExecutionMode mode);
+ void BASICS_EXPORT SetPyExecutionModeStr(const std::string& mode);
+ std::vector<std::string> BASICS_EXPORT GetAllPyExecutionModes();
+ std::string BASICS_EXPORT GetPyExecutionModeStr();
+ PyExecutionMode BASICS_EXPORT GetPyExecutionMode();
+}
%rename (SetVerbosityLevel) SetVerbosityLevelSwig;
%rename (VerbosityLevel) VerbosityLevelSwig;
+%rename (SetPyExecutionMode) SetPyExecutionModeStrSwig;
+%rename (GetPyExecutionMode) GetPyExecutionModeStrSwig;
+%rename (GetAllPyExecutionModes) GetAllPyExecutionModesSwig;
%inline
{
{
return VerbosityLevelStr();
}
+
+void SetPyExecutionModeStrSwig(const std::string& mode)
+{
+ SetPyExecutionModeStr( mode );
+}
+
+std::string GetPyExecutionModeStrSwig()
+{
+ return GetPyExecutionModeStr();
+}
+
+std::vector<std::string> GetAllPyExecutionModesSwig()
+{
+ return GetAllPyExecutionModes();
+}
}
%pythoncode %{
verbosityLevel = FromStrToVerbosityLevel(level);
}
+ std::vector<std::string> GetAllVerbosityLevelPossibilitiesStr()
+ {
+ return {ERROR_LEVEL_VALUE_STR,WARNING_LEVEL_VALUE_STR,INFO_LEVEL_VALUE_STR,DEBUG_LEVEL_VALUE_STR};
+ }
+
std::string VerbosityLevelStr()
{
return FromVerbosityLevelToStr( VerbosityLevel() );
#include "SALOME_Basics.hxx"
#include <string>
+#include <vector>
namespace SALOME
{
void BASICS_EXPORT AppendTimeClock(std::ostream& os);
VerbosityLevelType BASICS_EXPORT VerbosityLevel();
std::string BASICS_EXPORT VerbosityLevelStr();
+ std::vector<std::string> BASICS_EXPORT GetAllVerbosityLevelPossibilitiesStr();
}
*/
//=============================================================================
-Abstract_Engines_Container_i::Abstract_Engines_Container_i (CORBA::ORB_ptr orb,
+Abstract_Engines_Container_i::Abstract_Engines_Container_i (const std::string& pyContainerClsName,
+ CORBA::ORB_ptr orb,
PortableServer::POA_ptr poa,
char *containerName ,
int argc , char* argv[],
SALOME_NamingService_Container_Abstract *ns,
bool isServantAloneInProcess
) :
- _NS(nullptr),_id(0),_numInstance(0),_isServantAloneInProcess(isServantAloneInProcess)
+ _NS(nullptr),_py_container_name(pyContainerClsName),_id(0),_numInstance(0),_isServantAloneInProcess(isServantAloneInProcess)
{
_pid = (long)getpid();
CORBA::String_var sior = _orb->object_to_string(pCont);
std::ostringstream myCommand;
- myCommand << "pyCont = SALOME_Container.SALOME_Container_i('" << _containerName << "','" << sior << "'," << DFT_TIME_INTERVAL_BTW_MEASURE << ")\n";
+ myCommand << "pyCont = SALOME_Container." << this->getPyContainerClassName() << "('" << _containerName << "','" << sior << "'," << DFT_TIME_INTERVAL_BTW_MEASURE << ")\n";
INFO_MESSAGE("Python command executed : " << myCommand.str());
//[RNV]: Comment the PyEval_AcquireLock() and PyEval_ReleaseLock() because this
static Engines::Container_var _container_ref_singleton_ssl;
-Engines_Container_SSL_i *KERNEL::getContainerSA()
+Abstract_Engines_Container_SSL_i *KERNEL::getContainerSA()
{
if(!_container_singleton_ssl)
{
# \brief python implementation of container interface for Kernel
#
+import abc
import os
import sys
import traceback
#define an implementation of the container interface for embedding in Container implemented in C++
-class SALOME_Container_i:
+class SALOME_Container_Abstract_i(metaclass=abc.ABCMeta):
_orb = None
_poa = None
_containerName = ""
#-------------------------------------------------------------------------
- def __init__(self ,containerName, containerIORStr, dftTimeIntervalInMs):
+ def __init__(self, containerName, containerIORStr, dftTimeIntervalInMs):
# Warning this part of code is called at the very first step of container launching
# so logging is not instanciate. So use verbose method to discrimine if a message should be printed or not
try:
self._log = None
self._container = self._orb.string_to_object(containerIORStr)
+ @abc.abstractmethod
+ def getPyScriptCls(self):
+ raise RuntimeError("Must be overloaded")
+
@property
def logm(self):
logging.debug("Logm PID = {}".format(os.getpid()))
logscript = None
if getSSLMode():
logscript = self._log.addScript(nodeName,code)
- node=SALOME_PyNode.PyScriptNode_i(nodeName,code,self._poa,self, logscript)
+ cls = self.getPyScriptCls()
+ node = cls(nodeName,code,self._poa,self, logscript)
id_o = self._poa.activate_object(node)
comp_o = self._poa.id_to_reference(id_o)
comp_iors = self._orb.object_to_string(comp_o)
def SetMonitoringtimeresms(self , value):
self._timeIntervalInMs = value
+
+class SALOME_Container_i(SALOME_Container_Abstract_i):
+ def __init__(self, containerName, containerIORStr, dftTimeIntervalInMs):
+ super().__init__(containerName, containerIORStr, dftTimeIntervalInMs)
+
+ def getPyScriptCls(self):
+ return SALOME_PyNode.PyScriptNode_i
+
+class SALOME_Container_OutOfProcess_i(SALOME_Container_i):
+ def __init__(self, containerName, containerIORStr, dftTimeIntervalInMs):
+ super().__init__(containerName, containerIORStr, dftTimeIntervalInMs)
+
+ def getPyScriptCls(self):
+ return SALOME_PyNode.PyScriptNode_OutOfProcess_i
+
+class SALOME_Container_OutOfProcess_Replay_i(SALOME_Container_i):
+ def __init__(self, containerName, containerIORStr, dftTimeIntervalInMs):
+ super().__init__(containerName, containerIORStr, dftTimeIntervalInMs)
+
+ def getPyScriptCls(self):
+ return SALOME_PyNode.PyScriptNode_i
{
public:
Abstract_Engines_Container_i();
- Abstract_Engines_Container_i(CORBA::ORB_ptr orb,
+ Abstract_Engines_Container_i(const std::string& pyContainerClsName,
+ CORBA::ORB_ptr orb,
PortableServer::POA_ptr poa,
char *containerName,
int argc, char *argv[],
virtual bool isSSLMode() const = 0;
+ std::string getPyContainerClassName() const { return _py_container_name; }
+
// --- CORBA methods
virtual bool load_component_Library(const char *componentName, CORBA::String_out reason);
std::string _logfilename;
std::string _localfilename;
std::string _load_script;
+ std::string _py_container_name;
CORBA::ORB_var _orb;
PortableServer::POA_var _poa;
PortableServer::ObjectId *_id;
bool _isServantAloneInProcess;
};
+constexpr char PY_CONTAINER_CLS_NAME_IN_PROCESS[] = "SALOME_Container_i";
+constexpr char PY_CONTAINER_CLS_NAME_OUT_PROCESS_NO_REPLAY[] = "SALOME_Container_OutOfProcess_i";
+constexpr char PY_CONTAINER_CLS_NAME_OUT_PROCESS_WITH_REPLAY[] = "SALOME_Container_OutOfProcess_Replay_i";
+
+
class CONTAINER_EXPORT Engines_Container_i : public Abstract_Engines_Container_i
{
public:
int argc, char *argv[],
SALOME_NamingService_Container_Abstract *ns = nullptr,
bool isServantAloneInProcess = true) :
- Abstract_Engines_Container_i(orb, poa, containerName, argc, argv, ns, isServantAloneInProcess) {}
+ Abstract_Engines_Container_i(PY_CONTAINER_CLS_NAME_IN_PROCESS, orb, poa, containerName, argc, argv, ns, isServantAloneInProcess) {}
bool isSSLMode() const override { return false; }
};
-class CONTAINER_EXPORT Engines_Container_SSL_i : public Abstract_Engines_Container_i
+class CONTAINER_EXPORT Abstract_Engines_Container_SSL_i : public Abstract_Engines_Container_i
{
public:
- Engines_Container_SSL_i();
- Engines_Container_SSL_i(CORBA::ORB_ptr orb,
+ Abstract_Engines_Container_SSL_i(const std::string& pyContainerClsName,
+ CORBA::ORB_ptr orb,
PortableServer::POA_ptr poa,
char *containerName,
int argc, char *argv[],
SALOME_NamingService_Container_Abstract *ns = nullptr,
bool isServantAloneInProcess = true) :
- Abstract_Engines_Container_i(orb, poa, containerName, argc, argv, ns, isServantAloneInProcess) {}
+ Abstract_Engines_Container_i(pyContainerClsName, orb, poa, containerName, argc, argv, ns, isServantAloneInProcess) {}
bool isSSLMode() const override { return true; }
};
+class CONTAINER_EXPORT Engines_Container_SSL_i : public Abstract_Engines_Container_SSL_i
+{
+public:
+ Engines_Container_SSL_i(CORBA::ORB_ptr orb,
+ PortableServer::POA_ptr poa,
+ char *containerName,
+ int argc, char *argv[],
+ SALOME_NamingService_Container_Abstract *ns = nullptr,
+ bool isServantAloneInProcess = true) :
+ Abstract_Engines_Container_SSL_i(PY_CONTAINER_CLS_NAME_IN_PROCESS, orb, poa, containerName, argc, argv, ns, isServantAloneInProcess) {}
+};
+
+class CONTAINER_EXPORT Engines_Container_SSL_OutOfProcess_i : public Abstract_Engines_Container_SSL_i
+{
+public:
+ Engines_Container_SSL_OutOfProcess_i(CORBA::ORB_ptr orb,
+ PortableServer::POA_ptr poa,
+ char *containerName,
+ int argc, char *argv[],
+ SALOME_NamingService_Container_Abstract *ns = nullptr,
+ bool isServantAloneInProcess = true) :
+ Abstract_Engines_Container_SSL_i(PY_CONTAINER_CLS_NAME_OUT_PROCESS_NO_REPLAY, orb, poa, containerName, argc, argv, ns, isServantAloneInProcess) {}
+};
+
+class CONTAINER_EXPORT Engines_Container_SSL_OutOfProcess_Replay_i : public Abstract_Engines_Container_SSL_i
+{
+public:
+ Engines_Container_SSL_OutOfProcess_Replay_i(CORBA::ORB_ptr orb,
+ PortableServer::POA_ptr poa,
+ char *containerName,
+ int argc, char *argv[],
+ SALOME_NamingService_Container_Abstract *ns = nullptr,
+ bool isServantAloneInProcess = true) :
+ Abstract_Engines_Container_SSL_i(PY_CONTAINER_CLS_NAME_OUT_PROCESS_WITH_REPLAY, orb, poa, containerName, argc, argv, ns, isServantAloneInProcess) {}
+};
+
/*!
* Methods to be used in SSL mode to skip NS.
*/
namespace KERNEL
{
- CONTAINER_EXPORT Engines_Container_SSL_i *getContainerSA();
+ CONTAINER_EXPORT Abstract_Engines_Container_SSL_i *getContainerSA();
CONTAINER_EXPORT Engines::Container_var getContainerRefSA();
} // namespace KERNEL
import SALOME__POA
import SALOME
import logging
+import abc
import os
import sys
from SALOME_ContainerHelper import ScriptExecInfo
{banner}
"""
-def ExecCrashProof( code, context, outargsname ):
+def ExecCrashProofGeneric( code, context, outargsname, keepFilesToReplay ):
"""
Equivalent of exec(code,context) but executed in a separate subprocess to avoid to make the current process crash.
code (str) : python code to be executed using context
context (dict) : context to be used for execution. This context will be updated in accordance with the execution of code.
+ keepFilesToReplay (bool) : if True when something goes wrong during execution all the files to replay post mortem case are kept. If False only error is reported but files to replay are destoyed.
"""
import tempfile
import pickle
context.update( evParams.result )
evParams.destroyOnOK()
if returnCode != 0:
- evParams.destroyOnKO()
+ if keepFilesToReplay:
+ evParams.destroyOnKO()
+ else:
+ evParams.destroyOnOK()
raise RuntimeError(f"Subprocess launched {evParams.strDependingOnReturnCode(returnCode)}stdout :\n{stdout}\nstderr :\n{stderr}")
+def ExecCrashProofWithReplay( code, context, outargsname ):
+ return ExecCrashProofGeneric(code, context, outargsname, True)
+
+def ExecCrashProofWithoutReplay( code, context, outargsname ):
+ return ExecCrashProofGeneric(code, context, outargsname, False)
+
def ExecLocal( code, context, outargsname ):
exec( code, context )
def finalizeAndPushToMaster(self):
self._remote_handle.assign( pickle.dumps( self._current_instance ) )
-class PyScriptNode_i (Engines__POA.PyScriptNode,Generic):
+class PyScriptNode_Abstract_i(Engines__POA.PyScriptNode,Generic,metaclass=abc.ABCMeta):
"""The implementation of the PyScriptNode CORBA IDL that executes a script"""
- def __init__(self, nodeName,code,poa,my_container,logscript):
+ def __init__(self, nodeName, code, poa, my_container, logscript):
"""Initialize the node : compilation in the local context"""
Generic.__init__(self,poa)
self.nodeName=nodeName
self._log_script = logscript
self._current_execution_session = None
sys.stdout.flush() ; sys.stderr.flush() # flush to correctly capture log per execution session
+
+ @abc.abstractmethod
+ def executeNow(self, outargsname):
+ raise RuntimeError("Must be overloaded")
def __del__(self):
# force removal of self.context. Don t know why it s not done by default
##
self.addInfoOnLevel2("measureTimeResolution",self.my_container_py.monitoringtimeresms())
with GenericPythonMonitoringLauncherCtxMgr( CPUMemoryMonitoring( self.my_container_py.monitoringtimeresms() ) ) as monitoringParams:
- exec(self.ccode, self.context)
+ self.executeNow( outargsname )
cpumeminfo = ReadCPUMemInfo( monitoringParams )
##
self.addInfoOnLevel2("CPUMemDuringExec",cpumeminfo)
def addTimeInfoOnLevel2(self, key):
from datetime import datetime
self._current_execution_session.addInfoOnLevel2(key,datetime.now())
+
+class PyScriptNode_i(PyScriptNode_Abstract_i):
+ def __init__(self, nodeName, code, poa, my_container, logscript):
+ super().__init__(nodeName, code, poa, my_container, logscript)
+
+ def executeNow(self, outargsname):
+ ExecLocal(self.ccode,self.context,outargsname)
+
+class PyScriptNode_OutOfProcess_i(PyScriptNode_Abstract_i):
+ def __init__(self, nodeName, code, poa, my_container, logscript):
+ super().__init__(nodeName, code, poa, my_container, logscript)
+
+ def executeNow(self, outargsname):
+ ExecCrashProofWithoutReplay(self.ccode,self.context,outargsname)
+
+class PyScriptNode_OutOfProcess_Replay_i(PyScriptNode_Abstract_i):
+ def __init__(self, nodeName, code, poa, my_container, logscript):
+ super().__init__(nodeName, code, poa, my_container, logscript)
+
+ def executeNow(self, outargsname):
+ ExecCrashProofWithReplay(self.ccode,self.context,outargsname)
