-// Copyright (C) 2007-2008 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2010 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
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
+
#include "SALOME_ContainerManager.hxx"
#include "SALOME_NamingService.hxx"
#include "SALOME_ModuleCatalog.hh"
#include "Utils_CorbaException.hxx"
#include <sstream>
+#ifdef WNT
+#include <process.h>
+#define getpid _getpid
+#endif
+
#ifdef WITH_PACO_PARALLEL
#include "PaCOPP.hxx"
#endif
#define TIME_OUT_TO_LAUNCH_CONT 61
-using namespace std;
-
const char *SALOME_ContainerManager::_ContainerManagerNameInNS =
"/ContainerManager";
#ifdef HAVE_MPI2
#ifdef WITHOPENMPI
+ std::string urifile = getenv("HOME");
+ std::ostringstream mypid;
+ mypid << getpid();
+ urifile += "/.urifile_" + mypid.str();
+ setenv("OMPI_URI_FILE",urifile.c_str(),0);
if( getenv("OMPI_URI_FILE") != NULL ){
system("killall ompi-server");
- string command;
+ std::string command;
command = "ompi-server -r ";
command += getenv("OMPI_URI_FILE");
int status=system(command.c_str());
bool isOK;
isOK = _NS->Change_Directory("/Containers");
if( isOK ){
- vector<string> vec = _NS->list_directory_recurs();
- list<string> lstCont;
- for(vector<string>::iterator iter = vec.begin();iter!=vec.end();iter++)
+ std::vector<std::string> vec = _NS->list_directory_recurs();
+ std::list<std::string> lstCont;
+ for(std::vector<std::string>::iterator iter = vec.begin();iter!=vec.end();iter++)
{
SCRUTE((*iter));
CORBA::Object_var obj=_NS->Resolve((*iter).c_str());
}
}
MESSAGE("Container list: ");
- for(list<string>::iterator iter=lstCont.begin();iter!=lstCont.end();iter++){
+ for(std::list<std::string>::iterator iter=lstCont.begin();iter!=lstCont.end();iter++){
SCRUTE((*iter));
}
- for(list<string>::iterator iter=lstCont.begin();iter!=lstCont.end();iter++)
+ for(std::list<std::string>::iterator iter=lstCont.begin();iter!=lstCont.end();iter++)
{
try
{
Engines::Container_ptr
SALOME_ContainerManager::GiveContainer(const Engines::ContainerParameters& params)
{
- string machFile;
+ std::string machFile;
Engines::Container_ptr ret = Engines::Container::_nil();
// Step 0: Default mode is start
{
if (mode == "find")
{
- MESSAGE("[GiveContainer] no container found");
- return ret;
+ MESSAGE("[GiveContainer] no container found");
+ return ret;
}
else
{
- mode = "start";
+ mode = "start";
}
}
}
Engines::Container_ptr cont = FindContainer(params, possibleResources[i].in());
try
{
- if(!cont->_non_existent())
- local_resources.push_back(string(possibleResources[i]));
+ if(!cont->_non_existent())
+ local_resources.push_back(std::string(possibleResources[i]));
}
catch(CORBA::Exception&) {}
}
}
else
for(unsigned int i=0; i < possibleResources->length(); i++)
- local_resources.push_back(string(possibleResources[i]));
+ local_resources.push_back(std::string(possibleResources[i]));
// Step 4: select the resource where to get/start the container
std::string resource_selected;
std::string containerNameInNS;
if(params.isMPI){
int nbproc;
- if ( (params.resource_params.nb_node <= 0) && (params.resource_params.nb_proc_per_node <= 0) )
+ if ( params.nb_proc <= 0 )
nbproc = 1;
- else if ( params.resource_params.nb_node == 0 )
- nbproc = params.resource_params.nb_proc_per_node;
- else if ( params.resource_params.nb_proc_per_node == 0 )
- nbproc = params.resource_params.nb_node;
else
- nbproc = params.resource_params.nb_node * params.resource_params.nb_proc_per_node;
+ nbproc = params.nb_proc;
if( getenv("LIBBATCH_NODEFILE") != NULL )
machFile = machinesFile(nbproc);
// A mpi parallel container register on zero node in NS
Engines::Container_var cont=Engines::Container::_narrow(obj);
if(!cont->_non_existent())
{
- if(std::string(params.mode.in())=="getorstart" || std::string(params.mode.in())=="get"){
- return cont._retn(); /* the container exists and params.mode is getorstart or get use it*/
- }
- else
- {
- INFOS("[GiveContainer] A container is already registered with the name: " << containerNameInNS << ", shutdown the existing container");
- cont->Shutdown(); // shutdown the registered container if it exists
- }
+ if(std::string(params.mode.in())=="getorstart" || std::string(params.mode.in())=="get"){
+ return cont._retn(); /* the container exists and params.mode is getorstart or get use it*/
+ }
+ else
+ {
+ INFOS("[GiveContainer] A container is already registered with the name: " << containerNameInNS << ", shutdown the existing container");
+ cont->Shutdown(); // shutdown the registered container if it exists
+ }
}
}
catch(CORBA::Exception&)
SALOME_ModuleCatalog::Acomponent_var compoInfo = Catalog->GetComponent(compoi);
if (CORBA::is_nil (compoInfo))
{
- continue;
+ continue;
}
SALOME_ModuleCatalog::ImplType impl=compoInfo->implementation_type();
container_exe_tmp=compoInfo->implementation_name();
if(impl==SALOME_ModuleCatalog::CEXE)
{
- if(found)
- {
- INFOS("ContainerManager Error: you can't have 2 CEXE component in the same container" );
- return Engines::Container::_nil();
- }
- MESSAGE("[GiveContainer] Exe container found !: " << container_exe_tmp);
- container_exe = container_exe_tmp.in();
- found=1;
+ if(found)
+ {
+ INFOS("ContainerManager Error: you can't have 2 CEXE component in the same container" );
+ return Engines::Container::_nil();
+ }
+ MESSAGE("[GiveContainer] Exe container found !: " << container_exe_tmp);
+ container_exe = container_exe_tmp.in();
+ found=1;
}
}
}
//redirect stdout and stderr in a file
#ifdef WNT
- string logFilename=getenv("TEMP");
+ std::string logFilename=getenv("TEMP");
logFilename += "\\";
+ std::string user = getenv( "USERNAME" );
#else
- string logFilename="/tmp";
+ std::string user = getenv( "USER" );
+ std::string logFilename="/tmp";
char* val = getenv("SALOME_TMP_DIR");
if(val)
{
}
logFilename += "/";
#endif
- logFilename += _NS->ContainerName(params)+"_"+ resource_selected +"_"+getenv( "USER" )+".log" ;
+ logFilename += _NS->ContainerName(params)+"_"+ resource_selected +"_"+user;
+ std::ostringstream tmp;
+ tmp << "_" << getpid();
+ logFilename += tmp.str();
+ logFilename += ".log" ;
command += " > " + logFilename + " 2>&1";
#ifdef WNT
command = "%PYTHONBIN% -c \"import win32pm ; win32pm.spawnpid(r'" + command + "', '')\"";
// Setting log file name
logFilename=":"+logFilename;
logFilename="@"+Kernel_Utils::GetHostname()+logFilename;
- logFilename=getenv( "USER" )+logFilename;
+ logFilename=user+logFilename;
ret->logfilename(logFilename.c_str());
RmTmpFile(_TmpFileName); // command file can be removed here
}
}
}
+
+bool isPythonContainer(const char* ContainerName);
+
//=============================================================================
/*!
* This is no longer valid (C++ container are also python containers)
*/
//=============================================================================
-string
+std::string
SALOME_ContainerManager::BuildCommandToLaunchRemoteContainer
-(const string& resource_name,
+(const std::string& resource_name,
const Engines::ContainerParameters& params, const std::string& container_exe)
{
- string command;
+ std::string command;
if (!_isAppliSalomeDefined)
command = BuildTempFileToLaunchRemoteContainer(resource_name, params);
else
if (params.isMPI)
{
- if ((params.resource_params.nb_node <= 0) && (params.resource_params.nb_proc_per_node <= 0))
- nbproc = 1;
- else if (params.resource_params.nb_node == 0)
- nbproc = params.resource_params.nb_proc_per_node;
- else if (params.resource_params.nb_proc_per_node == 0)
- nbproc = params.resource_params.nb_node;
+ if ( params.nb_proc <= 0 )
+ nbproc = 1;
else
- nbproc = params.resource_params.nb_node * params.resource_params.nb_proc_per_node;
+ nbproc = params.nb_proc;
}
// "ssh -l user machine distantPath/runRemote.sh hostNS portNS WORKINGDIR workingdir \
command += " WORKINGDIR ";
command += " '";
if(wdir == "$TEMPDIR")
- wdir="\\$TEMPDIR";
+ wdir="\\$TEMPDIR";
command += wdir; // requested working directory
command += "'";
}
command += "-x PATH,LD_LIBRARY_PATH,OMNIORB_CONFIG,SALOME_trace ";
#elif defined(WITHOPENMPI)
if( getenv("OMPI_URI_FILE") == NULL )
- command += "-x PATH -x LD_LIBRARY_PATH -x OMNIORB_CONFIG -x SALOME_trace";
+ command += "-x PATH -x LD_LIBRARY_PATH -x OMNIORB_CONFIG -x SALOME_trace";
else{
- command += "-x PATH -x LD_LIBRARY_PATH -x OMNIORB_CONFIG -x SALOME_trace -ompi-server file:";
- command += getenv("OMPI_URI_FILE");
+ command += "-x PATH -x LD_LIBRARY_PATH -x OMNIORB_CONFIG -x SALOME_trace -ompi-server file:";
+ command += getenv("OMPI_URI_FILE");
}
#endif
command += " SALOME_MPIContainer ";
* builds the command to be launched.
*/
//=============================================================================
-string
+std::string
SALOME_ContainerManager::BuildCommandToLaunchLocalContainer
(const Engines::ContainerParameters& params, const std::string& machinesFile, const std::string& container_exe)
{
_TmpFileName = BuildTemporaryFileName();
- string command;
+ std::string command;
int nbproc = 0;
- ostringstream o;
+ std::ostringstream o;
if (params.isMPI)
{
o << "mpirun -np ";
- if ( (params.resource_params.nb_node <= 0) && (params.resource_params.nb_proc_per_node <= 0) )
+ if ( params.nb_proc <= 0 )
nbproc = 1;
- else if ( params.resource_params.nb_node == 0 )
- nbproc = params.resource_params.nb_proc_per_node;
- else if ( params.resource_params.nb_proc_per_node == 0 )
- nbproc = params.resource_params.nb_node;
else
- nbproc = params.resource_params.nb_node * params.resource_params.nb_proc_per_node;
+ nbproc = params.nb_proc;
o << nbproc << " ";
if( getenv("LIBBATCH_NODEFILE") != NULL )
- o << "-machinefile " << machinesFile << " ";
+ o << "-machinefile " << machinesFile << " ";
#ifdef WITHLAM
o << "-x PATH,LD_LIBRARY_PATH,OMNIORB_CONFIG,SALOME_trace ";
if(wdir == "$TEMPDIR")
{
// a new temporary directory is requested
- string dir = Kernel_Utils::GetTmpDir();
+ std::string dir = Kernel_Utils::GetTmpDir();
#ifdef WIN32
- o << "cd /d " << dir << endl;
+ o << "cd /d " << dir << std::endl;
#else
o << "cd " << dir << ";";
#endif
{
// a permanent directory is requested use it or create it
#ifdef WIN32
- o << "mkdir " + wdir << endl;
- o << "cd /D " + wdir << endl;
+ o << "mkdir " + wdir << std::endl;
+ o << "cd /D " + wdir << std::endl;
#else
o << "mkdir -p " << wdir << " && cd " << wdir + ";";
#endif
o << " -";
AddOmninamesParams(o);
- ofstream command_file( _TmpFileName.c_str() );
+ std::ofstream command_file( _TmpFileName.c_str() );
command_file << o.str();
command_file.close();
if ( lenght > 0)
{
#ifdef WIN32
- string command = "del /F ";
+ std::string command = "del /F ";
#else
- string command = "rm ";
+ std::string command = "rm ";
#endif
if ( lenght > 4 )
command += tmpFileName.substr(0, lenght - 3 );
command += '*';
system(command.c_str());
//if dir is empty - remove it
- string tmp_dir = Kernel_Utils::GetDirByPath( tmpFileName );
+ std::string tmp_dir = Kernel_Utils::GetDirByPath( tmpFileName );
if ( Kernel_Utils::IsEmptyDir( tmp_dir ) )
{
#ifdef WIN32
*/
//=============================================================================
-void SALOME_ContainerManager::AddOmninamesParams(string& command) const
+void SALOME_ContainerManager::AddOmninamesParams(std::string& command) const
{
CORBA::String_var iorstr = _NS->getIORaddr();
command += "ORBInitRef NameService=";
*/
//=============================================================================
-void SALOME_ContainerManager::AddOmninamesParams(ofstream& fileStream) const
+void SALOME_ContainerManager::AddOmninamesParams(std::ofstream& fileStream) const
{
CORBA::String_var iorstr = _NS->getIORaddr();
fileStream << "ORBInitRef NameService=";
*/
//=============================================================================
-void SALOME_ContainerManager::AddOmninamesParams(ostringstream& oss) const
+void SALOME_ContainerManager::AddOmninamesParams(std::ostringstream& oss) const
{
CORBA::String_var iorstr = _NS->getIORaddr();
oss << "ORBInitRef NameService=";
*/
//=============================================================================
-string SALOME_ContainerManager::BuildTemporaryFileName() const
+std::string SALOME_ContainerManager::BuildTemporaryFileName() const
{
//build more complex file name to support multiple salome session
- string aFileName = Kernel_Utils::GetTmpFileName();
+ std::string aFileName = Kernel_Utils::GetTmpFileName();
#ifndef WIN32
aFileName += ".sh";
#else
*/
//=============================================================================
-string
+std::string
SALOME_ContainerManager::BuildTempFileToLaunchRemoteContainer
-(const string& resource_name,
+(const std::string& resource_name,
const Engines::ContainerParameters& params) throw(SALOME_Exception)
{
int status;
_TmpFileName = BuildTemporaryFileName();
- ofstream tempOutputFile;
- tempOutputFile.open(_TmpFileName.c_str(), ofstream::out );
+ std::ofstream tempOutputFile;
+ tempOutputFile.open(_TmpFileName.c_str(), std::ofstream::out );
const ParserResourcesType& resInfo = _ResManager->GetImpl()->GetResourcesDescr(resource_name);
- tempOutputFile << "#! /bin/sh" << endl;
+ tempOutputFile << "#! /bin/sh" << std::endl;
// --- set env vars
- tempOutputFile << "export SALOME_trace=local" << endl; // mkr : 27.11.2006 : PAL13967 - Distributed supervision graphs - Problem with "SALOME_trace"
+ tempOutputFile << "export SALOME_trace=local" << std::endl; // mkr : 27.11.2006 : PAL13967 - Distributed supervision graphs - Problem with "SALOME_trace"
//tempOutputFile << "source " << resInfo.PreReqFilePath << endl;
// ! env vars
tempOutputFile << "mpirun -np ";
int nbproc;
- if ( (params.resource_params.nb_node <= 0) && (params.resource_params.nb_proc_per_node <= 0) )
+ if ( params.nb_proc <= 0 )
nbproc = 1;
- else if ( params.resource_params.nb_node == 0 )
- nbproc = params.resource_params.nb_proc_per_node;
- else if ( params.resource_params.nb_proc_per_node == 0 )
- nbproc = params.resource_params.nb_node;
else
- nbproc = params.resource_params.nb_node * params.resource_params.nb_proc_per_node;
+ nbproc = params.nb_proc;
std::ostringstream o;
tempOutputFile << _NS->ContainerName(params) << " -";
AddOmninamesParams(tempOutputFile);
- tempOutputFile << " &" << endl;
+ tempOutputFile << " &" << std::endl;
tempOutputFile.flush();
tempOutputFile.close();
#ifndef WIN32
// --- Build command
- string command;
+ std::string command;
if (resInfo.Protocol == rsh)
{
command = "rsh ";
- string commandRcp = "rcp ";
+ std::string commandRcp = "rcp ";
commandRcp += _TmpFileName;
commandRcp += " ";
commandRcp += resInfo.HostName;
else if (resInfo.Protocol == ssh)
{
command = "ssh ";
- string commandRcp = "scp ";
+ std::string commandRcp = "scp ";
commandRcp += _TmpFileName;
commandRcp += " ";
commandRcp += resInfo.HostName;
}
-string SALOME_ContainerManager::GetMPIZeroNode(const string machine, const string machinesFile)
+std::string SALOME_ContainerManager::GetMPIZeroNode(const std::string machine, const std::string machinesFile)
{
int status;
- string zeronode;
- string command;
- string tmpFile = BuildTemporaryFileName();
+ std::string zeronode;
+ std::string command;
+ std::string tmpFile = BuildTemporaryFileName();
if( getenv("LIBBATCH_NODEFILE") == NULL )
{
status = system(command.c_str());
if( status == 0 ){
- ifstream fp(tmpFile.c_str(),ios::in);
- fp >> zeronode;
+ std::ifstream fp(tmpFile.c_str(),std::ios::in);
+ while(fp >> zeronode);
}
RmTmpFile(tmpFile);
return zeronode;
}
-string SALOME_ContainerManager::machinesFile(const int nbproc)
+std::string SALOME_ContainerManager::machinesFile(const int nbproc)
{
- string tmp;
- string nodesFile = getenv("LIBBATCH_NODEFILE");
- string machinesFile = Kernel_Utils::GetTmpFileName();
- ifstream fpi(nodesFile.c_str(),ios::in);
- ofstream fpo(machinesFile.c_str(),ios::out);
+ std::string tmp;
+ std::string nodesFile = getenv("LIBBATCH_NODEFILE");
+ std::string machinesFile = Kernel_Utils::GetTmpFileName();
+ std::ifstream fpi(nodesFile.c_str(),std::ios::in);
+ std::ofstream fpo(machinesFile.c_str(),std::ios::out);
_numInstanceMutex.lock();
for(int i=0;i<nbproc;i++)
if( fpi >> tmp )
- fpo << tmp << endl;
+ fpo << tmp << std::endl;
else
throw SALOME_Exception("You ask more processes than batch session have allocated!");
//=============================================================================
Engines::Container_ptr
SALOME_ContainerManager::StartPaCOPPContainer(const Engines::ContainerParameters& params_const,
- std::string resource_selected)
+ std::string resource_selected)
{
CORBA::Object_var obj;
PaCO::InterfaceManager_var container_proxy;
// Step 2 : Get a MachineFile for the parallel container
std::string machine_file_name = _ResManager->getMachineFile(resource_selected,
- params.nb_proc,
- params.parallelLib.in());
+ params.nb_proc,
+ params.parallelLib.in());
if (machine_file_name == "")
{
std::string
SALOME_ContainerManager::BuildCommandToLaunchPaCOProxyContainer(const Engines::ContainerParameters& params,
- std::string machine_file_name,
- std::string & proxy_hostname)
+ std::string machine_file_name,
+ std::string & proxy_hostname)
{
// In the proxy case, we always launch a Dummy Proxy
std::string exe_name = "SALOME_ParallelContainerProxyDummy";
std::ifstream machine_file(machine_file_name.c_str());
std::getline(machine_file, hostname, ' ');
size_t found = hostname.find('\n');
- if (found!=string::npos)
+ if (found!=std::string::npos)
hostname.erase(found, 1); // Remove \n
proxy_hostname = hostname;
MESSAGE("[BuildCommandToLaunchPaCOProxyContainer] machine file name extracted is " << hostname);
std::string
SALOME_ContainerManager::BuildCommandToLaunchPaCONodeContainer(const Engines::ContainerParameters& params,
- const std::string & machine_file_name,
- SALOME_ContainerManager::actual_launch_machine_t & vect_machine,
- const std::string & proxy_hostname)
+ const std::string & machine_file_name,
+ SALOME_ContainerManager::actual_launch_machine_t & vect_machine,
+ const std::string & proxy_hostname)
{
// Name of exe
std::string exe_name = "SALOME_ParallelContainerNode";
bool remote_execution = false;
if (hostname != std::string(Kernel_Utils::GetHostname()))
{
- MESSAGE("[BuildCommandToLaunchPaCONodeContainer] remote machine case detected !");
- remote_execution = true;
+ MESSAGE("[BuildCommandToLaunchPaCONodeContainer] remote machine case detected !");
+ remote_execution = true;
}
// For each node we have a new command
// a SALOME application
if (remote_execution)
{
- ASSERT(getenv("NSHOST"));
- ASSERT(getenv("NSPORT"));
-
- command_node_stream << resource_definition->protocol.in();
- command_node_stream << " -l ";
- command_node_stream << resource_definition->username.in();
- command_node_stream << " " << hostname;
- command_node_stream << " " << resource_definition->applipath.in();
- command_node_stream << "/runRemote.sh ";
- command_node_stream << getenv("NSHOST") << " "; // hostname of CORBA name server
- command_node_stream << getenv("NSPORT") << " "; // port of CORBA name server
+ ASSERT(getenv("NSHOST"));
+ ASSERT(getenv("NSPORT"));
+
+ command_node_stream << resource_definition->protocol.in();
+ command_node_stream << " -l ";
+ command_node_stream << resource_definition->username.in();
+ command_node_stream << " " << hostname;
+ command_node_stream << " " << resource_definition->applipath.in();
+ command_node_stream << "/runRemote.sh ";
+ command_node_stream << getenv("NSHOST") << " "; // hostname of CORBA name server
+ command_node_stream << getenv("NSPORT") << " "; // port of CORBA name server
}
command_node_stream << exe_name;
void
SALOME_ContainerManager::LogConfiguration(const std::string & log_type,
- const std::string & exe_type,
- const std::string & container_name,
- const std::string & hostname,
- std::string & begin,
- std::string & end)
+ const std::string & exe_type,
+ const std::string & container_name,
+ const std::string & hostname,
+ std::string & begin,
+ std::string & end)
{
if(log_type == "xterm")
{
CORBA::Object_ptr
SALOME_ContainerManager::LaunchPaCOProxyContainer(const std::string& command,
- const Engines::ContainerParameters& params,
- const std::string & hostname)
+ const Engines::ContainerParameters& params,
+ const std::string & hostname)
{
PaCO::InterfaceManager_ptr container_proxy = PaCO::InterfaceManager::_nil();
int count = TIME_OUT_TO_LAUNCH_CONT;
CORBA::Object_var obj = CORBA::Object::_nil();
std::string containerNameInNS = _NS->BuildContainerNameForNS(params.container_name.in(),
- hostname.c_str());
+ hostname.c_str());
MESSAGE("[LaunchParallelContainer] Waiting for Parallel Container proxy : " << containerNameInNS);
while (CORBA::is_nil(obj) && count)
Engines::Container_ptr
SALOME_ContainerManager::StartPaCOPPContainer(const Engines::ContainerParameters& params,
- std::string resource_selected)
+ std::string resource_selected)
{
Engines::Container_ptr ret = Engines::Container::_nil();
INFOS("[StarPaCOPPContainer] is disabled !");
std::string
SALOME_ContainerManager::BuildCommandToLaunchPaCOProxyContainer(const Engines::ContainerParameters& params,
- std::string machine_file_name,
- std::string & proxy_hostname)
+ std::string machine_file_name,
+ std::string & proxy_hostname)
{
return "";
}
std::string
SALOME_ContainerManager::BuildCommandToLaunchPaCONodeContainer(const Engines::ContainerParameters& params,
- const std::string & machine_file_name,
- SALOME_ContainerManager::actual_launch_machine_t & vect_machine,
- const std::string & proxy_hostname)
+ const std::string & machine_file_name,
+ SALOME_ContainerManager::actual_launch_machine_t & vect_machine,
+ const std::string & proxy_hostname)
{
return "";
}
void
SALOME_ContainerManager::LogConfiguration(const std::string & log_type,
- const std::string & exe_type,
- const std::string & container_name,
- const std::string & hostname,
- std::string & begin,
- std::string & end)
+ const std::string & exe_type,
+ const std::string & container_name,
+ const std::string & hostname,
+ std::string & begin,
+ std::string & end)
{
}
CORBA::Object_ptr
SALOME_ContainerManager::LaunchPaCOProxyContainer(const std::string& command,
- const Engines::ContainerParameters& params,
- const std::string& hostname)
+ const Engines::ContainerParameters& params,
+ const std::string& hostname)
{
CORBA::Object_ptr ret = CORBA::Object::_nil();
return ret;
bool
SALOME_ContainerManager::LaunchPaCONodeContainer(const std::string& command,
- const Engines::ContainerParameters& params,
- const std::string& name,
- SALOME_ContainerManager::actual_launch_machine_t & vect_machine)
+ const Engines::ContainerParameters& params,
+ const std::string& name,
+ SALOME_ContainerManager::actual_launch_machine_t & vect_machine)
{
return false;
}
