-// Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2023 CEA, EDF, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
*/
//=============================================================================
-SALOME_ResourcesManager::
-SALOME_ResourcesManager(CORBA::ORB_ptr orb,
- PortableServer::POA_var poa,
- SALOME_NamingService *ns,
- const char *xmlFilePath) : _rm(xmlFilePath)
+SALOME_ResourcesManager::SALOME_ResourcesManager(CORBA::ORB_ptr orb,
+ PortableServer::POA_var poa,
+ SALOME_NamingService_Abstract *ns,
+ const char *xmlFilePath)
+: _rm(new ResourcesManager_cpp(xmlFilePath))
{
MESSAGE("SALOME_ResourcesManager constructor");
_NS = ns;
_orb = CORBA::ORB::_duplicate(orb) ;
- _poa = PortableServer::POA::_duplicate(poa) ;
+ //
+ PortableServer::POAManager_var pman = poa->the_POAManager();
+ CORBA::PolicyList policies;
+ policies.length(1);
+ PortableServer::ThreadPolicy_var threadPol(poa->create_thread_policy(PortableServer::SINGLE_THREAD_MODEL));
+ policies[0] = PortableServer::ThreadPolicy::_duplicate(threadPol);
+ _poa = poa->create_POA("SingleThreadPOA",pman,policies);
+ threadPol->destroy();
+ //
PortableServer::ObjectId_var id = _poa->activate_object(this);
CORBA::Object_var obj = _poa->id_to_reference(id);
Engines::ResourcesManager_var refContMan = Engines::ResourcesManager::_narrow(obj);
SALOME_ResourcesManager::SALOME_ResourcesManager(CORBA::ORB_ptr orb,
PortableServer::POA_var poa,
- SALOME_NamingService *ns) : _rm()
+ SALOME_NamingService_Abstract *ns) : _rm(new ResourcesManager_cpp())
{
MESSAGE("SALOME_ResourcesManager constructor");
_NS = ns;
_orb = CORBA::ORB::_duplicate(orb) ;
- _poa = PortableServer::POA::_duplicate(poa) ;
+ //
+ PortableServer::POAManager_var pman = poa->the_POAManager();
+ CORBA::PolicyList policies;
+ policies.length(1);
+ PortableServer::ThreadPolicy_var threadPol(poa->create_thread_policy(PortableServer::SINGLE_THREAD_MODEL));
+ policies[0] = PortableServer::ThreadPolicy::_duplicate(threadPol);
+ _poa = poa->create_POA("SingleThreadPOA",pman,policies);
+ threadPol->destroy();
+ //
PortableServer::ObjectId_var id = _poa->activate_object(this);
CORBA::Object_var obj = _poa->id_to_reference(id);
Engines::ResourcesManager_var refContMan = Engines::ResourcesManager::_narrow(obj);
- _NS->Register(refContMan,_ResourcesManagerNameInNS);
+ if(_NS)
+ _NS->Register(refContMan,_ResourcesManagerNameInNS);
MESSAGE("SALOME_ResourcesManager constructor end");
}
void SALOME_ResourcesManager::Shutdown()
{
MESSAGE("Shutdown");
+ if(!_NS)
+ return ;
_NS->Destroy_Name(_ResourcesManagerNameInNS);
PortableServer::ObjectId_var oid = _poa->servant_to_id(this);
_poa->deactivate_object(oid);
}
+/*!
+ * Return list of resources available (regarding content of CatalogResources.xml) but select only those with canRunContainers attribute set to true.
+ * And for each resource the number of proc available of it.
+ *
+ * \sa SALOME_ResourcesManager::ListAllResourcesInCatalog
+ */
+void SALOME_ResourcesManager::ListAllAvailableResources(Engines::ResourceList_out machines, Engines::IntegerList_out nbProcsOfMachines)
+{
+ const MapOfParserResourcesType& zeList(_rm->GetList());
+ std::vector<std::string> ret0;
+ std::vector<int> ret1;
+ for(MapOfParserResourcesType::const_iterator it=zeList.begin();it!=zeList.end();it++)
+ {
+ const ParserResourcesType& elt((*it).second);
+ if(elt.can_run_containers)
+ {
+ ret0.push_back(elt.HostName);
+ ret1.push_back(elt.DataForSort._nbOfNodes*elt.DataForSort._nbOfProcPerNode);
+ }
+ }
+ machines=new Engines::ResourceList;
+ nbProcsOfMachines=new Engines::IntegerList;
+ std::size_t sz(ret0.size());
+ machines->length((CORBA::ULong)sz); nbProcsOfMachines->length((CORBA::ULong)sz);
+ for(std::size_t j=0;j<sz;j++)
+ {
+ (*machines)[(CORBA::ULong)j]=CORBA::string_dup(ret0[j].c_str());
+ (*nbProcsOfMachines)[(CORBA::ULong)j]=ret1[j];
+ }
+}
+
+/*!
+ * Return list of resources available (regarding content of CatalogResources.xml) whatever canRunContainers attribute value.
+ *
+ * \sa SALOME_ResourcesManager::ListAllAvailableResources
+ */
+Engines::ResourceList *SALOME_ResourcesManager::ListAllResourcesInCatalog()
+{
+ const MapOfParserResourcesType& zeList(_rm->GetList());
+ auto sz = zeList.size();
+ Engines::ResourceList *ret(new Engines::ResourceList);
+ ret->length( sz );
+ CORBA::ULong i(0);
+ for(auto it : zeList)
+ {
+ (*ret)[i++] = CORBA::string_dup( it.second.HostName.c_str() );
+ }
+ return ret;
+}
+
//=============================================================================
//! get the name of resources fitting the specified constraints (params)
/*!
Engines::ResourceList *
SALOME_ResourcesManager::GetFittingResources(const Engines::ResourceParameters& params)
{
- MESSAGE("ResourcesManager::GetFittingResources");
- Engines::ResourceList * ret = new Engines::ResourceList;
+ //MESSAGE("ResourcesManager::GetFittingResources");
+ Engines::ResourceList_var ret;
// CORBA -> C++
- resourceParams p;
- p.name = params.name;
- p.hostname = params.hostname;
- p.can_launch_batch_jobs = params.can_launch_batch_jobs;
- p.can_run_containers = params.can_run_containers;
- p.OS = params.OS;
- p.nb_proc = params.nb_proc;
- p.nb_node = params.nb_node;
- p.nb_proc_per_node = params.nb_proc_per_node;
- p.cpu_clock = params.cpu_clock;
- p.mem_mb = params.mem_mb;
- for(unsigned int i=0; i<params.componentList.length(); i++)
- p.componentList.push_back(std::string(params.componentList[i]));
- for(unsigned int i=0; i<params.resList.length(); i++)
- p.resourceList.push_back(std::string(params.resList[i]));
-
+ resourceParams p = resourceParameters_CORBAtoCPP(params);
+
try
{
// Call C++ ResourceManager
- std::vector <std::string> vec = _rm.GetFittingResources(p);
+ std::vector <std::string> vec = _rm->GetFittingResources(p);
// C++ -> CORBA
- ret->length(vec.size());
- for(unsigned int i=0;i<vec.size();i++)
- (*ret)[i] = (vec[i]).c_str();
+ ret = resourceList_CPPtoCORBA(vec);
}
catch(const ResourcesException &ex)
{
THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::BAD_PARAM);
}
- return ret;
+ return ret._retn();
}
//=============================================================================
SALOME_ResourcesManager::FindFirst(const Engines::ResourceList& listOfResources)
{
// CORBA -> C++
- std::vector<std::string> rl;
- for(unsigned int i=0; i<listOfResources.length(); i++)
- rl.push_back(std::string(listOfResources[i]));
+ std::vector<std::string> rl = resourceList_CORBAtoCPP(listOfResources);
- return CORBA::string_dup(_rm.Find("first", rl).c_str());
+ return CORBA::string_dup(_rm->Find("first", rl).c_str());
}
char *
SALOME_ResourcesManager::Find(const char* policy, const Engines::ResourceList& listOfResources)
{
// CORBA -> C++
- std::vector<std::string> rl;
- for(unsigned int i=0; i<listOfResources.length(); i++)
- rl.push_back(std::string(listOfResources[i]));
+ std::vector<std::string> rl = resourceList_CORBAtoCPP(listOfResources);
- return CORBA::string_dup(_rm.Find(policy, rl).c_str());
+ return CORBA::string_dup(_rm->Find(policy, rl).c_str());
}
-Engines::ResourceDefinition*
+Engines::ResourceDefinition*
SALOME_ResourcesManager::GetResourceDefinition(const char * name)
{
- Engines::ResourceDefinition * p_ptr = NULL;
+ Engines::ResourceDefinition_var resDef;
try {
- ParserResourcesType resource = _rm.GetResourcesDescr(name);
- p_ptr = new Engines::ResourceDefinition;
-
- p_ptr->name = CORBA::string_dup(resource.Name.c_str());
- p_ptr->hostname = CORBA::string_dup(resource.HostName.c_str());
- p_ptr->type = CORBA::string_dup(resource.getResourceTypeStr().c_str());
- p_ptr->protocol = CORBA::string_dup(resource.getAccessProtocolTypeStr().c_str());
- p_ptr->iprotocol = CORBA::string_dup(resource.getClusterInternalProtocolStr().c_str());
- p_ptr->username = CORBA::string_dup(resource.UserName.c_str());
- p_ptr->applipath = CORBA::string_dup(resource.AppliPath.c_str());
- p_ptr->componentList.length(resource.ComponentsList.size());
- for(unsigned int i=0;i<resource.ComponentsList.size();i++)
- p_ptr->componentList[i] = CORBA::string_dup(resource.ComponentsList[i].c_str());
- p_ptr->OS = CORBA::string_dup(resource.OS.c_str());
- p_ptr->mem_mb = resource.DataForSort._memInMB;
- p_ptr->cpu_clock = resource.DataForSort._CPUFreqMHz;
- p_ptr->nb_proc_per_node = resource.DataForSort._nbOfProcPerNode;
- p_ptr->nb_node = resource.DataForSort._nbOfNodes;
- p_ptr->can_launch_batch_jobs = resource.can_launch_batch_jobs;
- p_ptr->can_run_containers = resource.can_run_containers;
- p_ptr->working_directory = CORBA::string_dup(resource.working_directory.c_str());
- p_ptr->mpiImpl = CORBA::string_dup(resource.getMpiImplTypeStr().c_str());
- p_ptr->batch = CORBA::string_dup(resource.getBatchTypeStr().c_str());
+ ParserResourcesType resource = _rm->GetResourcesDescr(name);
+ resDef = resourceDefinition_CPPtoCORBA(resource);
} catch (const exception & ex) {
INFOS("Caught exception in GetResourceDefinition: " << ex.what());
THROW_SALOME_CORBA_EXCEPTION(ex.what(), SALOME::BAD_PARAM);
}
- return p_ptr;
+ return resDef._retn();
}
void
{
try
{
- ParserResourcesType resource;
- resource.Name = new_resource.name.in();
- resource.HostName = new_resource.hostname.in();
- resource.setResourceTypeStr(new_resource.type.in());
- resource.OS = new_resource.OS.in();
- resource.AppliPath = new_resource.applipath.in();
- resource.DataForSort._memInMB = new_resource.mem_mb;
- resource.DataForSort._CPUFreqMHz = new_resource.cpu_clock;
- resource.DataForSort._nbOfNodes = new_resource.nb_node;
- resource.DataForSort._nbOfProcPerNode = new_resource.nb_proc_per_node;
- resource.UserName = new_resource.username.in();
- resource.can_launch_batch_jobs = new_resource.can_launch_batch_jobs;
- resource.can_run_containers = new_resource.can_run_containers;
- resource.working_directory = new_resource.working_directory.in();
- resource.setBatchTypeStr(new_resource.batch.in());
- resource.setMpiImplTypeStr(new_resource.mpiImpl.in());
- resource.setAccessProtocolTypeStr(new_resource.protocol.in());
- resource.setClusterInternalProtocolStr(new_resource.iprotocol.in());
- for (CORBA::ULong i = 0; i < new_resource.componentList.length(); i++)
- resource.ComponentsList.push_back(new_resource.componentList[i].in());
-
- _rm.AddResourceInCatalog(resource);
+ ParserResourcesType resource = resourceDefinition_CORBAtoCPP(new_resource);
+ _rm->AddResourceInCatalog(resource);
if (write)
{
- _rm.WriteInXmlFile(std::string(xml_file));
- _rm.ParseXmlFiles();
+ _rm->WriteInXmlFile(std::string(xml_file));
+ _rm->ParseXmlFiles();
}
}
catch (const SALOME_Exception & e)
INFOS("Error in AddResourceInCatalog: " << e);
THROW_SALOME_CORBA_EXCEPTION(e.what(), SALOME::BAD_PARAM);
}
+ catch (const ResourcesException & e)
+ {
+ INFOS("Error in AddResourceInCatalog: " << e.msg);
+ THROW_SALOME_CORBA_EXCEPTION(e.msg.c_str(), SALOME::BAD_PARAM);
+ }
}
void
{
try
{
- _rm.DeleteResourceInCatalog(resource_name);
+ _rm->DeleteResourceInCatalog(resource_name);
}
catch (const SALOME_Exception & e)
{
if (write)
{
- _rm.WriteInXmlFile(std::string(xml_file));
- _rm.ParseXmlFiles();
+ _rm->WriteInXmlFile(std::string(xml_file));
+ _rm->ParseXmlFiles();
}
}
-std::string
-SALOME_ResourcesManager::getMachineFile(std::string resource_name,
+char *
+SALOME_ResourcesManager::getMachineFile(const char * resource_name,
CORBA::Long nb_procs,
- std::string parallelLib)
+ const char * parallelLib)
{
std::string machine_file_name("");
- if (parallelLib == "Dummy")
+ if (std::string(parallelLib) == "Dummy")
{
MESSAGE("[getMachineFile] parallelLib is Dummy");
- MapOfParserResourcesType resourcesList = _rm.GetList();
- if (resourcesList.find(resource_name) != resourcesList.end())
+ MapOfParserResourcesType resourcesList = _rm->GetList();
+ if (resourcesList.find(std::string(resource_name)) != resourcesList.end())
{
- ParserResourcesType resource = resourcesList[resource_name];
+ ParserResourcesType resource = resourcesList[std::string(resource_name)];
// Check if resource is cluster or not
if (resource.ClusterMembersList.empty())
else
INFOS("[getMachineFile] Error resource_name not found in resourcesList -> " << resource_name);
}
- else if (parallelLib == "Mpi")
+ else if (std::string(parallelLib) == "Mpi")
{
MESSAGE("[getMachineFile] parallelLib is Mpi");
- MapOfParserResourcesType resourcesList = _rm.GetList();
- if (resourcesList.find(resource_name) != resourcesList.end())
+ MapOfParserResourcesType resourcesList = _rm->GetList();
+ if (resourcesList.find(std::string(resource_name)) != resourcesList.end())
{
- ParserResourcesType resource = resourcesList[resource_name];
+ ParserResourcesType resource = resourcesList[std::string(resource_name)];
// Check if resource is cluster or not
if (resource.ClusterMembersList.empty())
{
INFOS("[getMachineFile] Error resource_name MPI implementation was defined for " << resource_name);
}
else
- INFOS("[getMachineFile] Error resource_name MPI implementation not currenly handled for " << resource_name);
+ INFOS("[getMachineFile] Error resource_name MPI implementation not currently handled for " << resource_name);
}
else
INFOS("[getMachineFile] Error resource_name not found in resourcesList -> " << resource_name);
else
INFOS("[getMachineFile] Error parallelLib is not handled -> " << parallelLib);
- return machine_file_name;
+ return CORBA::string_dup(machine_file_name.c_str());
}
