X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FLifeCycleCORBA%2FSALOME_LifeCycleCORBA.cxx;h=08223ade7cec6f02c61e67296d59eb984d7a01f1;hb=a98a09635ad776cf8eb98664e0933760eb9edbe4;hp=d846594ab4f36f81bd135c075a4973128059ff54;hpb=bdfedda34da6a6b254d16373a7d4d1a7861d896c;p=modules%2Fkernel.git diff --git a/src/LifeCycleCORBA/SALOME_LifeCycleCORBA.cxx b/src/LifeCycleCORBA/SALOME_LifeCycleCORBA.cxx index d846594ab..08223ade7 100644 --- a/src/LifeCycleCORBA/SALOME_LifeCycleCORBA.cxx +++ b/src/LifeCycleCORBA/SALOME_LifeCycleCORBA.cxx @@ -1,228 +1,844 @@ -// SALOME LifeCycleCORBA : implementation of containers and engines life cycle both in Python and C++ +// Copyright (C) 2007-2021 CEA/DEN, EDF R&D, OPEN CASCADE +// +// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, +// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS // -// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, -// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS -// -// This library is free software; you can redistribute it and/or -// modify it under the terms of the GNU Lesser General Public -// License as published by the Free Software Foundation; either -// version 2.1 of the License. -// -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -// Lesser General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public -// License along with this library; if not, write to the Free Software -// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -// -// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. // +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. // +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA // +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// + +// SALOME LifeCycleCORBA : implementation of containers and engines life cycle both in Python and C++ // File : SALOME_LifeCycleCORBA.cxx // Author : Paul RASCLE, EDF // Module : SALOME -// $Header$ #include #include #include #include -#include "OpUtil.hxx" +#include +#ifndef WIN32 + #include + #include +#endif + +#include "Basics_Utils.hxx" #include "utilities.h" #include #include "SALOME_LifeCycleCORBA.hxx" +#include "SALOME_ResourcesManager.hxx" +#include "SALOMESDS_DataServerManager.hxx" +#include "SALOME_ExternalServerLauncher.hxx" + #include CORBA_CLIENT_HEADER(SALOME_ModuleCatalog) +#include CORBA_CLIENT_HEADER(SALOME_Session) +#include CORBA_CLIENT_HEADER(DSC_Engines) +#include CORBA_CLIENT_HEADER(SALOME_Registry) +#include CORBA_CLIENT_HEADER(SALOMEDS) +#include CORBA_CLIENT_HEADER(SALOME_SDS) +#include CORBA_CLIENT_HEADER(Logger) +#include CORBA_CLIENT_HEADER(SALOME_Launcher) + +#include "SALOME_ResourcesManager.hxx" #include "SALOME_ContainerManager.hxx" #include "SALOME_Component_i.hxx" #include "SALOME_NamingService.hxx" -using namespace std; +#include "SALOME_FileTransferCORBA.hxx" + +IncompatibleComponent::IncompatibleComponent( void ): + SALOME_Exception( "IncompatibleComponent" ) +{ +} + +IncompatibleComponent::IncompatibleComponent(const IncompatibleComponent &ex): + SALOME_Exception( ex ) +{ +} + +/*! \class SALOME_LifeCycleCORBA + \brief A class to manage life cycle of SALOME components. + +*/ + +//============================================================================= +/*! + * Constructor + */ +//============================================================================= -SALOME_LifeCycleCORBA::SALOME_LifeCycleCORBA(SALOME_NamingService *ns) +SALOME_LifeCycleCORBA::SALOME_LifeCycleCORBA(SALOME_NamingService_Abstract *ns) { - _NS = ns; + // be sure to have an instance of traceCollector, when used via SWIG + // in a Python module + int argc = 0; + char *xargv = (char*)""; + char **argv = &xargv; + CORBA::ORB_var orb = CORBA::ORB_init(argc, argv); + // LocalTraceCollector *myThreadTrace = SALOMETraceCollector::instance(orb); + _NSnew=0; + if (!ns) + { + _NS = new SALOME_NamingService(orb); + _NSnew=_NS; + } + else _NS = ns; //add try catch - CORBA::Object_var obj=_NS->Resolve(SALOME_ContainerManager::_ContainerManagerNameInNS); - ASSERT( !CORBA::is_nil(obj)); - _ContManager=Engines::ContainerManager::_narrow(obj); + _NS->Change_Directory("/"); // mpv 250105: current directory may be not root + // (in SALOMEDS for an example) + // not enough: set a current directory in naming service is not thread safe + // if naming service instance is shared among several threads... + // ==> always use absolute path and don't rely on current directory! + //if( dynamic_cast(_NS) ) + { + CORBA::Object_var obj = + _NS->Resolve(SALOME_ContainerManager::_ContainerManagerNameInNS); + if (CORBA::is_nil(obj)) + throw SALOME_Exception("Error: Cannot resolve ContainerManager in Naming Service"); + _ContManager=Engines::ContainerManager::_narrow(obj); + + obj = _NS->Resolve(SALOME_ResourcesManager::_ResourcesManagerNameInNS); + if (CORBA::is_nil(obj)) + throw SALOME_Exception("Error: Cannot resolve ResourceManager in Naming Service"); + _ResManager=Engines::ResourcesManager::_narrow(obj); + } } +//============================================================================= +/*! + * Destructor + */ +//============================================================================= + SALOME_LifeCycleCORBA::~SALOME_LifeCycleCORBA() { + if(_NSnew)delete _NSnew; } -string SALOME_LifeCycleCORBA::ContainerName( - const char * aComputerContainer , - string * theComputer , - string * theContainer ) { - char * ContainerName = new char [ strlen( aComputerContainer ) + 1 ] ; - strcpy( ContainerName , aComputerContainer ) ; - string theComputerContainer("/Containers/"); - char * slash = strchr( ContainerName , '/' ) ; - if ( !slash ) { - *theComputer = GetHostname() ; - theComputerContainer += *theComputer ; - theComputerContainer += "/" ; - *theContainer = ContainerName ; - theComputerContainer += *theContainer ; - } - else { - slash[ 0 ] = '\0' ; - slash += 1 ; - *theContainer = slash ; - if ( !strcmp( ContainerName , "localhost" ) ) { - *theComputer = GetHostname() ; +//============================================================================= +/*! \brief Find an already existing and registered component instance. + * + * \param params container parameters like type or name... + * \param componentName the name of component class + * \return a CORBA reference of the component instance, or _nil if not found + */ +//============================================================================= +Engines::EngineComponent_ptr +SALOME_LifeCycleCORBA::FindComponent(const Engines::ContainerParameters& params, + const char *componentName) +{ + if (! isKnownComponentClass(componentName)) + return Engines::EngineComponent::_nil(); + + Engines::ContainerParameters new_params(params); + new_params.resource_params.componentList.length(1); + new_params.resource_params.componentList[0] = componentName; + new_params.resource_params.can_run_containers = true; + Engines::ResourceList_var listOfResources; + try + { + listOfResources = _ResManager->GetFittingResources(new_params.resource_params); } - else { - *theComputer = ContainerName ; + catch( const SALOME::SALOME_Exception& /*ex*/ ) //!< TODO: unused variable + { + return Engines::EngineComponent::_nil(); } - theComputerContainer += *theComputer ; - theComputerContainer += "/" ; - theComputerContainer += *theContainer ; - } - delete [] ContainerName; - return theComputerContainer ; + + Engines::EngineComponent_var compo = _FindComponent(new_params, + componentName, + listOfResources); + + return compo._retn(); } -bool SALOME_LifeCycleCORBA::isKnownComponentClass(const char *componentName) +//============================================================================= +/*! \brief Load a component instance on a container defined by its parameters + * + * \param params container parameters like type or name... + * \param componentName the name of component class + * \return a CORBA reference of the component instance, or _nil if problem + */ +//============================================================================= + +Engines::EngineComponent_ptr +SALOME_LifeCycleCORBA::LoadComponent(const Engines::ContainerParameters& params, + const char *componentName) { + // --- Check if Component Name is known in ModuleCatalog + if (! isKnownComponentClass(componentName)) + return Engines::EngineComponent::_nil(); + + Engines::ContainerParameters new_params(params); + new_params.resource_params.componentList.length(1); + new_params.resource_params.componentList[0] = componentName; + new_params.resource_params.can_run_containers = true; + + Engines::ResourceList_var listOfResources; try { - CORBA::Object_var obj = _NS->Resolve("/Kernel/ModulCatalog"); - SALOME_ModuleCatalog::ModuleCatalog_var Catalog = - SALOME_ModuleCatalog::ModuleCatalog::_narrow(obj) ; - SALOME_ModuleCatalog::Acomponent_ptr compoInfo = - Catalog->GetComponent(componentName); - if (CORBA::is_nil (compoInfo)) - { - INFOS("Catalog Error : Component not found in the catalog"); - return false; - } - else return true; + listOfResources = _ResManager->GetFittingResources(new_params.resource_params); } - catch (ServiceUnreachable&) + catch( const SALOME::SALOME_Exception& /*ex*/ ) //!< TODO: unused variable { - INFOS("Caught exception: Naming Service Unreachable"); + return Engines::EngineComponent::_nil(); } - catch (...) + new_params.resource_params.resList = listOfResources; + + Engines::EngineComponent_var compo = _LoadComponent(new_params, + componentName); + + return compo._retn(); +} + +//============================================================================= +/*! \brief Find an already existing and registered component instance or load a new + * component instance on a container defined by its parameters. + * + * \param params container parameters like type or name... + * \param componentName the name of component class + * \return a CORBA reference of the component instance, or _nil if problem + */ +//============================================================================= + +Engines::EngineComponent_ptr +SALOME_LifeCycleCORBA:: +FindOrLoad_Component(const Engines::ContainerParameters& params, + const char *componentName) +{ + // --- Check if Component Name is known in ModuleCatalog + + if (! isKnownComponentClass(componentName)) + return Engines::EngineComponent::_nil(); + + Engines::ContainerParameters new_params(params); + new_params.resource_params.componentList.length(1); + new_params.resource_params.componentList[0] = componentName; + new_params.resource_params.can_run_containers = true; + + Engines::ResourceList_var listOfResources; + try { - INFOS("Caught unknown exception."); + listOfResources = _ResManager->GetFittingResources(new_params.resource_params); + } + catch( const SALOME::SALOME_Exception& /*ex*/ ) //!< TODO: unused variable + { + return Engines::EngineComponent::_nil(); } - return false; -} -string SALOME_LifeCycleCORBA::ComputerPath( - const char * theComputer ) { - CORBA::String_var path; - CORBA::Object_var obj = _NS->Resolve("/Kernel/ModulCatalog"); - SALOME_ModuleCatalog::ModuleCatalog_var Catalog = - SALOME_ModuleCatalog::ModuleCatalog::_narrow(obj) ; - try { - path = Catalog->GetPathPrefix( theComputer ); - } - catch (SALOME_ModuleCatalog::NotFound&) { - INFOS("GetPathPrefix(" << theComputer << ") not found!"); - path = "" ; + Engines::EngineComponent_var compo = _FindComponent(new_params, + componentName, + listOfResources); + + if(CORBA::is_nil(compo)) + { + new_params.resource_params.resList = listOfResources; + compo = _LoadComponent(new_params, + componentName); } - SCRUTE( path ) ; - return CORBA::string_dup( path ) ; + + return compo._retn(); } -Engines::Component_ptr SALOME_LifeCycleCORBA::FindOrLoad_Component - (const char *containerName, - const char *componentName) +//============================================================================= +/*! \brief Find an already existing and registered component instance or load a new + * component instance on a container defined by name + * + * \param containerName the name of container, under one of the forms + * - 1 aContainer (local container) + * - 2 machine/aContainer (container on hostname = machine) + * \param componentName the name of component class + * \return a CORBA reference of the component instance, or _nil if problem + */ +//============================================================================= + +Engines::EngineComponent_ptr +SALOME_LifeCycleCORBA::FindOrLoad_Component(const char *containerName, + const char *componentName) { - if (! isKnownComponentClass(componentName)) return Engines::Component::_nil(); + MESSAGE("SALOME_LifeCycleCORBA::FindOrLoad_Component INTERACTIF " << containerName << " " << componentName ) ; + + // --- Check if Component Name is known in ModuleCatalog + if (! isKnownComponentClass(componentName)) + return Engines::EngineComponent::_nil(); + + // --- Check if containerName contains machine name (if yes: rg>0) char *stContainer=strdup(containerName); - string st2Container(stContainer); - int rg=st2Container.find("/"); - if(rg<0) { - //containerName doesn't contain "/" => Local container - free(stContainer); - Engines::MachineList_var listOfMachine=new Engines::MachineList; - listOfMachine->length(1); - listOfMachine[0]=CORBA::string_dup(GetHostname().c_str()); - Engines::Component_ptr ret=FindComponent(containerName,componentName,listOfMachine.in()); - if(CORBA::is_nil(ret)) - return LoadComponent(containerName,componentName,listOfMachine); - else - return ret; - } - else { - //containerName contains "/" => Remote container + std::string st2Container(stContainer); + size_t rg=st2Container.find("/"); + + Engines::ContainerParameters params; + preSet(params); + if (rg == std::string::npos) + { + // containerName doesn't contain "/" => Local container + params.container_name = CORBA::string_dup(stContainer); + } + else + { stContainer[rg]='\0'; - Engines::MachineParameters_var params=new Engines::MachineParameters; - params->container_name=CORBA::string_dup(stContainer+rg+1); - params->hostname=CORBA::string_dup(stContainer); - params->OS=CORBA::string_dup("LINUX"); - free(stContainer); - return FindOrLoad_Component(params,componentName); + params.container_name = CORBA::string_dup(stContainer+rg+1); + params.resource_params.hostname = CORBA::string_dup(stContainer); + } + params.isMPI = false; + SCRUTE(params.container_name); + free(stContainer); + return FindOrLoad_Component(params, componentName); +} + +//============================================================================= +/*! \brief Check if the component class is known in module catalog + * + * \param componentName the name of component class + * \return true if found, false otherwise + */ +//============================================================================= + +bool SALOME_LifeCycleCORBA::isKnownComponentClass(const char *componentName) +{ + try + { + CORBA::Object_var obj = _NS->Resolve("/Kernel/ModulCatalog"); + SALOME_ModuleCatalog::ModuleCatalog_var Catalog = + SALOME_ModuleCatalog::ModuleCatalog::_narrow(obj) ; + ASSERT(! CORBA::is_nil(Catalog)); + SALOME_ModuleCatalog::Acomponent_var compoInfo = + Catalog->GetComponent(componentName); + if (CORBA::is_nil (compoInfo)) + { + MESSAGE("Catalog Error: Component not found in the catalog " << componentName); + return false; + } + else return true; } + catch (ServiceUnreachable&) + { + INFOS("Caught exception: Naming Service Unreachable"); + } + catch (...) + { + INFOS("Caught unknown exception."); + } + return false; } -Engines::Component_ptr SALOME_LifeCycleCORBA::FindOrLoad_Component(const Engines::MachineParameters& params, - const char *componentName) +//============================================================================= +/*! \brief Initialisation of a given Engines::ResourceParameters with default values. + */ +//============================================================================= + +void +SALOME_LifeCycleCORBA::preSet(Engines::ResourceParameters& params) { - if (! isKnownComponentClass(componentName)) return Engines::Component::_nil(); - Engines::MachineList_var listOfMachine=_ContManager->GetFittingResources(params,componentName); - Engines::Component_ptr ret=FindComponent(params.container_name,componentName,listOfMachine); - if(CORBA::is_nil(ret)) - return LoadComponent(params.container_name,componentName,listOfMachine); + params.name = ""; + params.hostname = ""; + params.OS = ""; + params.nb_proc = 0; + params.mem_mb = 0; + params.cpu_clock = 0; + params.nb_node = 0; + params.nb_proc_per_node = 0; + params.policy = ""; + params.can_launch_batch_jobs = false; + params.can_run_containers = false; +} + +//============================================================================= +/*! \brief Initialisation of a given Engines::ContainerParameters with default values. + */ +//============================================================================= + +void SALOME_LifeCycleCORBA::preSet( Engines::ContainerParameters& params) +{ + params.container_name = ""; + params.mode = ""; + params.workingdir = ""; + params.nb_proc = 0; + params.isMPI = false; + params.parallelLib = ""; + SALOME_LifeCycleCORBA::preSet(params.resource_params); +} + +//============================================================================= +/*! + * \return a number of processors not 0, only for MPI containers + */ +//============================================================================= + +int SALOME_LifeCycleCORBA::NbProc(const Engines::ContainerParameters& params) +{ + if( !params.isMPI ) + return 0; + else if( params.nb_proc <= 0 ) + return 1; else - return ret; -} - -Engines::Component_ptr SALOME_LifeCycleCORBA::FindComponent(const char *containerName, - const char *componentName, - const Engines::MachineList& listOfMachines) -{ - if (! isKnownComponentClass(componentName)) return Engines::Component::_nil(); - if(containerName[0]!='\0') - { - Engines::MachineList_var machinesOK=new Engines::MachineList; - unsigned int lghtOfmachinesOK=0; - machinesOK->length(listOfMachines.length()); - for(unsigned int i=0;iResolve(componentNameForNS.c_str()); - if(!CORBA::is_nil(obj)) - { - machinesOK[lghtOfmachinesOK++]=CORBA::string_dup(currentMachine); - } - } - if(lghtOfmachinesOK!=0) - { - machinesOK->length(lghtOfmachinesOK); - CORBA::String_var bestMachine=_ContManager->FindBest(machinesOK); - string componentNameForNS=Engines_Component_i::BuildComponentNameForNS(componentName,containerName,bestMachine); - CORBA::Object_var obj=_NS->Resolve(componentNameForNS.c_str()); - return Engines::Component::_narrow(obj); - } - else - return Engines::Component::_nil(); + return params.nb_proc; +} + +//============================================================================= +/*! \brief Get the container manager + * + * \return the container Manager + */ +//============================================================================= + +Engines::ContainerManager_ptr SALOME_LifeCycleCORBA::getContainerManager() +{ + Engines::ContainerManager_var contManager = + Engines::ContainerManager::_duplicate(_ContManager); + return contManager._retn(); +} + +//============================================================================= +/*! \brief Get the resources manager + * + * \return the container Manager + */ +//============================================================================= + +Engines::ResourcesManager_ptr SALOME_LifeCycleCORBA::getResourcesManager() +{ + Engines::ResourcesManager_var resManager = + Engines::ResourcesManager::_duplicate(_ResManager); + return resManager._retn(); +} + +//============================================================================= +/*! \brief shutdown all the SALOME servers except SALOME_Session_Server and omniNames + */ +//============================================================================= + +void SALOME_LifeCycleCORBA::shutdownServers(bool shutdownLauncher) +{ + // get each Container from NamingService => shutdown it + // (the order is inverse to the order of servers initialization) + + SALOME::Session_var session = SALOME::Session::_nil(); + CORBA::Long pid = 0; + CORBA::Object_var objS = _NS->Resolve("/Kernel/Session"); + if (!CORBA::is_nil(objS)) + { + session = SALOME::Session::_narrow(objS); + if (!CORBA::is_nil(session)) + { + pid = session->getPID(); + session->Shutdown(); + } + } + + std::string hostname = Kernel_Utils::GetHostname(); + + // 1) ConnectionManager + try + { + CORBA::Object_var objCnM=_NS->Resolve("/ConnectionManager"); + Engines::ConnectionManager_var connMan=Engines::ConnectionManager::_narrow(objCnM); + if ( !CORBA::is_nil(connMan) && ( pid != connMan->getPID() ) ) + connMan->ShutdownWithExit(); } + catch(const CORBA::Exception& /*e*/) //!< TODO: unused variable + { + // ignore and continue + } + + timespec ts_req; + ts_req.tv_nsec=100000000; + ts_req.tv_sec=0; + +//Wait some time so that ConnectionManager be completely shutdown +#ifndef WIN32 + nanosleep(&ts_req,0); +#endif + + // 2) SALOMEDS + try + { + CORBA::Object_var objSDS = _NS->Resolve("/Study"); + SALOMEDS::Study_var study = SALOMEDS::Study::_narrow(objSDS) ; + if ( !CORBA::is_nil(study) && ( pid != study->getPID() ) ) + study->Shutdown(); + _NS->Destroy_Name("/Study"); + } + catch(const CORBA::Exception& /*e*/) //!< TODO: unused variable + { + // ignore and continue + } + +//Wait some time so that study be completely shutdown +#ifndef WIN32 + nanosleep(&ts_req,0); +#endif + + // 3) ModuleCatalog + try + { + CORBA::Object_var objMC=_NS->Resolve("/Kernel/ModulCatalog"); + SALOME_ModuleCatalog::ModuleCatalog_var catalog = SALOME_ModuleCatalog::ModuleCatalog::_narrow(objMC); + if ( !CORBA::is_nil(catalog) && ( pid != catalog->getPID() ) ) + catalog->shutdown(); + _NS->Destroy_Name("/Kernel/ModulCatalog"); + } + catch(const CORBA::Exception& /*e*/) //!< TODO: unused variable + { + // ignore and continue + } + +//Wait some time so that ModulCatalog be completely shutdown +#ifndef WIN32 + nanosleep(&ts_req,0); +#endif + // 4 ) Remote ScopeServer (the DataServer is hosted by SalomeLauncher shutdown right after on point 6) + try + { + CORBA::Object_var objDSM(_NS->Resolve(SALOMESDS::DataServerManager::NAME_IN_NS)); + SALOME::DataServerManager_var dsm(SALOME::DataServerManager::_narrow(objDSM)); + if ( !CORBA::is_nil(dsm) ) + dsm->shutdownScopes(); + } + catch(const CORBA::Exception& /*e*/) //!< TODO: unused variable + { + // ignore and continue + } + // 5) External server launcher (the ExternalServer is hosted by SalomeLauncher shutdown right after on point 6) + try + { + CORBA::Object_var objDSM(_NS->Resolve(SALOME_ExternalServerLauncher::NAME_IN_NS)); + SALOME::ExternalServerLauncher_var dsm(SALOME::ExternalServerLauncher::_narrow(objDSM)); + if ( !CORBA::is_nil(dsm) ) + dsm->shutdownServers(); + } + catch(const CORBA::Exception& /*e*/) //!< TODO: unused variable + { + // ignore and continue + } + // 6) SalomeLauncher + try + { + if(shutdownLauncher){ + CORBA::Object_var objSL = _NS->Resolve("/SalomeLauncher"); + Engines::SalomeLauncher_var launcher = Engines::SalomeLauncher::_narrow(objSL); + if (!CORBA::is_nil(launcher) && (pid != launcher->getPID())) + launcher->Shutdown(); + } + } + catch(const CORBA::Exception& /*e*/) //!< TODO: unused variable + { + // ignore and continue + } + +//Wait some time so that launcher be completely shutdown +#ifndef WIN32 + nanosleep(&ts_req,0); +#endif + + // 6) Registry + try + { + CORBA::Object_var objR = _NS->Resolve("/Registry"); + Registry::Components_var registry = Registry::Components::_narrow(objR); + if ( !CORBA::is_nil(registry) && ( pid != registry->getPID() ) ) + registry->Shutdown(); + _NS->Destroy_Name("/Registry"); + } + catch(const CORBA::Exception& /*e*/) //!< TODO: unused variable + { + // ignore and continue + } + + // 7) Logger + int argc = 0; + char *xargv = (char*)""; + char **argv = &xargv; + CORBA::ORB_var orb = CORBA::ORB_init(argc, argv); + + CORBA::Object_var objLog = CORBA::Object::_nil(); + CosNaming::NamingContext_var inc; + CORBA::Object_var theObj = CORBA::Object::_nil(); + std::string stdname = "Logger"; + CosNaming::Name name; + name.length(1); + name[0].id = CORBA::string_dup(stdname.c_str()); + try + { + if(!CORBA::is_nil(orb)) + theObj = orb->resolve_initial_references("NameService"); + if (!CORBA::is_nil(theObj)) + inc = CosNaming::NamingContext::_narrow(theObj); + } + catch(...) + { + } + if(!CORBA::is_nil(inc)) + { + try + { + objLog = inc->resolve(name); + SALOME_Logger::Logger_var logger = SALOME_Logger::Logger::_narrow(objLog); + if ( !CORBA::is_nil(logger) ) + logger->shutdown(); + } + catch(...) + { + } + } +} + +//============================================================================= +/*! \brief shutdown omniNames + */ +//============================================================================= + +void SALOME_LifeCycleCORBA::killOmniNames() +{ + std::string portNumber (::getenv ("NSPORT") ); + std::string python_exe; + + python_exe = std::string("python3"); + + if ( !portNumber.empty() ) + { + std::string cmd; + + cmd = std::string("from salome_utils import killOmniNames; "); + cmd += std::string("killOmniNames(") + portNumber + "); "; + cmd = python_exe + std::string(" -c \"") + cmd +"\""; + MESSAGE(cmd); + system( cmd.c_str() ); + + cmd = std::string("from killSalomeWithPort import cleanApplication; "); + cmd += std::string("cleanApplication(") + portNumber + "); "; + cmd = python_exe + std::string(" -c \"") + cmd +"\""; + MESSAGE(cmd); + system( cmd.c_str() ); + } + + // shutdown portmanager + if ( !portNumber.empty() ) + { + std::string cmd; + + cmd = std::string("from PortManager import releasePort; "); + cmd += std::string("releasePort(") + portNumber + "); "; + cmd = python_exe + std::string(" -c \"") + cmd +"\""; + MESSAGE(cmd); + system( cmd.c_str() ); + } +} + +//============================================================================= +/*! \brief Find an already existing and registered component instance. + * + * - build a list of machines on which an instance of the component is running, + * - find the best machine among the list + * + * \param params machine parameters like type or name... + * \param componentName the name of component class + * \param listOfMachines list of machine address + * \return a CORBA reference of the component instance, or _nil if not found + */ +//============================================================================= + +Engines::EngineComponent_ptr +SALOME_LifeCycleCORBA:: +_FindComponent(const Engines::ContainerParameters& params, + const char *componentName, + const Engines::ResourceList& listOfResources) +{ + // --- build the list of machines on which the component is already running + const char *containerName = params.container_name; + int nbproc = NbProc(params); + + Engines::ResourceList_var resourcesOK = new Engines::ResourceList; + + unsigned int lghtOfresourcesOK = 0; + resourcesOK->length(listOfResources.length()); + + for(unsigned int i=0; i < listOfResources.length(); i++) + { + const char * currentResource = listOfResources[i]; + Engines::ResourceDefinition_var resource_definition = + _ResManager->GetResourceDefinition(currentResource); + CORBA::Object_var obj = _NS->ResolveComponent(resource_definition->hostname.in(), + containerName, + componentName, + nbproc); + if (!CORBA::is_nil(obj)) + resourcesOK[lghtOfresourcesOK++] = CORBA::string_dup(currentResource); + } + + // --- find the best machine among the list + if(lghtOfresourcesOK != 0) + { + resourcesOK->length(lghtOfresourcesOK); + CORBA::String_var bestResource = _ResManager->FindFirst(resourcesOK); + Engines::ResourceDefinition_var resource_definition = + _ResManager->GetResourceDefinition(bestResource); + CORBA::Object_var obj = _NS->ResolveComponent(resource_definition->hostname.in(), + containerName, + componentName, + nbproc); + return Engines::EngineComponent::_narrow(obj); + } else + return Engines::EngineComponent::_nil(); +} + +//============================================================================= +/*! \brief Load a component instance. + * + * - Finds a container in the list of machine or start one. + * - Try to load the component library in the container, + * - then create an instance of the component. + * + * \param params machine parameters like type or name... + * \param componentName the name of component class + * \return a CORBA reference of the component instance, or _nil if problem + */ +//============================================================================= + +Engines::EngineComponent_ptr +SALOME_LifeCycleCORBA:: +_LoadComponent(const Engines::ContainerParameters& params, + const char *componentName) +{ + MESSAGE("_LoadComponent, required " << params.container_name << + " " << componentName << " " << NbProc(params)); + + Engines::ContainerParameters local_params(params); + local_params.mode = CORBA::string_dup("findorstart"); + Engines::Container_var cont = _ContManager->GiveContainer(local_params); + if (CORBA::is_nil(cont)) return Engines::EngineComponent::_nil(); + + char* reason; + bool isLoadable = cont->load_component_Library(componentName,reason); + if (!isLoadable) { - //user specified no container name so trying to find a component in the best machine among listOfMachines - CORBA::String_var bestMachine=_ContManager->FindBest(listOfMachines); - //Normally look at all containers launched on bestMachine to see if componentName is already launched on one of them. To do.. - string componentNameForNS=Engines_Component_i::BuildComponentNameForNS(componentName,containerName,bestMachine); - CORBA::Object_var obj = _NS->Resolve(componentNameForNS.c_str()); - return Engines::Component::_narrow(obj); + //std::cerr << reason << std::endl; + CORBA::string_free(reason); + return Engines::EngineComponent::_nil(); } + CORBA::string_free(reason); + + Engines::EngineComponent_var myInstance = + cont->create_component_instance(componentName); + return myInstance._retn(); +} + +//============================================================================= +/*! \brief Load a parallel component instance. + * + * \param params machine parameters like type or name... + * \param componentName the name of component class + * \return a CORBA reference of the parallel component instance, or _nil if problem + */ +//============================================================================= +Engines::EngineComponent_ptr +SALOME_LifeCycleCORBA::Load_ParallelComponent(const Engines::ContainerParameters& params, + const char *componentName) +{ + MESSAGE("Entering LoadParallelComponent"); + +/*MESSAGE("Parameters : "); + MESSAGE("Container name : " << params.container_name); + MESSAGE("Number of component nodes : " << params.nb_component_nodes); + MESSAGE("Component Name : " << componentName);*/ + + Engines::ContainerParameters parms(params); + parms.resource_params.componentList.length(1); + parms.resource_params.componentList[0] = componentName; + parms.mode = CORBA::string_dup("findorstart"); + + MESSAGE("Starting Parallel Container"); + Engines::Container_var cont = _ContManager->GiveContainer(parms); + if (CORBA::is_nil(cont)) { + INFOS("FindOrStartParallelContainer() returns a NULL container !"); + return Engines::EngineComponent::_nil(); + } + + MESSAGE("Loading component library"); + char* reason; + bool isLoadable = cont->load_component_Library(componentName,reason); + if (!isLoadable) { + INFOS(componentName <<" library is not loadable !"); + //std::cerr << reason << std::endl; + CORBA::string_free(reason); + return Engines::EngineComponent::_nil(); + } + CORBA::string_free(reason); + + MESSAGE("Creating component instance"); + // @PARALLEL@ permits to identify that the component requested + // is a parallel component. + std::string name = std::string(componentName); + Engines::EngineComponent_var myInstance = cont->create_component_instance(name.c_str()); + if (CORBA::is_nil(myInstance)) + INFOS("create_component_instance returns a NULL component !"); + return myInstance._retn(); +} + +/*! \brief copy a file from a source host to a destination host + * \param hostSrc the source host + * \param fileSrc the file to copy from the source host to the destination host + * \param hostDest the destination host + * \param fileDest the destination file + */ +void SALOME_LifeCycleCORBA::copyFile(const char* hostSrc, const char* fileSrc, const char* hostDest, const char* fileDest) +{ + if(strcmp(hostDest,"localhost") == 0) + { + //if localhost use a shortcut + SALOME_FileTransferCORBA transfer(hostSrc,fileSrc); + transfer.getLocalFile(fileDest); + return; + } + + Engines::ContainerManager_var contManager = getContainerManager(); + + Engines::ContainerParameters params; + preSet(params); + + params.resource_params.hostname = hostDest; + params.mode = CORBA::string_dup("findorstart"); + Engines::Container_var containerDest = contManager->GiveContainer(params); + + params.resource_params.hostname = hostSrc; + Engines::Container_var containerSrc = contManager->GiveContainer(params); + + containerDest->copyFile(containerSrc,fileSrc,fileDest); +} + +/*! \brief get the naming service used by the life cycle + * + * \return the naming service + */ +SALOME_NamingService_Abstract * SALOME_LifeCycleCORBA::namingService() +{ + return _NS; } -Engines::Component_ptr SALOME_LifeCycleCORBA::LoadComponent(const char *containerName, const char *componentName, const Engines::MachineList& listOfMachines) +/*! \brief get the orb used by the life cycle + * + * \return the orb + */ +CORBA::ORB_ptr SALOME_LifeCycleCORBA::orb() { - Engines::Container_var cont=_ContManager->FindOrStartContainer(containerName,listOfMachines); - string implementation=Engines_Component_i::GetDynLibraryName(componentName); - return cont->load_impl(componentName, implementation.c_str()); + SALOME_NamingService *NSC = dynamic_cast(_NS); + if(!_NS) + THROW_SALOME_EXCEPTION("SALOME_LifeCycleCORBA::orb : not a CORBA SALOME_NamingService "); + return NSC->orb(); }