void setVerbosity(in boolean activated, in string level);
- //! Shutdown the Container process.
+ //! Shutdown the Container process. Shutdown is not immediate. It waits for all remaining invokation completion.
void Shutdown();
+ //! Shutdown the Container process. Shutdown is immediate for this method.
+ void ShutdownNow();
+
//! Returns the hostname of the container
string getHostName();
//! Currently: get, start, getorstart, findorstart, find
Container GiveContainer(in ContainerParameters params) raises (SALOME::SALOME_Exception);
- //! Shutdown all containers that have been launched by the container manager
+ //! Shutdown all containers that have been launched by the container manager. This termination is soft. It means that orb.shutdown is invoked meaning that completion of all CORBA
void ShutdownContainers();
+
+ //! Stronger version than ShutdownContainers. This method does not wait for completion of last CORBA invokation on containers. It terminates them
+ void ShutdownContainersNow();
long GetTimeOutToLaunchServerInSecond();
{
public:
AutoPyRef(PyObject *pyobj=nullptr):_pyobj(pyobj) { }
- virtual ~AutoPyRef() { release(); }
+ ~AutoPyRef() { release(); }
AutoPyRef(const AutoPyRef& other):_pyobj(other._pyobj) { if(_pyobj) Py_XINCREF(_pyobj); }
AutoPyRef(AutoPyRef&& other) = default;
AutoPyRef& operator=(const AutoPyRef& other) { if(_pyobj==other._pyobj) return *this; release(); _pyobj=other._pyobj; Py_XINCREF(_pyobj); return *this; }
AutoPyRefGilSafe(PyObject *pyobj=nullptr):AutoPyRef(pyobj) { }
~AutoPyRefGilSafe() { AutoGIL agil; release(); }
};
+
+class AutoPyYielder
+{
+private:
+ PyThreadState *_save = nullptr;
+public:
+ AutoPyYielder() { _save = PyEval_SaveThread(); }
+ ~AutoPyYielder() { PyEval_RestoreThread(_save); }
+};
{
_pid = (long)getpid();
- if(ns)
+ if( isServantAloneInProcess )
ActSigIntHandler() ;
_argc = argc ;
*/
//=============================================================================
void Abstract_Engines_Container_i::Shutdown()
+{
+ ShutdownCommonPart();
+ if(_isServantAloneInProcess)
+ {
+ MESSAGE("Effective Shutdown of container Begins...");
+ try
+ {
+ if(!CORBA::is_nil(_orb))
+ _orb->shutdown(0);
+ }
+ catch(...)
+ {
+ }
+ MESSAGE("Effective Shutdown of container Ends...");
+ }
+}
+
+void Abstract_Engines_Container_i::ShutdownCommonPart()
{
MESSAGE("Engines_Container_i::Shutdown()");
}
}
_listInstances_map.clear();
-
+ MESSAGE("Engines_Container_i::Shutdown() -- step 2");
// NS unregistering may throw in SSL mode if master process hosting SALOME_Embedded_NamingService servant has vanished
// In this case it's skip it and still continue.
try
catch(...)
{
}
- //
- this->cleanAllPyScripts();
- //
+ MESSAGE("Engines_Container_i::Shutdown() -- step 3");
+ try
{
- AutoGIL gstate;
- AutoPyRef result = PyObject_CallMethod(_pyCont, (char*)"shutdownPy", (char*)"",nullptr);
+ this->cleanAllPyScripts();
+ //
+ {
+ AutoGIL gstate;
+ AutoPyRef result = PyObject_CallMethod(_pyCont, (char*)"shutdownPy", (char*)"",nullptr);
+ }
}
- //
- if(_isServantAloneInProcess)
+ catch(...)
{
- MESSAGE("Effective Shutdown of container Begins...");
- if(!CORBA::is_nil(_orb))
- _orb->shutdown(0);
+ }
+ MESSAGE("Engines_Container_i::Shutdown() -- step 4");
+}
+
+void Abstract_Engines_Container_i::ShutdownNow()
+{
+ ShutdownCommonPart();if(_isServantAloneInProcess)
+ {
+ AutoGIL gstate;
+ AutoPyRef result = PyObject_CallMethod(_pyCont, (char*)"killMe", (char*)"",nullptr);
}
}
#self._log.destroy()# TODO : choose to destroy perf report or not. For the moment we keep the report
pass
+ def killMe(self):
+ import signal
+ os.kill( os.getpid() , signal.SIGTERM)
+
def setLogFileName(self, logFileName):
logging.debug("setLogFileName {} PID = {}".format(logFileName,os.getpid()))
if getSSLMode():
*/
//=============================================================================
-void SALOME_ContainerManager::ShutdownContainers()
+void SALOME_ContainerManager::ShutdownContainersGeneric(std::function<void(Engines::Container_ptr)> funcToBeCalledOnContainer)
{
- MESSAGE("ShutdownContainers");
+ MESSAGE("ShutdownContainersGeneric");
if(!_NS)
return ;
SALOME::Session_var session = SALOME::Session::_nil();
Engines::Container_var cont=Engines::Container::_narrow(obj);
if(!CORBA::is_nil(cont))
{
- MESSAGE("ShutdownContainers: " << (*iter));
- cont->Shutdown();
+ MESSAGE("ShutdownContainersGeneric: " << (*iter));
+ funcToBeCalledOnContainer( cont );
+ MESSAGE("ShutdownContainersGeneric: after call of shutdown" << (*iter));
}
else
- MESSAGE("ShutdownContainers: no container ref for " << (*iter));
+ MESSAGE("ShutdownContainersGeneric: no container ref for " << (*iter));
}
catch(CORBA::SystemException& e)
{
}
}
+void SALOME_ContainerManager::ShutdownContainers()
+{
+ this->ShutdownContainersGeneric( [](Engines::Container_ptr cont) { cont->Shutdown(); } );
+}
+
+void SALOME_ContainerManager::ShutdownContainersNow()
+{
+ this->ShutdownContainersGeneric( [](Engines::Container_ptr cont)
+ {
+ try
+ {
+ cont->ShutdownNow();
+ }
+ catch(...)
+ {
+ }
+ }
+ );
+}
+
void SALOME_ContainerManager::SetOverrideEnvForContainers(const Engines::KeyValDict& env)
{
this->_override_env.clear();
#include <vector>
#include <string>
#include <utility>
+#include <functional>
#include <set>
class SALOME_NamingService_Abstract;
void ShutdownContainers() override;
+ void ShutdownContainersNow() override;
+
void SetOverrideEnvForContainers(const Engines::KeyValDict& env) override;
Engines::KeyValDict *GetOverrideEnvForContainers() override;
static const char *_ContainerManagerNameInNS;
+private:
+
+ void ShutdownContainersGeneric(std::function<void(Engines::Container_ptr)> funcToBeCalledOnContainer);
+
protected:
// C++ methods
Engines::Container_ptr
// CASCatch_SignalsHandler aSignalsHandler;
try {
theORB->run();
+ INFOS("ORB run finished...");
// CCRT porting
// }catch(CORBA::SystemException&){
// Handle(Standard_Failure) aFail = Standard_Failure::Caught();
void verbosity(bool& activated, CORBA::String_out level) override;
void setVerbosity(bool activated, const char *level) override;
- virtual void Shutdown();
+ void Shutdown() override;
+ void ShutdownNow() override;
char *getHostName();
CORBA::Long getPID();
//! Kill current container
PortableServer::ObjectId *getCORBAId() const { return _id; }
public:
static const int DFT_TIME_INTERVAL_BTW_MEASURE;
+private:
+ void ShutdownCommonPart();
protected:
static std::map<std::string, int> _cntInstances_map;
static std::map<std::string, void *> _library_map; // library names, loaded
type(logm).Fetch = LogManagerFetch
type(logm).DumpInFile = LogManagerDumpInFile
type(logm).LaunchMonitoringDumpFile = LogManagerLaunchMonitoringDumpFile
+ type(logm).FinalFetchBeforeDying = LogManagerFinalFetchBeforeDying
type(logm).GetLatestMonitoringDumpFile = LogManagerGetLatestMonitoringDumpFile
type(logm).DumpIORInFile = LogManagerDumpIORInFile
#
with open(iorfakensfile,"w") as iorfakensf:
iorfakensf.write(NamingService.IOROfNS())
+CM_NAME_IN_NS = "/ContainerManager"
+RM_NAME_IN_NS = "/ResourcesManager"
+DSM_NAME_IN_NS = "/DataServerManager"
+ESM_NAME_IN_NS = "/ExternalServers"
+LOGM_NAME_IN_NS = "/LogManager"
+
def salome_init_without_session_attached(path=None, embedded=False):
"""
Configuration SSL inside a python interpretor launched in the SALOME_Container_No_NS_Serv.
import KernelBasis
nsAbroad = orb.string_to_object( KernelBasis.getIOROfEmbeddedNS() )
import SALOME
- CM_NAME_IN_NS = "/ContainerManager"
cm = orb.string_to_object( nsAbroad.Resolve(CM_NAME_IN_NS).decode() )
type(cm).SetOverrideEnvForContainersSimple = ContainerManagerSetOverrideEnvForContainersSimple
naming_service.Register(cm,CM_NAME_IN_NS)
- RM_NAME_IN_NS = "/ResourcesManager"
rm = orb.string_to_object( nsAbroad.Resolve(RM_NAME_IN_NS).decode() )
naming_service.Register(rm,RM_NAME_IN_NS)
#
from LifeCycleCORBA import LifeCycleCORBASSL
lcc = LifeCycleCORBASSL()
- DSM_NAME_IN_NS = "/DataServerManager"
dsm = orb.string_to_object( nsAbroad.Resolve(DSM_NAME_IN_NS).decode() )
naming_service.Register(dsm,DSM_NAME_IN_NS)
#
- ESM_NAME_IN_NS = "/ExternalServers"
esm = orb.string_to_object( nsAbroad.Resolve(ESM_NAME_IN_NS).decode() )
naming_service.Register(esm,ESM_NAME_IN_NS)
#
- LOGM_NAME_IN_NS = "/LogManager"
logm = orb.string_to_object( nsAbroad.Resolve(LOGM_NAME_IN_NS).decode() )
naming_service.Register(logm,LOGM_NAME_IN_NS)
tempFileName = f.name
return LoadAndWrite( logm, tempFileName )
+def LogManagerFinalFetchBeforeDying(self):
+ import shutil
+ a,b = self.getFileNamePairOfLogger()
+ self.DumpInFile( b )
+ shutil.move( b, a)
+
def LogManagerGetLatestMonitoringDumpFile(self):
import shutil
import logging
logging.debug("LogManagerGetLatestMonitoringDumpFile SITUATION A")
if os.path.exists( b ):
os.remove( b )
+ self.FinalFetchBeforeDying()
return a
if lastVersion == b:
logging.debug("LogManagerGetLatestMonitoringDumpFile SITUATION B")
if os.path.exists( b ):
shutil.move( b, a)
+ self.FinalFetchBeforeDying()
return a
logging.warning("in LogManagerGetLatestMonitoringDumpFile an unexpected situation araises.")
return ""
#to expose all objects to pydoc
-__all__=dir()
+__all__ = dir()
with open( iorFileName, "w" ) as f:
f.write( cls.IOROfNS() )
NamingService.DumpIORInFile = classmethod(NamingService_DumpIORInFile)
+def NamingService_LoadIORInFile(cls,iorFileName):
+ import Engines
+ import CORBA
+ orb=CORBA.ORB_init([''])
+ with open( iorFileName ) as f:
+ ior = f.read()
+ ref = orb.string_to_object(ior)
+ return ref
+NamingService.LoadIORInFile = classmethod( NamingService_LoadIORInFile )
def NamingService_KillContainersInFile(cls,logFileName):
import Engines
import CORBA
