src/Container/SALOME_ContainerManager.cxx

   1 // Copyright (C) 2007-2015  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 // This library is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU Lesser General Public
   8 // License as published by the Free Software Foundation; either
   9 // version 2.1 of the License, or (at your option) any later version.
  10 //
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // Lesser General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU Lesser General Public
  17 // License along with this library; if not, write to the Free Software
  18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22
  23 #include "SALOME_ContainerManager.hxx"
  24 #include "SALOME_ResourcesManager.hxx"
  25 #include "SALOME_LoadRateManager.hxx"
  26 #include "SALOME_NamingService.hxx"
  27 #include "SALOME_ResourcesManager_Client.hxx"
  28 #include "SALOME_ModuleCatalog.hh"
  29 #include "Basics_Utils.hxx"
  30 #include "Basics_DirUtils.hxx"
  31 #include <sys/types.h>
  32 #include <sys/stat.h>
  33 #include <signal.h>
  34 #ifndef WIN32
  35 #include <unistd.h>
  36 #endif
  37 #include <vector>
  38 #include "Utils_CorbaException.hxx"
  39 #include <sstream>
  40 #include <string>
  41
  42 #include <SALOMEconfig.h>
  43 #include CORBA_CLIENT_HEADER(SALOME_Session)
  44
  45 #ifdef HAVE_MPI2
  46 #include <mpi.h>
  47 #endif
  48
  49 #ifdef WIN32
  50 #include <process.h>
  51 #define getpid _getpid
  52 #endif
  53
  54 #ifdef WITH_PACO_PARALLEL
  55 #include "PaCOPP.hxx"
  56 #endif
  57
  58 const int SALOME_ContainerManager::TIME_OUT_TO_LAUNCH_CONT=60;
  59
  60 const char *SALOME_ContainerManager::_ContainerManagerNameInNS =
  61   "/ContainerManager";
  62
  63 omni_mutex SALOME_ContainerManager::_numInstanceMutex;
  64
  65 Utils_Mutex SALOME_ContainerManager::_getenvMutex;
  66
  67 Utils_Mutex SALOME_ContainerManager::_systemMutex;
  68
  69 //=============================================================================
  70 /*!
  71  *  Constructor
  72  *  \param orb
  73  *  Define a CORBA single thread policy for the server, which avoid to deal
  74  *  with non thread-safe usage like Change_Directory in SALOME naming service
  75  */
  76 //=============================================================================
  77
  78 SALOME_ContainerManager::SALOME_ContainerManager(CORBA::ORB_ptr orb, PortableServer::POA_var poa, SALOME_NamingService *ns)
  79   : _nbprocUsed(1)
  80 {
  81   MESSAGE("constructor");
  82   _NS = ns;
  83   _resManager = new SALOME_ResourcesManager_Client(ns);
  84
  85   PortableServer::POAManager_var pman = poa->the_POAManager();
  86   _orb = CORBA::ORB::_duplicate(orb) ;
  87   CORBA::PolicyList policies;
  88   policies.length(1);
  89   PortableServer::ThreadPolicy_var threadPol(poa->create_thread_policy(PortableServer::ORB_CTRL_MODEL));
  90   policies[0] = PortableServer::ThreadPolicy::_duplicate(threadPol);
  91
  92   _poa = poa->create_POA("MThreadPOA",pman,policies);
  93   threadPol->destroy();
  94   PortableServer::ObjectId_var id = _poa->activate_object(this);
  95   CORBA::Object_var obj = _poa->id_to_reference(id);
  96   Engines::ContainerManager_var refContMan =
  97     Engines::ContainerManager::_narrow(obj);
  98
  99   _NS->Register(refContMan,_ContainerManagerNameInNS);
 100   _isAppliSalomeDefined = (GetenvThreadSafe("APPLI") != 0);
 101
 102 #ifdef HAVE_MPI2
 103 #ifdef OPEN_MPI
 104   _pid_mpiServer = -1;
 105   // the urifile name depends on pid of the process
 106   std::stringstream urifile;
 107   urifile << GetenvThreadSafeAsString("HOME") << "/.urifile_" << getpid();
 108   setenv("OMPI_URI_FILE",urifile.str().c_str(),1);
 109   if( GetenvThreadSafe("OMPI_URI_FILE") != NULL ){
 110     // get the pid of all ompi-server
 111     std::set<pid_t> thepids1 = getpidofprogram("ompi-server");
 112     // launch a new ompi-server
 113     std::string command;
 114     command = "ompi-server -r ";
 115     command += GetenvThreadSafeAsString("OMPI_URI_FILE");
 116     int status=SystemThreadSafe(command.c_str());
 117     if(status!=0)
 118       throw SALOME_Exception("Error when launching ompi-server");
 119     // get the pid of all ompi-server
 120     std::set<pid_t> thepids2 = getpidofprogram("ompi-server");
 121     // my ompi-server is the new one
 122     std::set<pid_t>::const_iterator it;
 123     for(it=thepids2.begin();it!=thepids2.end();it++)
 124       if(thepids1.find(*it) == thepids1.end())
 125         _pid_mpiServer = *it;
 126     if(_pid_mpiServer < 0)
 127       throw SALOME_Exception("Error when getting ompi-server id");
 128   }
 129 #elif defined(MPICH)
 130   _pid_mpiServer = -1;
 131   // get the pid of all hydra_nameserver
 132   std::set<pid_t> thepids1 = getpidofprogram("hydra_nameserver");
 133   // launch a new hydra_nameserver
 134   std::string command;
 135   command = "hydra_nameserver &";
 136   SystemThreadSafe(command.c_str());
 137   // get the pid of all hydra_nameserver
 138   std::set<pid_t> thepids2 = getpidofprogram("hydra_nameserver");
 139   // my hydra_nameserver is the new one
 140   std::set<pid_t>::const_iterator it;
 141   for(it=thepids2.begin();it!=thepids2.end();it++)
 142     if(thepids1.find(*it) == thepids1.end())
 143       _pid_mpiServer = *it;
 144 #endif
 145 #endif
 146
 147   MESSAGE("constructor end");
 148 }
 149
 150 //=============================================================================
 151 /*!
 152  * destructor
 153  */
 154 //=============================================================================
 155
 156 SALOME_ContainerManager::~SALOME_ContainerManager()
 157 {
 158   MESSAGE("destructor");
 159   delete _resManager;
 160 #ifdef HAVE_MPI2
 161 #ifdef OPEN_MPI
 162   if( GetenvThreadSafe("OMPI_URI_FILE") != NULL ){
 163     // kill my ompi-server
 164     if( kill(_pid_mpiServer,SIGTERM) != 0 )
 165       throw SALOME_Exception("Error when killing ompi-server");
 166     // delete my urifile
 167     int status=SystemThreadSafe("rm -f ${OMPI_URI_FILE}");
 168     if(status!=0)
 169       throw SALOME_Exception("Error when removing urifile");
 170   }
 171 #elif defined(MPICH)
 172   // kill my hydra_nameserver
 173   if(_pid_mpiServer > -1)
 174     if( kill(_pid_mpiServer,SIGTERM) != 0 )
 175       throw SALOME_Exception("Error when killing hydra_nameserver");
 176 #endif
 177 #endif
 178 }
 179
 180 //=============================================================================
 181 //! shutdown all the containers, then the ContainerManager servant
 182 /*! CORBA method:
 183  */
 184 //=============================================================================
 185
 186 void SALOME_ContainerManager::Shutdown()
 187 {
 188   MESSAGE("Shutdown");
 189   ShutdownContainers();
 190   _NS->Destroy_Name(_ContainerManagerNameInNS);
 191   PortableServer::ObjectId_var oid = _poa->servant_to_id(this);
 192   _poa->deactivate_object(oid);
 193 }
 194
 195 //=============================================================================
 196 //! Loop on all the containers listed in naming service, ask shutdown on each
 197 /*! CORBA Method:
 198  */
 199 //=============================================================================
 200
 201 void SALOME_ContainerManager::ShutdownContainers()
 202 {
 203   MESSAGE("ShutdownContainers");
 204
 205   SALOME::Session_var session = SALOME::Session::_nil();
 206   CORBA::Long pid = 0;
 207   CORBA::Object_var objS = _NS->Resolve("/Kernel/Session");
 208   if (!CORBA::is_nil(objS))
 209   {
 210     session = SALOME::Session::_narrow(objS);
 211     if (!CORBA::is_nil(session))
 212       pid = session->getPID();
 213   }
 214
 215   bool isOK;
 216   isOK = _NS->Change_Directory("/Containers");
 217   if( isOK ){
 218     std::vector<std::string> vec = _NS->list_directory_recurs();
 219     std::list<std::string> lstCont;
 220     for(std::vector<std::string>::iterator iter = vec.begin();iter!=vec.end();iter++)
 221       {
 222         SCRUTE((*iter));
 223         CORBA::Object_var obj=_NS->Resolve((*iter).c_str());
 224         try
 225           {
 226             Engines::Container_var cont=Engines::Container::_narrow(obj);
 227             if(!CORBA::is_nil(cont) && pid != cont->getPID())
 228               lstCont.push_back((*iter));
 229           }
 230         catch(const CORBA::Exception& e)
 231           {
 232             // ignore this entry and continue
 233           }
 234       }
 235     MESSAGE("Container list: ");
 236     for(std::list<std::string>::iterator iter=lstCont.begin();iter!=lstCont.end();iter++){
 237       SCRUTE((*iter));
 238     }
 239     for(std::list<std::string>::iterator iter=lstCont.begin();iter!=lstCont.end();iter++)
 240     {
 241       try
 242       {
 243         SCRUTE((*iter));
 244         CORBA::Object_var obj=_NS->Resolve((*iter).c_str());
 245         Engines::Container_var cont=Engines::Container::_narrow(obj);
 246         if(!CORBA::is_nil(cont))
 247         {
 248           MESSAGE("ShutdownContainers: " << (*iter));
 249           cont->Shutdown();
 250         }
 251         else
 252           MESSAGE("ShutdownContainers: no container ref for " << (*iter));
 253       }
 254       catch(CORBA::SystemException& e)
 255       {
 256         INFOS("CORBA::SystemException ignored : " << e);
 257       }
 258       catch(CORBA::Exception&)
 259       {
 260         INFOS("CORBA::Exception ignored.");
 261       }
 262       catch(...)
 263       {
 264         INFOS("Unknown exception ignored.");
 265       }
 266     }
 267   }
 268 }
 269
 270 //=============================================================================
 271 //! Give a suitable Container given constraints
 272 /*! CORBA Method:
 273  *  \param params Container Parameters required for the container
 274  *  \return the container or nil
 275  */
 276 //=============================================================================
 277 Engines::Container_ptr SALOME_ContainerManager::GiveContainer(const Engines::ContainerParameters& params)
 278 {
 279   std::string machFile;
 280   Engines::Container_ptr ret(Engines::Container::_nil());
 281
 282   // Step 0: Default mode is start
 283   Engines::ContainerParameters local_params(params);
 284   if (std::string(local_params.mode.in()) == "")
 285     local_params.mode = CORBA::string_dup("start");
 286   std::string mode = local_params.mode.in();
 287   MESSAGE("[GiveContainer] starting with mode: " << mode);
 288
 289   // Step 1: Find Container for find and findorstart mode
 290   if (mode == "find" || mode == "findorstart")
 291   {
 292     ret = FindContainer(params, params.resource_params.resList);
 293     if(!CORBA::is_nil(ret))
 294       return ret;
 295     else
 296     {
 297       if (mode == "find")
 298       {
 299         MESSAGE("[GiveContainer] no container found");
 300         return ret;
 301       }
 302       else
 303       {
 304         mode = "start";
 305       }
 306     }
 307   }
 308
 309   // Step 2: Get all possibleResources from the parameters
 310   // Consider only resources that can run containers
 311   resourceParams resource_params = resourceParameters_CORBAtoCPP(local_params.resource_params);
 312   resource_params.can_run_containers = true;
 313   std::vector<std::string> possibleResources = _resManager->GetFittingResources(resource_params);
 314   MESSAGE("[GiveContainer] - length of possible resources " << possibleResources.size());
 315   std::vector<std::string> local_resources;
 316
 317   // Step 3: if mode is "get" keep only machines with existing containers
 318   if(mode == "get")
 319   {
 320     for(unsigned int i=0; i < possibleResources.size(); i++)
 321     {
 322       Engines::Container_ptr cont = FindContainer(params, possibleResources[i]);
 323       try
 324       {
 325         if(!cont->_non_existent())
 326           local_resources.push_back(possibleResources[i]);
 327       }
 328       catch(CORBA::Exception&) {}
 329     }
 330
 331     // if local_resources is empty, we cannot give a container
 332     if (local_resources.size() == 0)
 333     {
 334       MESSAGE("[GiveContainer] cannot find a container for mode get");
 335       return ret;
 336     }
 337   }
 338   else
 339     local_resources = possibleResources;
 340
 341   // Step 4: select the resource where to get/start the container
 342   bool resource_available = true;
 343   std::string resource_selected;
 344   std::vector<std::string> resources = local_resources;
 345   while (resource_available)
 346   {
 347     if (resources.size() == 0)
 348       resource_available = false;
 349     else
 350     {
 351       try
 352       {
 353         resource_selected = _resManager->Find(params.resource_params.policy.in(), resources);
 354         // Remove resource_selected from vector
 355         std::vector<std::string>::iterator it;
 356         for (it=resources.begin() ; it < resources.end(); it++ )
 357           if (*it == resource_selected)
 358           {
 359             resources.erase(it);
 360             break;
 361           }
 362       }
 363       catch(const SALOME_Exception &ex)
 364       {
 365         MESSAGE("[GiveContainer] Exception in ResourceManager find !: " << ex.what());
 366         return ret;
 367       }
 368       MESSAGE("[GiveContainer] Resource selected is: " << resource_selected);
 369
 370       // Step 5: Create container name
 371       ParserResourcesType resource_definition = _resManager->GetResourceDefinition(resource_selected);
 372       std::string hostname(resource_definition.HostName);
 373       std::string containerNameInNS;
 374       if(params.isMPI){
 375         int nbproc;
 376         if ( params.nb_proc <= 0 )
 377           nbproc = 1;
 378         else
 379           nbproc = params.nb_proc;
 380         try
 381         {
 382           if( GetenvThreadSafe("LIBBATCH_NODEFILE") != NULL )
 383             machFile = machinesFile(nbproc);
 384         }
 385         catch(const SALOME_Exception & ex)
 386         {
 387           std::string err_msg = ex.what();
 388           err_msg += params.container_name;
 389           INFOS(err_msg.c_str());
 390           return ret;
 391         }
 392         // A mpi parallel container register on zero node in NS
 393         containerNameInNS = _NS->BuildContainerNameForNS(params, GetMPIZeroNode(hostname,machFile).c_str());
 394       }
 395       else
 396         containerNameInNS = _NS->BuildContainerNameForNS(params, hostname.c_str());
 397       MESSAGE("[GiveContainer] Container name in the naming service: " << containerNameInNS);
 398
 399       // Step 6: check if the name exists in naming service
 400       //if params.mode == "getorstart" or "get" use the existing container
 401       //if params.mode == "start" shutdown the existing container before launching a new one with that name
 402
 403       { // critical section
 404         Utils_Locker lock (&_giveContainerMutex1);
 405         CORBA::Object_var obj = _NS->Resolve(containerNameInNS.c_str());
 406         if (!CORBA::is_nil(obj))
 407           {
 408             try
 409             {
 410                 Engines::Container_var cont=Engines::Container::_narrow(obj);
 411                 if(!cont->_non_existent())
 412                   {
 413                     if(std::string(params.mode.in())=="getorstart" || std::string(params.mode.in())=="get"){
 414                         return cont._retn(); /* the container exists and params.mode is getorstart or get use it*/
 415                     }
 416                     else
 417                       {
 418                         INFOS("[GiveContainer] A container is already registered with the name: " << containerNameInNS << ", shutdown the existing container");
 419                         cont->Shutdown(); // shutdown the registered container if it exists
 420                       }
 421                   }
 422             }
 423             catch(CORBA::Exception&)
 424             {
 425                 INFOS("[GiveContainer] CORBA::Exception ignored when trying to get the container - we start a new one");
 426             }
 427           }
 428       } // end critical section
 429       Engines::Container_var cont = LaunchContainer(params, resource_selected, hostname, machFile, containerNameInNS);
 430       if (!CORBA::is_nil(cont))
 431       {
 432         INFOS("[GiveContainer] container " << containerNameInNS << " launched");
 433         return cont._retn();
 434       }
 435       else
 436       {
 437         INFOS("[GiveContainer] Failed to launch container on resource " << resource_selected);
 438       }
 439     }
 440   }
 441
 442   // We were not able to launch the container
 443   INFOS("[GiveContainer] Cannot launch the container on the following selected resources:")
 444   std::vector<std::string>::iterator it;
 445   for (it=local_resources.begin() ; it < local_resources.end(); it++ )
 446     INFOS("[GiveContainer] " << *it)
 447   return ret;
 448 }
 449
 450 Engines::Container_ptr
 451 SALOME_ContainerManager::LaunchContainer(const Engines::ContainerParameters& params,
 452                                          const std::string & resource_selected,
 453                                          const std::string & hostname,
 454                                          const std::string & machFile,
 455                                          const std::string & containerNameInNS)
 456 {
 457   std::string user,command,logFilename,tmpFileName;
 458   int status;
 459   Engines::Container_ptr ret(Engines::Container::_nil());
 460   {//start of critical section
 461     Utils_Locker lock (&_giveContainerMutex1);
 462     // Step 1: type of container: PaCO, Exe, Mpi or Classic
 463     // Mpi already tested in step 5, specific code on BuildCommandToLaunch Local/Remote Container methods
 464     // TODO -> separates Mpi from Classic/Exe
 465     // Classic or Exe ?
 466     std::string container_exe = "SALOME_Container"; // Classic container
 467     Engines::ContainerParameters local_params(params);
 468     int found=0;
 469     try
 470     {
 471         CORBA::String_var container_exe_tmp;
 472         CORBA::Object_var obj = _NS->Resolve("/Kernel/ModulCatalog");
 473         SALOME_ModuleCatalog::ModuleCatalog_var Catalog = SALOME_ModuleCatalog::ModuleCatalog::_narrow(obj) ;
 474         if (CORBA::is_nil (Catalog))
 475           {
 476             INFOS("[GiveContainer] Module Catalog is not found -> cannot launch a container");
 477             return ret;
 478           }
 479         // Loop through component list
 480         for(unsigned int i=0; i < local_params.resource_params.componentList.length(); i++)
 481           {
 482             const char* compoi = local_params.resource_params.componentList[i];
 483             SALOME_ModuleCatalog::Acomponent_var compoInfo = Catalog->GetComponent(compoi);
 484             if (CORBA::is_nil (compoInfo))
 485               {
 486                 continue;
 487               }
 488             SALOME_ModuleCatalog::ImplType impl=compoInfo->implementation_type();
 489             container_exe_tmp=compoInfo->implementation_name();
 490             if(impl==SALOME_ModuleCatalog::CEXE)
 491               {
 492                 if(found)
 493                   {
 494                     INFOS("ContainerManager Error: you can't have 2 CEXE component in the same container" );
 495                     return Engines::Container::_nil();
 496                   }
 497                 MESSAGE("[GiveContainer] Exe container found !: " << container_exe_tmp);
 498                 container_exe = container_exe_tmp.in();
 499                 found=1;
 500               }
 501           }
 502     }
 503     catch (ServiceUnreachable&)
 504     {
 505         INFOS("Caught exception: Naming Service Unreachable");
 506         return ret;
 507     }
 508     catch (...)
 509     {
 510         INFOS("Caught unknown exception.");
 511         return ret;
 512     }
 513
 514     // Step 2: test resource
 515     // Only if an application directory is set
 516     if(hostname != Kernel_Utils::GetHostname() && _isAppliSalomeDefined)
 517       {
 518         // Preparing remote command
 519         std::string command = "";
 520         const ParserResourcesType resInfo(_resManager->GetResourceDefinition(resource_selected));
 521         command = getCommandToRunRemoteProcess(resInfo.Protocol, resInfo.HostName, resInfo.UserName);
 522         if (resInfo.AppliPath != "")
 523           command += resInfo.AppliPath;
 524         else
 525           {
 526             ASSERT(GetenvThreadSafe("APPLI"));
 527             command += GetenvThreadSafeAsString("APPLI");
 528           }
 529         command += "/runRemote.sh ";
 530         ASSERT(GetenvThreadSafe("NSHOST"));
 531         command += GetenvThreadSafeAsString("NSHOST"); // hostname of CORBA name server
 532         command += " ";
 533         ASSERT(GetenvThreadSafe("NSPORT"));
 534         command += GetenvThreadSafeAsString("NSPORT"); // port of CORBA name server
 535         command += " \"ls /tmp >/dev/null 2>&1\"";
 536
 537         // Launch remote command
 538         int status = SystemThreadSafe(command.c_str());
 539         if (status != 0)
 540           {
 541             // Error on resource - cannot launch commands
 542             INFOS("[LaunchContainer] Cannot launch commands on machine " << hostname);
 543             INFOS("[LaunchContainer] Command was " << command);
 544 #ifndef WIN32
 545             INFOS("[LaunchContainer] Command status is " << WEXITSTATUS(status));
 546 #endif
 547             return Engines::Container::_nil();
 548           }
 549       }
 550
 551     // Step 3: start a new container
 552     // Check if a PaCO container
 553     // PaCO++
 554     if (std::string(local_params.parallelLib.in()) != "")
 555       {
 556         ret = StartPaCOPPContainer(params, resource_selected);
 557         return ret;
 558       }
 559     // Other type of containers...
 560     MESSAGE("[GiveContainer] Try to launch a new container on " << resource_selected);
 561     // if a parallel container is launched in batch job, command is: "mpirun -np nbproc -machinefile nodesfile SALOME_MPIContainer"
 562     if( GetenvThreadSafe("LIBBATCH_NODEFILE") != NULL && params.isMPI )
 563       command = BuildCommandToLaunchLocalContainer(params, machFile, container_exe, tmpFileName);
 564     // if a container is launched on localhost, command is "SALOME_Container" or "mpirun -np nbproc SALOME_MPIContainer"
 565     else if(hostname == Kernel_Utils::GetHostname())
 566       command = BuildCommandToLaunchLocalContainer(params, machFile, container_exe, tmpFileName);
 567     // if a container is launched in remote mode, command is "ssh resource_selected SALOME_Container" or "ssh resource_selected mpirun -np nbproc SALOME_MPIContainer"
 568     else
 569       command = BuildCommandToLaunchRemoteContainer(resource_selected, params, container_exe);
 570
 571     //redirect stdout and stderr in a file
 572 #ifdef WIN32
 573     logFilename=GetenvThreadSafeAsString("TEMP");
 574     logFilename += "\\";
 575     user = GetenvThreadSafeAsString( "USERNAME" );
 576 #else
 577     user = GetenvThreadSafeAsString( "USER" );
 578     if (user.empty())
 579       user = GetenvThreadSafeAsString( "LOGNAME" );
 580     logFilename="/tmp";
 581     char* val = GetenvThreadSafe("SALOME_TMP_DIR");
 582     if(val)
 583       {
 584         struct stat file_info;
 585         stat(val, &file_info);
 586         bool is_dir = S_ISDIR(file_info.st_mode);
 587         if (is_dir)logFilename=val;
 588         else std::cerr << "SALOME_TMP_DIR environment variable is not a directory use /tmp instead" << std::endl;
 589       }
 590     logFilename += "/";
 591 #endif
 592     logFilename += _NS->ContainerName(params)+"_"+ resource_selected +"_"+user;
 593     std::ostringstream tmp;
 594     tmp << "_" << getpid();
 595     logFilename += tmp.str();
 596     logFilename += ".log" ;
 597     command += " > " + logFilename + " 2>&1";
 598     MakeTheCommandToBeLaunchedASync(command);
 599
 600     // launch container with a system call
 601     status=SystemThreadSafe(command.c_str());
 602   }//end of critical of section
 603
 604   if (status == -1)
 605     {
 606       INFOS("[LaunchContainer] command failed (system command status -1): " << command);
 607       RmTmpFile(tmpFileName); // command file can be removed here
 608       return Engines::Container::_nil();
 609     }
 610   else if (status == 217)
 611     {
 612       INFOS("[LaunchContainer] command failed (system command status 217): " << command);
 613       RmTmpFile(tmpFileName); // command file can be removed here
 614       return Engines::Container::_nil();
 615     }
 616   else
 617     {
 618       // Step 4: Wait for the container
 619       int count(GetTimeOutToLoaunchServer());
 620       INFOS("[GiveContainer] waiting " << count << " second steps container " << containerNameInNS);
 621       while (CORBA::is_nil(ret) && count)
 622         {
 623           SleepInSecond(1);
 624           count--;
 625           MESSAGE("[GiveContainer] step " << count << " Waiting for container on " << resource_selected);
 626           CORBA::Object_var obj(_NS->Resolve(containerNameInNS.c_str()));
 627           ret=Engines::Container::_narrow(obj);
 628         }
 629       if (CORBA::is_nil(ret))
 630         {
 631           INFOS("[GiveContainer] was not able to launch container " << containerNameInNS);
 632         }
 633       else
 634         {
 635           // Setting log file name
 636           logFilename=":"+logFilename;
 637           logFilename="@"+Kernel_Utils::GetHostname()+logFilename;//threadsafe
 638           logFilename=user+logFilename;
 639           ret->logfilename(logFilename.c_str());
 640           RmTmpFile(tmpFileName); // command file can be removed here
 641         }
 642     }
 643   return ret;
 644 }
 645
 646 //=============================================================================
 647 //! Find a container given constraints (params) on a list of machines (possibleComputers)
 648 //! agy : this method is ThreadSafe
 649 /*!
 650  *
 651  */
 652 //=============================================================================
 653
 654 Engines::Container_ptr SALOME_ContainerManager::FindContainer(const Engines::ContainerParameters& params, const Engines::ResourceList& possibleResources)
 655 {
 656   MESSAGE("[FindContainer] FindContainer on " << possibleResources.length() << " resources");
 657   for(unsigned int i=0; i < possibleResources.length();i++)
 658     {
 659       Engines::Container_ptr cont = FindContainer(params, possibleResources[i].in());
 660       if(!CORBA::is_nil(cont))
 661         return cont;
 662     }
 663   MESSAGE("[FindContainer] no container found");
 664   return Engines::Container::_nil();
 665 }
 666
 667 //=============================================================================
 668 //! Find a container given constraints (params) on a machine (theMachine)
 669 //! agy : this method is ThreadSafe
 670 /*!
 671  *
 672  */
 673 //=============================================================================
 674
 675 Engines::Container_ptr
 676 SALOME_ContainerManager::FindContainer(const Engines::ContainerParameters& params, const std::string& resource)
 677 {
 678   ParserResourcesType resource_definition = _resManager->GetResourceDefinition(resource);
 679   std::string hostname(resource_definition.HostName);
 680   std::string containerNameInNS(_NS->BuildContainerNameForNS(params, hostname.c_str()));
 681   MESSAGE("[FindContainer] Try to find a container  " << containerNameInNS << " on resource " << resource);
 682   CORBA::Object_var obj = _NS->Resolve(containerNameInNS.c_str());
 683   try
 684   {
 685     if(obj->_non_existent())
 686       return Engines::Container::_nil();
 687     else
 688       return Engines::Container::_narrow(obj);
 689   }
 690   catch(const CORBA::Exception& e)
 691   {
 692     return Engines::Container::_nil();
 693   }
 694 }
 695
 696
 697 bool isPythonContainer(const char* ContainerName);
 698
 699 //=============================================================================
 700 /*!
 701  *  This is no longer valid (C++ container are also python containers)
 702  */
 703 //=============================================================================
 704 bool isPythonContainer(const char* ContainerName)
 705 {
 706   return false; // VSR 02/08/2013: Python containers are no more supported
 707   bool ret = false;
 708   int len = strlen(ContainerName);
 709
 710   if (len >= 2)
 711     if (strcmp(ContainerName + len - 2, "Py") == 0)
 712       ret = true;
 713
 714   return ret;
 715 }
 716
 717 //=============================================================================
 718 /*!
 719  *  Builds the script to be launched
 720  *
 721  *  If SALOME Application not defined ($APPLI),
 722  *  see BuildTempFileToLaunchRemoteContainer()
 723  *
 724  *  Else rely on distant configuration. Command is under the form (example):
 725  *  ssh user@machine distantPath/runRemote.sh hostNS portNS WORKINGDIR workingdir \
 726  *                   SALOME_Container containerName &"
 727
 728  *  - where user is ommited if not specified in CatalogResources,
 729  *  - where distant path is always relative to user@machine $HOME, and
 730  *    equal to $APPLI if not specified in CatalogResources,
 731  *  - where hostNS is the hostname of CORBA naming server (set by scripts to
 732  *    use to launch SALOME and servers in $APPLI: runAppli.sh, runRemote.sh)
 733  *  - where portNS is the port used by CORBA naming server (set by scripts to
 734  *    use to launch SALOME and servers in $APPLI: runAppli.sh, runRemote.sh)
 735  *  - where workingdir is the requested working directory for the container.
 736  *    If WORKINGDIR (and workingdir) is not present the working dir will be $HOME
 737  */
 738 //=============================================================================
 739
 740 std::string
 741 SALOME_ContainerManager::BuildCommandToLaunchRemoteContainer(const std::string& resource_name, const Engines::ContainerParameters& params, const std::string& container_exe) const
 742 {
 743   std::string command,tmpFileName;
 744   if (!_isAppliSalomeDefined)
 745     command = BuildTempFileToLaunchRemoteContainer(resource_name, params, tmpFileName);
 746   else
 747   {
 748     int nbproc;
 749     const ParserResourcesType resInfo(_resManager->GetResourceDefinition(resource_name));
 750
 751     if (params.isMPI)
 752     {
 753       if ( params.nb_proc <= 0 )
 754         nbproc = 1;
 755       else
 756         nbproc = params.nb_proc;
 757     }
 758
 759     // "ssh -l user machine distantPath/runRemote.sh hostNS portNS WORKINGDIR workingdir \
 760     //  SALOME_Container containerName &"
 761     command = getCommandToRunRemoteProcess(resInfo.Protocol, resInfo.HostName, resInfo.UserName);
 762
 763     if (resInfo.AppliPath != "")
 764       command += resInfo.AppliPath; // path relative to user@machine $HOME
 765     else
 766     {
 767       ASSERT(GetenvThreadSafe("APPLI"));
 768       command += GetenvThreadSafeAsString("APPLI"); // path relative to user@machine $HOME
 769     }
 770
 771     command += "/runRemote.sh ";
 772
 773     ASSERT(GetenvThreadSafe("NSHOST"));
 774     command += GetenvThreadSafeAsString("NSHOST"); // hostname of CORBA name server
 775
 776     command += " ";
 777     ASSERT(GetenvThreadSafe("NSPORT"));
 778     command += GetenvThreadSafeAsString("NSPORT"); // port of CORBA name server
 779
 780     std::string wdir = params.workingdir.in();
 781     if(wdir != "")
 782     {
 783       command += " WORKINGDIR ";
 784       command += " '";
 785       if(wdir == "$TEMPDIR")
 786         wdir="\\$TEMPDIR";
 787       command += wdir; // requested working directory
 788       command += "'";
 789     }
 790
 791     if(params.isMPI)
 792     {
 793       command += " mpirun -np ";
 794       std::ostringstream o;
 795       o << nbproc << " ";
 796       command += o.str();
 797 #ifdef LAM_MPI
 798       command += "-x PATH,LD_LIBRARY_PATH,OMNIORB_CONFIG,SALOME_trace ";
 799 #elif defined(OPEN_MPI)
 800       if( GetenvThreadSafe("OMPI_URI_FILE") == NULL )
 801         command += "-x PATH -x LD_LIBRARY_PATH -x OMNIORB_CONFIG -x SALOME_trace";
 802       else{
 803         command += "-x PATH -x LD_LIBRARY_PATH -x OMNIORB_CONFIG -x SALOME_trace -ompi-server file:";
 804         command += GetenvThreadSafeAsString("OMPI_URI_FILE");
 805       }
 806 #elif defined(MPICH)
 807       command += "-nameserver " + Kernel_Utils::GetHostname();
 808 #endif
 809       command += " SALOME_MPIContainer ";
 810     }
 811     else
 812       command += " " +container_exe+ " ";
 813
 814     command += _NS->ContainerName(params);
 815     command += " -";
 816     AddOmninamesParams(command);
 817
 818     MESSAGE("command =" << command);
 819   }
 820
 821   return command;
 822 }
 823
 824 //=============================================================================
 825 /*!
 826  *  builds the command to be launched.
 827  */
 828 //=============================================================================
 829 std::string SALOME_ContainerManager::BuildCommandToLaunchLocalContainer(const Engines::ContainerParameters& params, const std::string& machinesFile, const std::string& container_exe, std::string& tmpFileName) const
 830 {
 831   tmpFileName = BuildTemporaryFileName();
 832   std::string command;
 833   int nbproc = 0;
 834
 835   std::ostringstream o;
 836
 837   if (params.isMPI)
 838     {
 839       o << "mpirun -np ";
 840
 841       if ( params.nb_proc <= 0 )
 842         nbproc = 1;
 843       else
 844         nbproc = params.nb_proc;
 845
 846       o << nbproc << " ";
 847
 848       if( GetenvThreadSafe("LIBBATCH_NODEFILE") != NULL )
 849         o << "-machinefile " << machinesFile << " ";
 850
 851 #ifdef LAM_MPI
 852       o << "-x PATH,LD_LIBRARY_PATH,OMNIORB_CONFIG,SALOME_trace ";
 853 #elif defined(OPEN_MPI)
 854       if( GetenvThreadSafe("OMPI_URI_FILE") == NULL )
 855         o << "-x PATH -x LD_LIBRARY_PATH -x OMNIORB_CONFIG -x SALOME_trace";
 856       else
 857         {
 858           o << "-x PATH -x LD_LIBRARY_PATH -x OMNIORB_CONFIG -x SALOME_trace -ompi-server file:";
 859           o << GetenvThreadSafeAsString("OMPI_URI_FILE");
 860         }
 861 #elif defined(MPICH)
 862       o << "-nameserver " + Kernel_Utils::GetHostname();
 863 #endif
 864
 865       if (isPythonContainer(params.container_name))
 866         o << " pyMPI SALOME_ContainerPy.py ";
 867       else
 868         o << " SALOME_MPIContainer ";
 869     }
 870
 871   else
 872     {
 873       std::string wdir=params.workingdir.in();
 874       if(wdir != "")
 875         {
 876           // a working directory is requested
 877           if(wdir == "$TEMPDIR")
 878             {
 879               // a new temporary directory is requested
 880               std::string dir = Kernel_Utils::GetTmpDir();
 881 #ifdef WIN32
 882               o << "cd /d " << dir << std::endl;
 883 #else
 884               o << "cd " << dir << ";";
 885 #endif
 886
 887             }
 888           else
 889             {
 890               // a permanent directory is requested use it or create it
 891 #ifdef WIN32
 892               o << "mkdir " + wdir << std::endl;
 893               o << "cd /D " + wdir << std::endl;
 894 #else
 895               o << "mkdir -p " << wdir << " && cd " << wdir + ";";
 896 #endif
 897             }
 898         }
 899
 900       if (isPythonContainer(params.container_name))
 901         o << "SALOME_ContainerPy.py ";
 902       else
 903         o << container_exe + " ";
 904
 905     }
 906
 907   o << _NS->ContainerName(params);
 908   o << " -";
 909   AddOmninamesParams(o);
 910
 911   std::ofstream command_file( tmpFileName.c_str() );
 912   command_file << o.str();
 913   command_file.close();
 914
 915 #ifndef WIN32
 916   chmod(tmpFileName.c_str(), 0x1ED);
 917 #endif
 918   command = tmpFileName;
 919
 920   MESSAGE("Command is file ... " << command);
 921   MESSAGE("Command is ... " << o.str());
 922   return command;
 923 }
 924
 925
 926 //=============================================================================
 927 /*!
 928  *  removes the generated temporary file in case of a remote launch.
 929  *  This method is thread safe
 930  */
 931 //=============================================================================
 932
 933 void SALOME_ContainerManager::RmTmpFile(std::string& tmpFileName)
 934 {
 935   int lenght = tmpFileName.size();
 936   if ( lenght  > 0)
 937     {
 938 #ifdef WIN32
 939       std::string command = "del /F ";
 940 #else
 941       std::string command = "rm ";
 942 #endif
 943       if ( lenght > 4 )
 944         command += tmpFileName.substr(0, lenght - 3 );
 945       else
 946         command += tmpFileName;
 947       command += '*';
 948       SystemThreadSafe(command.c_str());
 949       //if dir is empty - remove it
 950       std::string tmp_dir = Kernel_Utils::GetDirByPath( tmpFileName );
 951       if ( Kernel_Utils::IsEmptyDir( tmp_dir ) )
 952         {
 953 #ifdef WIN32
 954           command = "del /F " + tmp_dir;
 955 #else
 956           command = "rmdir " + tmp_dir;
 957 #endif
 958           SystemThreadSafe(command.c_str());
 959         }
 960     }
 961 }
 962
 963 //=============================================================================
 964 /*!
 965  *   add to command all options relative to naming service.
 966  */
 967 //=============================================================================
 968
 969 void SALOME_ContainerManager::AddOmninamesParams(std::string& command) const
 970 {
 971   std::ostringstream oss;
 972   AddOmninamesParams(oss);
 973   command+=oss.str();
 974 }
 975
 976 //=============================================================================
 977 /*!
 978  *  add to command all options relative to naming service.
 979  */
 980 //=============================================================================
 981
 982 void SALOME_ContainerManager::AddOmninamesParams(std::ostream& fileStream) const
 983 {
 984   AddOmninamesParams(fileStream,_NS);
 985 }
 986
 987 //=============================================================================
 988 /*!
 989  *  add to command all options relative to naming service.
 990  */
 991 //=============================================================================
 992
 993 void SALOME_ContainerManager::AddOmninamesParams(std::ostream& fileStream, SALOME_NamingService *ns)
 994 {
 995   CORBA::String_var iorstr(ns->getIORaddr());
 996   fileStream << "ORBInitRef NameService=";
 997   fileStream << iorstr;
 998 }
 999
1000 void SALOME_ContainerManager::MakeTheCommandToBeLaunchedASync(std::string& command)
1001 {
1002 #ifdef WIN32
1003     command = "%PYTHONBIN% -c \"import subprocess ; subprocess.Popen(command).pid\"";
1004 #else
1005     command += " &";
1006 #endif
1007 }
1008
1009 int SALOME_ContainerManager::GetTimeOutToLoaunchServer()
1010 {
1011   int count(TIME_OUT_TO_LAUNCH_CONT);
1012   if (GetenvThreadSafe("TIMEOUT_TO_LAUNCH_CONTAINER") != 0)
1013     {
1014       std::string new_count_str(GetenvThreadSafeAsString("TIMEOUT_TO_LAUNCH_CONTAINER"));
1015       int new_count;
1016       std::istringstream ss(new_count_str);
1017       if (!(ss >> new_count))
1018         {
1019           INFOS("[LaunchContainer] TIMEOUT_TO_LAUNCH_CONTAINER should be an int");
1020         }
1021       else
1022         count = new_count;
1023     }
1024   return count;
1025 }
1026
1027 void SALOME_ContainerManager::SleepInSecond(int ellapseTimeInSecond)
1028 {
1029 #ifndef WIN32
1030   sleep( ellapseTimeInSecond ) ;
1031 #else
1032   int timeInMS(1000*ellapseTimeInSecond);
1033   Sleep(timeInMS);
1034 #endif
1035 }
1036
1037 //=============================================================================
1038 /*!
1039  *  generate a file name in /tmp directory
1040  */
1041 //=============================================================================
1042
1043 std::string SALOME_ContainerManager::BuildTemporaryFileName()
1044 {
1045   //build more complex file name to support multiple salome session
1046   std::string aFileName = Kernel_Utils::GetTmpFileName();
1047 #ifndef WIN32
1048   aFileName += ".sh";
1049 #else
1050   aFileName += ".bat";
1051 #endif
1052   return aFileName;
1053 }
1054
1055 //=============================================================================
1056 /*!
1057  *  Builds in a temporary file the script to be launched.
1058  *
1059  *  Used if SALOME Application ($APPLI) is not defined.
1060  *  The command is build with data from CatalogResources, in which every path
1061  *  used on remote computer must be defined.
1062  */
1063 //=============================================================================
1064
1065 std::string SALOME_ContainerManager::BuildTempFileToLaunchRemoteContainer (const std::string& resource_name, const Engines::ContainerParameters& params, std::string& tmpFileName) const
1066 {
1067   int status;
1068
1069   tmpFileName = BuildTemporaryFileName();
1070   std::ofstream tempOutputFile;
1071   tempOutputFile.open(tmpFileName.c_str(), std::ofstream::out );
1072   const ParserResourcesType resInfo(_resManager->GetResourceDefinition(resource_name));
1073   tempOutputFile << "#! /bin/sh" << std::endl;
1074
1075   // --- set env vars
1076
1077   tempOutputFile << "export SALOME_trace=local" << std::endl; // mkr : 27.11.2006 : PAL13967 - Distributed supervision graphs - Problem with "SALOME_trace"
1078   //tempOutputFile << "source " << resInfo.PreReqFilePath << endl;
1079
1080   // ! env vars
1081
1082   if (params.isMPI)
1083     {
1084       tempOutputFile << "mpirun -np ";
1085       int nbproc;
1086
1087       if ( params.nb_proc <= 0 )
1088         nbproc = 1;
1089       else
1090         nbproc = params.nb_proc;
1091
1092       std::ostringstream o;
1093
1094       tempOutputFile << nbproc << " ";
1095 #ifdef LAM_MPI
1096       tempOutputFile << "-x PATH,LD_LIBRARY_PATH,OMNIORB_CONFIG,SALOME_trace ";
1097 #elif defined(OPEN_MPI)
1098       if( GetenvThreadSafe("OMPI_URI_FILE") == NULL )
1099         tempOutputFile << "-x PATH -x LD_LIBRARY_PATH -x OMNIORB_CONFIG -x SALOME_trace";
1100       else{
1101         tempOutputFile << "-x PATH -x LD_LIBRARY_PATH -x OMNIORB_CONFIG -x SALOME_trace -ompi-server file:";
1102         tempOutputFile << GetenvThreadSafeAsString("OMPI_URI_FILE");
1103       }
1104 #elif defined(MPICH)
1105       tempOutputFile << "-nameserver " + Kernel_Utils::GetHostname();
1106 #endif
1107     }
1108
1109   tempOutputFile << GetenvThreadSafeAsString("KERNEL_ROOT_DIR") << "/bin/salome/";
1110
1111   if (params.isMPI)
1112     {
1113       if (isPythonContainer(params.container_name))
1114         tempOutputFile << " pyMPI SALOME_ContainerPy.py ";
1115       else
1116         tempOutputFile << " SALOME_MPIContainer ";
1117     }
1118
1119   else
1120     {
1121       if (isPythonContainer(params.container_name))
1122         tempOutputFile << "SALOME_ContainerPy.py ";
1123       else
1124         tempOutputFile << "SALOME_Container ";
1125     }
1126
1127   tempOutputFile << _NS->ContainerName(params) << " -";
1128   AddOmninamesParams(tempOutputFile);
1129   tempOutputFile << " &" << std::endl;
1130   tempOutputFile.flush();
1131   tempOutputFile.close();
1132 #ifndef WIN32
1133   chmod(tmpFileName.c_str(), 0x1ED);
1134 #endif
1135
1136   // --- Build command
1137
1138   std::string command;
1139
1140   if (resInfo.Protocol == rsh)
1141     {
1142       command = "rsh ";
1143       std::string commandRcp = "rcp ";
1144       commandRcp += tmpFileName;
1145       commandRcp += " ";
1146       commandRcp += resInfo.HostName;
1147       commandRcp += ":";
1148       commandRcp += tmpFileName;
1149       status = SystemThreadSafe(commandRcp.c_str());
1150     }
1151
1152   else if (resInfo.Protocol == ssh)
1153     {
1154       command = "ssh ";
1155       std::string commandRcp = "scp ";
1156       commandRcp += tmpFileName;
1157       commandRcp += " ";
1158       commandRcp += resInfo.HostName;
1159       commandRcp += ":";
1160       commandRcp += tmpFileName;
1161       status = SystemThreadSafe(commandRcp.c_str());
1162     }
1163
1164   else if (resInfo.Protocol == srun)
1165     {
1166       command = "srun -n 1 -N 1 --share --nodelist=";
1167       std::string commandRcp = "rcp ";
1168       commandRcp += tmpFileName;
1169       commandRcp += " ";
1170       commandRcp += resInfo.HostName;
1171       commandRcp += ":";
1172       commandRcp += tmpFileName;
1173       status = SystemThreadSafe(commandRcp.c_str());
1174     }
1175   else
1176     throw SALOME_Exception("Unknown protocol");
1177
1178   if(status)
1179     throw SALOME_Exception("Error of connection on remote host");
1180
1181   command += resInfo.HostName;
1182   command += " ";
1183   command += tmpFileName;
1184
1185   SCRUTE(command);
1186
1187   return command;
1188
1189 }
1190
1191 std::string SALOME_ContainerManager::GetMPIZeroNode(const std::string machine, const std::string machinesFile) const
1192 {
1193   int status;
1194   std::string zeronode;
1195   std::string command;
1196   std::string tmpFile = BuildTemporaryFileName();
1197
1198   if( GetenvThreadSafe("LIBBATCH_NODEFILE") == NULL )
1199     {
1200       if (_isAppliSalomeDefined)
1201         {
1202           const ParserResourcesType resInfo(_resManager->GetResourceDefinition(machine));
1203
1204           if (resInfo.Protocol == rsh)
1205             command = "rsh ";
1206           else if (resInfo.Protocol == ssh)
1207             command = "ssh ";
1208           else if (resInfo.Protocol == srun)
1209             command = "srun -n 1 -N 1 --share --nodelist=";
1210           else
1211             throw SALOME_Exception("Unknown protocol");
1212
1213           if (resInfo.UserName != "")
1214             {
1215               command += "-l ";
1216               command += resInfo.UserName;
1217               command += " ";
1218             }
1219
1220           command += resInfo.HostName;
1221           command += " ";
1222
1223           if (resInfo.AppliPath != "")
1224             command += resInfo.AppliPath; // path relative to user@machine $HOME
1225           else
1226             {
1227               ASSERT(GetenvThreadSafe("APPLI"));
1228               command += GetenvThreadSafeAsString("APPLI"); // path relative to user@machine $HOME
1229             }
1230
1231           command += "/runRemote.sh ";
1232
1233           ASSERT(GetenvThreadSafe("NSHOST"));
1234           command += GetenvThreadSafeAsString("NSHOST"); // hostname of CORBA name server
1235
1236           command += " ";
1237           ASSERT(GetenvThreadSafe("NSPORT"));
1238           command += GetenvThreadSafeAsString("NSPORT"); // port of CORBA name server
1239
1240           command += " mpirun -np 1 hostname -s > " + tmpFile;
1241         }
1242       else
1243         command = "mpirun -np 1 hostname -s > " + tmpFile;
1244     }
1245   else
1246     command = "mpirun -np 1 -machinefile " + machinesFile + " hostname -s > " + tmpFile;
1247
1248   status = SystemThreadSafe(command.c_str());
1249   if( status == 0 ){
1250     std::ifstream fp(tmpFile.c_str(),std::ios::in);
1251     while(fp >> zeronode);
1252   }
1253
1254   RmTmpFile(tmpFile);
1255
1256   return zeronode;
1257 }
1258
1259 std::string SALOME_ContainerManager::machinesFile(const int nbproc)
1260 {
1261   std::string tmp;
1262   std::string nodesFile = GetenvThreadSafeAsString("LIBBATCH_NODEFILE");
1263   std::string machinesFile = Kernel_Utils::GetTmpFileName();
1264   std::ifstream fpi(nodesFile.c_str(),std::ios::in);
1265   std::ofstream fpo(machinesFile.c_str(),std::ios::out);
1266
1267   _numInstanceMutex.lock();
1268
1269   for(int i=0;i<_nbprocUsed;i++)
1270     fpi >> tmp;
1271
1272   for(int i=0;i<nbproc;i++)
1273     if( fpi >> tmp )
1274       fpo << tmp << std::endl;
1275     else
1276       throw SALOME_Exception("You need more processors than batch session have allocated for you! Unable to launch the mpi container: ");
1277
1278   _nbprocUsed += nbproc;
1279   fpi.close();
1280   fpo.close();
1281
1282   _numInstanceMutex.unlock();
1283
1284   return machinesFile;
1285
1286 }
1287
1288 std::set<pid_t> SALOME_ContainerManager::getpidofprogram(const std::string program)
1289 {
1290   std::set<pid_t> thepids;
1291   std::string tmpFile = Kernel_Utils::GetTmpFileName();
1292   std::string cmd;
1293   std::string thepid;
1294   cmd = "pidof " + program + " > " + tmpFile;
1295   SystemThreadSafe(cmd.c_str());
1296   std::ifstream fpi(tmpFile.c_str(),std::ios::in);
1297   while(fpi >> thepid){
1298     thepids.insert(atoi(thepid.c_str()));
1299   }
1300   return thepids;
1301 }
1302
1303 std::string SALOME_ContainerManager::getCommandToRunRemoteProcess(AccessProtocolType protocol,
1304                                                                   const std::string & hostname,
1305                                                                   const std::string & username)
1306 {
1307   std::ostringstream command;
1308   switch (protocol)
1309   {
1310   case rsh:
1311     command << "rsh ";
1312     if (username != "")
1313     {
1314       command << "-l " << username << " ";
1315     }
1316     command << hostname << " ";
1317     break;
1318   case ssh:
1319     command << "ssh ";
1320     if (username != "")
1321     {
1322       command << "-l " << username << " ";
1323     }
1324     command << hostname << " ";
1325     break;
1326   case srun:
1327     // no need to redefine the user with srun, the job user is taken by default
1328     // (note: for srun, user id can be specified with " --uid=<user>")
1329     command << "srun -n 1 -N 1 --share --nodelist=" << hostname << " ";
1330     break;
1331   case pbsdsh:
1332     command << "pbsdsh -o -h " << hostname << " ";
1333     break;
1334   case blaunch:
1335     command << "blaunch -no-shell " << hostname << " ";
1336     break;
1337   default:
1338     throw SALOME_Exception("Unknown protocol");
1339   }
1340
1341   return command.str();
1342 }
1343
1344 bool
1345 SALOME_ContainerManager::checkPaCOParameters(Engines::ContainerParameters & params, std::string resource_selected)
1346 {
1347   bool result = true;
1348
1349   // Step 1 : check ContainerParameters
1350   // Check container_name, has to be defined
1351   if (std::string(params.container_name.in()) == "")
1352   {
1353     INFOS("[checkPaCOParameters] You must define a container_name to launch a PaCO++ container");
1354     result = false;
1355   }
1356   // Check parallelLib
1357   std::string parallelLib = params.parallelLib.in();
1358   if (parallelLib != "Mpi" && parallelLib != "Dummy")
1359   {
1360     INFOS("[checkPaCOParameters] parallelLib is not correctly defined");
1361     INFOS("[checkPaCOParameters] you can chosse between: Mpi and Dummy");
1362     INFOS("[checkPaCOParameters] you entered: " << parallelLib);
1363     result = false;
1364   }
1365   // Check nb_proc
1366   if (params.nb_proc <= 0)
1367   {
1368     INFOS("[checkPaCOParameters] You must define a nb_proc > 0");
1369     result = false;
1370   }
1371
1372   // Step 2 : check resource_selected
1373   const ParserResourcesType resource_definition = _resManager->GetResourceDefinition(resource_selected);
1374   //std::string protocol = resource_definition->protocol.in();
1375   std::string username = resource_definition.UserName;
1376   std::string applipath = resource_definition.AppliPath;
1377
1378   //if (protocol == "" || username == "" || applipath == "")
1379   if (username == "" || applipath == "")
1380   {
1381     INFOS("[checkPaCOParameters] resource selected is not well defined");
1382     INFOS("[checkPaCOParameters] resource name: " << resource_definition.Name);
1383     INFOS("[checkPaCOParameters] resource hostname: " << resource_definition.HostName);
1384     INFOS("[checkPaCOParameters] resource protocol: " << resource_definition.getAccessProtocolTypeStr());
1385     INFOS("[checkPaCOParameters] resource username: " << username);
1386     INFOS("[checkPaCOParameters] resource applipath: " << applipath);
1387     result = false;
1388   }
1389
1390   return result;
1391 }
1392
1393 /*
1394  * :WARNING: Do not directly convert returned value to std::string
1395  * This function may return NULL if env variable is not defined.
1396  * And std::string(NULL) causes undefined behavior.
1397  * Use GetenvThreadSafeAsString to properly get a std::string.
1398 */
1399 char *SALOME_ContainerManager::GetenvThreadSafe(const char *name)
1400 {// getenv is not thread safe. See man 7 pthread.
1401   Utils_Locker lock (&_getenvMutex);
1402   return getenv(name);
1403 }
1404
1405 /*
1406  * Return env variable as a std::string.
1407  * Return empty string if env variable is not set.
1408  */
1409 std::string SALOME_ContainerManager::GetenvThreadSafeAsString(const char *name)
1410 {
1411   char* var = GetenvThreadSafe(name);
1412   return var ? std::string(var) : std::string();
1413 }
1414
1415 int SALOME_ContainerManager::SystemThreadSafe(const char *command)
1416 {
1417   Utils_Locker lock (&_systemMutex);
1418   return system(command);
1419 }
1420
1421 #ifdef WITH_PACO_PARALLEL
1422
1423 //=============================================================================
1424 /*! CORBA Method:
1425  *  Start a suitable PaCO++ Parallel Container in a list of machines.
1426  *  \param params           Container Parameters required for the container
1427  *  \return CORBA container reference.
1428  */
1429 //=============================================================================
1430 Engines::Container_ptr
1431 SALOME_ContainerManager::StartPaCOPPContainer(const Engines::ContainerParameters& params_const,
1432                                               std::string resource_selected)
1433 {
1434   CORBA::Object_var obj;
1435   PaCO::InterfaceManager_var container_proxy;
1436   Engines::Container_ptr ret = Engines::Container::_nil();
1437   Engines::ContainerParameters params(params_const);
1438   params.resource_params.name = CORBA::string_dup(resource_selected.c_str());
1439
1440   // Step 0 : Check parameters
1441   if (!checkPaCOParameters(params, resource_selected))
1442   {
1443     INFOS("[StartPaCOPPContainer] check parameters failed ! see logs...");
1444     return ret;
1445   }
1446
1447   // Step 1 : Starting a new parallel container !
1448   INFOS("[StartPaCOPPContainer] Starting a PaCO++ parallel container");
1449   INFOS("[StartPaCOPPContainer] on resource : " << resource_selected);
1450
1451   // Step 2 : Get a MachineFile for the parallel container
1452   std::string machine_file_name = _resManager->getMachineFile(resource_selected,
1453                                                               params.nb_proc,
1454                                                               params.parallelLib.in());
1455
1456   if (machine_file_name == "")
1457   {
1458     INFOS("[StartPaCOPPContainer] Machine file generation failed");
1459     return ret;
1460   }
1461
1462   // Step 3 : starting parallel container proxy
1463   std::string command_proxy("");
1464   std::string proxy_machine;
1465   try
1466   {
1467     command_proxy = BuildCommandToLaunchPaCOProxyContainer(params, machine_file_name, proxy_machine);
1468   }
1469   catch(const SALOME_Exception & ex)
1470   {
1471     INFOS("[StartPaCOPPContainer] Exception in BuildCommandToLaunchPaCOContainer");
1472     INFOS(ex.what());
1473     return ret;
1474   }
1475   obj = LaunchPaCOProxyContainer(command_proxy, params, proxy_machine);
1476   if (CORBA::is_nil(obj))
1477   {
1478     INFOS("[StartPaCOPPContainer] LaunchPaCOContainer for proxy returns NIL !");
1479     return ret;
1480   }
1481   container_proxy = PaCO::InterfaceManager::_narrow(obj);
1482   MESSAGE("[StartPaCOPPContainer] PaCO container proxy is launched");
1483
1484   // Step 4 : starting parallel container nodes
1485   std::string command_nodes("");
1486   SALOME_ContainerManager::actual_launch_machine_t nodes_machines;
1487   try
1488   {
1489     command_nodes = BuildCommandToLaunchPaCONodeContainer(params, machine_file_name, nodes_machines, proxy_machine);
1490   }
1491   catch(const SALOME_Exception & ex)
1492   {
1493     INFOS("[StarPaCOPPContainer] Exception in BuildCommandToLaunchPaCONodeContainer");
1494     INFOS(ex.what());
1495     return ret;
1496   }
1497
1498   std::string container_generic_node_name = std::string(params.container_name.in()) + std::string("Node");
1499   bool result = LaunchPaCONodeContainer(command_nodes, params, container_generic_node_name, nodes_machines);
1500   if (!result)
1501   {
1502     INFOS("[StarPaCOPPContainer] LaunchPaCONodeContainer failed !");
1503     // Il faut tuer le proxy
1504     try
1505     {
1506       Engines::Container_var proxy = Engines::Container::_narrow(container_proxy);
1507       proxy->Shutdown();
1508     }
1509     catch (...)
1510     {
1511       INFOS("[StarPaCOPPContainer] Exception catched from proxy Shutdown...");
1512     }
1513     return ret;
1514   }
1515
1516   // Step 4 : connecting nodes and the proxy to actually create a parallel container
1517   for (int i = 0; i < params.nb_proc; i++)
1518   {
1519     std::ostringstream tmp;
1520     tmp << i;
1521     std::string proc_number = tmp.str();
1522     std::string container_node_name = container_generic_node_name + proc_number;
1523
1524     std::string theNodeMachine(nodes_machines[i]);
1525     std::string containerNameInNS = _NS->BuildContainerNameForNS(container_node_name.c_str(), theNodeMachine.c_str());
1526     obj = _NS->Resolve(containerNameInNS.c_str());
1527     if (CORBA::is_nil(obj))
1528     {
1529       INFOS("[StarPaCOPPContainer] CONNECTION FAILED From Naming Service !");
1530       INFOS("[StarPaCOPPContainer] Container name is " << containerNameInNS);
1531       return ret;
1532     }
1533     try
1534     {
1535       MESSAGE("[StarPaCOPPContainer] Deploying node : " << container_node_name);
1536       PaCO::InterfaceParallel_var node = PaCO::InterfaceParallel::_narrow(obj);
1537       node->deploy();
1538       MESSAGE("[StarPaCOPPContainer] node " << container_node_name << " is deployed");
1539     }
1540     catch(CORBA::SystemException& e)
1541     {
1542       INFOS("[StarPaCOPPContainer] Exception in deploying node : " << containerNameInNS);
1543       INFOS("CORBA::SystemException : " << e);
1544       return ret;
1545     }
1546     catch(CORBA::Exception& e)
1547     {
1548       INFOS("[StarPaCOPPContainer] Exception in deploying node : " << containerNameInNS);
1549       INFOS("CORBA::Exception" << e);
1550       return ret;
1551     }
1552     catch(...)
1553     {
1554       INFOS("[StarPaCOPPContainer] Exception in deploying node : " << containerNameInNS);
1555       INFOS("Unknown exception !");
1556       return ret;
1557     }
1558   }
1559
1560   // Step 5 : starting parallel container
1561   try
1562   {
1563     MESSAGE ("[StarPaCOPPContainer] Starting parallel object");
1564     container_proxy->start();
1565     MESSAGE ("[StarPaCOPPContainer] Parallel object is started");
1566     ret = Engines::Container::_narrow(container_proxy);
1567   }
1568   catch(CORBA::SystemException& e)
1569   {
1570     INFOS("Caught CORBA::SystemException. : " << e);
1571   }
1572   catch(PortableServer::POA::ServantAlreadyActive&)
1573   {
1574     INFOS("Caught CORBA::ServantAlreadyActiveException");
1575   }
1576   catch(CORBA::Exception&)
1577   {
1578     INFOS("Caught CORBA::Exception.");
1579   }
1580   catch(std::exception& exc)
1581   {
1582     INFOS("Caught std::exception - "<<exc.what());
1583   }
1584   catch(...)
1585   {
1586     INFOS("Caught unknown exception.");
1587   }
1588   return ret;
1589 }
1590
1591 std::string
1592 SALOME_ContainerManager::BuildCommandToLaunchPaCOProxyContainer(const Engines::ContainerParameters& params,
1593                                                                 std::string machine_file_name,
1594                                                                 std::string & proxy_hostname)
1595 {
1596   // In the proxy case, we always launch a Dummy Proxy
1597   std::string exe_name = "SALOME_ParallelContainerProxyDummy";
1598   std::string container_name = params.container_name.in();
1599
1600   // Convert nb_proc in string
1601   std::ostringstream tmp_string;
1602   tmp_string << params.nb_proc;
1603   std::string nb_proc_str = tmp_string.str();
1604
1605   // Get resource definition
1606   ParserResourcesType resource_definition =
1607       _resManager->GetResourceDefinition(params.resource_params.name.in());
1608
1609   // Choose hostname
1610   std::string hostname;
1611   std::ifstream machine_file(machine_file_name.c_str());
1612   std::getline(machine_file, hostname, ' ');
1613   size_t found = hostname.find('\n');
1614   if (found!=std::string::npos)
1615     hostname.erase(found, 1); // Remove \n
1616   proxy_hostname = hostname;
1617   MESSAGE("[BuildCommandToLaunchPaCOProxyContainer] machine file name extracted is " << hostname);
1618
1619   // Remote execution
1620   bool remote_execution = false;
1621   if (hostname != std::string(Kernel_Utils::GetHostname()))
1622   {
1623     MESSAGE("[BuildCommandToLaunchPaCOProxyContainer] remote machine case detected !");
1624     remote_execution = true;
1625   }
1626
1627   // Log environnement
1628   std::string log_type("");
1629   char * get_val = GetenvThreadSafe("PARALLEL_LOG");
1630   if (get_val)
1631     log_type = get_val;
1632
1633   // Generating the command
1634   std::string command_begin("");
1635   std::string command_end("");
1636   std::ostringstream command;
1637
1638   LogConfiguration(log_type, "proxy", container_name, hostname, command_begin, command_end);
1639   command << command_begin;
1640
1641   // Adding connection command
1642   // We can only have a remote execution with
1643   // a SALOME application
1644   if (remote_execution)
1645   {
1646     ASSERT(GetenvThreadSafe("NSHOST"));
1647     ASSERT(GetenvThreadSafe("NSPORT"));
1648
1649     command << resource_definition.getAccessProtocolTypeStr();
1650     command << " -l ";
1651     command << resource_definition.UserName;
1652     command << " " << hostname;
1653     command << " " << resource_definition.AppliPath;
1654     command << "/runRemote.sh ";
1655     command << GetenvThreadSafeAsString("NSHOST") << " "; // hostname of CORBA name server
1656     command << GetenvThreadSafeAsString("NSPORT") << " "; // port of CORBA name server
1657   }
1658
1659   command << exe_name;
1660   command << " " << container_name;
1661   command << " Dummy";
1662   command << " " << hostname;
1663   command << " " << nb_proc_str;
1664   command << " -";
1665   AddOmninamesParams(command);
1666
1667   // Final command
1668   command << command_end;
1669   MESSAGE("[BuildCommandToLaunchPaCOProxyContainer] Command is: " << command.str());
1670
1671   return command.str();
1672 }
1673
1674 std::string
1675 SALOME_ContainerManager::BuildCommandToLaunchPaCONodeContainer(const Engines::ContainerParameters& params,
1676                                                                const std::string & machine_file_name,
1677                                                                SALOME_ContainerManager::actual_launch_machine_t & vect_machine,
1678                                                                const std::string & proxy_hostname)
1679 {
1680   // Name of exe
1681   std::string exe_name = "SALOME_ParallelContainerNode";
1682   exe_name += params.parallelLib.in();
1683   std::string container_name = params.container_name.in();
1684
1685   // Convert nb_proc in string
1686   std::ostringstream nb_proc_stream;
1687   nb_proc_stream << params.nb_proc;
1688
1689   // Get resource definition
1690   ParserResourcesType resource_definition =
1691       _resManager->GetResourceDefinition(params.resource_params.name.in());
1692
1693   // Log environnement
1694   std::string log_type("");
1695   char * get_val = GetenvThreadSafe("PARALLEL_LOG");
1696   if (get_val)
1697     log_type = get_val;
1698
1699   // Now the command is different according to paralleLib
1700   std::ostringstream command_nodes;
1701   std::ifstream machine_file(machine_file_name.c_str());
1702   if (std::string(params.parallelLib.in()) == "Dummy")
1703   {
1704     for (int i= 0; i < params.nb_proc; i++)
1705     {
1706       // Choose hostname
1707       std::string hostname;
1708       std::getline(machine_file, hostname);
1709       MESSAGE("[BuildCommandToLaunchPaCONodeContainer] machine file name extracted is " << hostname);
1710
1711       // Remote execution
1712       bool remote_execution = false;
1713       if (hostname != std::string(Kernel_Utils::GetHostname()))
1714       {
1715         MESSAGE("[BuildCommandToLaunchPaCONodeContainer] remote machine case detected !");
1716         remote_execution = true;
1717       }
1718
1719       // For each node we have a new command
1720       // Generating the command
1721       std::ostringstream command_node_stream;
1722       std::string command_node_begin("");
1723       std::string command_node_end("");
1724       std::ostringstream node_number;
1725       node_number << i;
1726       std::string container_node_name = container_name + node_number.str();
1727       LogConfiguration(log_type, "node", container_node_name, hostname, command_node_begin, command_node_end);
1728
1729       // Adding connection command
1730       // We can only have a remote execution with
1731       // a SALOME application
1732       if (remote_execution)
1733       {
1734         ASSERT(GetenvThreadSafe("NSHOST"));
1735         ASSERT(GetenvThreadSafe("NSPORT"));
1736
1737         command_node_stream << resource_definition.getAccessProtocolTypeStr();
1738         command_node_stream << " -l ";
1739         command_node_stream << resource_definition.UserName;
1740         command_node_stream << " " << hostname;
1741         command_node_stream << " " << resource_definition.AppliPath;
1742         command_node_stream << "/runRemote.sh ";
1743         command_node_stream << GetenvThreadSafeAsString("NSHOST") << " "; // hostname of CORBA name server
1744         command_node_stream << GetenvThreadSafeAsString("NSPORT") << " "; // port of CORBA name server
1745       }
1746
1747       command_node_stream << exe_name;
1748       command_node_stream << " " << container_name;
1749       command_node_stream << " " << params.parallelLib.in();
1750       command_node_stream << " " << proxy_hostname;
1751       command_node_stream << " " << node_number.str();
1752       command_node_stream << " -";
1753       AddOmninamesParams(command_node_stream);
1754
1755       command_nodes << command_node_begin << command_node_stream.str() << command_node_end;
1756       vect_machine.push_back(hostname);
1757     }
1758   }
1759
1760   else if (std::string(params.parallelLib.in()) == "Mpi")
1761   {
1762     // Choose hostname
1763     std::string hostname;
1764     std::getline(machine_file, hostname, ' ');
1765     MESSAGE("[BuildCommandToLaunchPaCONodeContainer] machine file name extracted is " << hostname);
1766
1767     // Remote execution
1768     bool remote_execution = false;
1769     if (hostname != std::string(Kernel_Utils::GetHostname()))
1770     {
1771       MESSAGE("[BuildCommandToLaunchPaCONodeContainer] remote machine case detected !");
1772       remote_execution = true;
1773     }
1774
1775     // In case of Mpi and Remote, we copy machine_file in the applipath
1776     // scp mpi_machine_file user@machine:Path
1777     std::ostringstream command_remote_stream;
1778     std::string::size_type last = machine_file_name.find_last_of("/");
1779     if (last == std::string::npos)
1780       last = -1;
1781
1782     if (resource_definition.Protocol == rsh)
1783       command_remote_stream << "rcp ";
1784     else
1785       command_remote_stream << "scp ";
1786     command_remote_stream << machine_file_name << " ";
1787     command_remote_stream << resource_definition.UserName << "@";
1788     command_remote_stream << hostname << ":" << resource_definition.AppliPath;
1789     command_remote_stream <<  "/" << machine_file_name.substr(last+1);
1790
1791     int status = SystemThreadSafe(command_remote_stream.str().c_str());
1792     if (status == -1)
1793     {
1794       INFOS("copy of the MPI machine file failed ! - sorry !");
1795       return "";
1796     }
1797
1798     // Generating the command
1799     std::string command_begin("");
1800     std::string command_end("");
1801
1802     LogConfiguration(log_type, "nodes", container_name, hostname, command_begin, command_end);
1803     command_nodes << command_begin;
1804
1805     // Adding connection command
1806     // We can only have a remote execution with
1807     // a SALOME application
1808     if (remote_execution)
1809     {
1810       ASSERT(GetenvThreadSafe("NSHOST"));
1811       ASSERT(GetenvThreadSafe("NSPORT"));
1812
1813       command_nodes << resource_definition.getAccessProtocolTypeStr();
1814       command_nodes << " -l ";
1815       command_nodes << resource_definition.UserName;
1816       command_nodes << " " << hostname;
1817       command_nodes << " " << resource_definition.AppliPath;
1818       command_nodes << "/runRemote.sh ";
1819       command_nodes << GetenvThreadSafeAsString("NSHOST") << " "; // hostname of CORBA name server
1820       command_nodes << GetenvThreadSafeAsString("NSPORT") << " "; // port of CORBA name server
1821     }
1822
1823     if (resource_definition.mpi == lam)
1824     {
1825       command_nodes << "mpiexec -ssi boot ";
1826       command_nodes << "-machinefile "  << machine_file_name << " ";
1827       command_nodes <<  "-n " << params.nb_proc;
1828     }
1829     else
1830     {
1831       command_nodes << "mpirun -np " << params.nb_proc;
1832     }
1833     command_nodes << " " << exe_name;
1834     command_nodes << " " << container_name;
1835     command_nodes << " " << params.parallelLib.in();
1836     command_nodes << " " << proxy_hostname;
1837     command_nodes << " -";
1838     AddOmninamesParams(command_nodes);
1839
1840     // We don't put hostname, because nodes are registered in the resource of the proxy
1841     for (int i= 0; i < params.nb_proc; i++)
1842       vect_machine.push_back(proxy_hostname);
1843
1844     command_nodes << command_end;
1845   }
1846   return command_nodes.str();
1847 }
1848
1849 void
1850 SALOME_ContainerManager::LogConfiguration(const std::string & log_type,
1851                                           const std::string & exe_type,
1852                                           const std::string & container_name,
1853                                           const std::string & hostname,
1854                                           std::string & begin,
1855                                           std::string & end)
1856 {
1857   if(log_type == "xterm")
1858   {
1859     begin = "xterm -e \"export LD_LIBRARY_PATH=$LD_LIBRARY_PATH; export PATH=$PATH;";
1860     end   = "\"&";
1861   }
1862   else if(log_type == "xterm_debug")
1863   {
1864     begin = "xterm -e \"export LD_LIBRARY_PATH=$LD_LIBRARY_PATH; export PATH=$PATH;";
1865     end   = "; cat \" &";
1866   }
1867   else
1868   {
1869     // default into a file...
1870     std::string logFilename = "/tmp/" + container_name + "_" + hostname + "_" + exe_type + "_";
1871     std::string user = GetenvThreadSafeAsString("USER");
1872     if (user.empty())
1873       user = GetenvThreadSafeAsString("LOGNAME");
1874     logFilename += user + ".log";
1875     end = " > " + logFilename + " 2>&1 & ";
1876   }
1877 }
1878
1879 CORBA::Object_ptr
1880 SALOME_ContainerManager::LaunchPaCOProxyContainer(const std::string& command,
1881                                                   const Engines::ContainerParameters& params,
1882                                                   const std::string & hostname)
1883 {
1884   PaCO::InterfaceManager_ptr container_proxy = PaCO::InterfaceManager::_nil();
1885
1886   MESSAGE("[LaunchPaCOProxyContainer] Launch command");
1887   int status = SystemThreadSafe(command.c_str());
1888   if (status == -1) {
1889     INFOS("[LaunchPaCOProxyContainer] failed : system command status -1");
1890     return container_proxy;
1891   }
1892   else if (status == 217) {
1893     INFOS("[LaunchPaCOProxyContainer] failed : system command status 217");
1894     return container_proxy;
1895   }
1896
1897   int count(GetTimeOutToLoaunchServer());
1898   CORBA::Object_var obj = CORBA::Object::_nil();
1899   std::string containerNameInNS = _NS->BuildContainerNameForNS(params.container_name.in(),
1900                                                                hostname.c_str());
1901   MESSAGE("[LaunchParallelContainer]  Waiting for Parallel Container proxy : " << containerNameInNS);
1902
1903   while (CORBA::is_nil(obj) && count)
1904   {
1905     sleep(1);
1906     count--;
1907     obj = _NS->Resolve(containerNameInNS.c_str());
1908   }
1909
1910   try
1911   {
1912     container_proxy = PaCO::InterfaceManager::_narrow(obj);
1913   }
1914   catch(CORBA::SystemException& e)
1915   {
1916     INFOS("[StarPaCOPPContainer] Exception in _narrow after LaunchParallelContainer for proxy !");
1917     INFOS("CORBA::SystemException : " << e);
1918     return container_proxy;
1919   }
1920   catch(CORBA::Exception& e)
1921   {
1922     INFOS("[StarPaCOPPContainer] Exception in _narrow after LaunchParallelContainer for proxy !");
1923     INFOS("CORBA::Exception" << e);
1924     return container_proxy;
1925   }
1926   catch(...)
1927   {
1928     INFOS("[StarPaCOPPContainer] Exception in _narrow after LaunchParallelContainer for proxy !");
1929     INFOS("Unknown exception !");
1930     return container_proxy;
1931   }
1932   if (CORBA::is_nil(container_proxy))
1933   {
1934     INFOS("[StarPaCOPPContainer] PaCO::InterfaceManager::_narrow returns NIL !");
1935     return container_proxy;
1936   }
1937   return obj._retn();
1938 }
1939
1940 //=============================================================================
1941 /*! This method launches the parallel container.
1942  *  It will may be placed on the ressources manager.
1943  *
1944  * \param command to launch
1945  * \param container's parameters
1946  * \param name of the container
1947  *
1948  * \return CORBA container reference
1949  */
1950 //=============================================================================
1951 bool
1952 SALOME_ContainerManager::LaunchPaCONodeContainer(const std::string& command,
1953                                                  const Engines::ContainerParameters& params,
1954                                                  const std::string& name,
1955                                                  SALOME_ContainerManager::actual_launch_machine_t & vect_machine)
1956 {
1957   INFOS("[LaunchPaCONodeContainer] Launch command");
1958   int status = SystemThreadSafe(command.c_str());
1959   if (status == -1) {
1960     INFOS("[LaunchPaCONodeContainer] failed : system command status -1");
1961     return false;
1962   }
1963   else if (status == 217) {
1964     INFOS("[LaunchPaCONodeContainer] failed : system command status 217");
1965     return false;
1966   }
1967
1968   INFOS("[LaunchPaCONodeContainer] Waiting for the nodes of the parallel container");
1969   // We are waiting all the nodes
1970   for (int i = 0; i < params.nb_proc; i++)
1971   {
1972     CORBA::Object_var obj = CORBA::Object::_nil();
1973     std::string theMachine(vect_machine[i]);
1974     // Name of the node
1975     std::ostringstream tmp;
1976     tmp << i;
1977     std::string proc_number = tmp.str();
1978     std::string container_node_name = name + proc_number;
1979     std::string containerNameInNS = _NS->BuildContainerNameForNS((char*) container_node_name.c_str(), theMachine.c_str());
1980     INFOS("[LaunchPaCONodeContainer]  Waiting for Parallel Container node " << containerNameInNS << " on " << theMachine);
1981     int count(GetTimeOutToLoaunchServer());
1982     while (CORBA::is_nil(obj) && count) {
1983       SleepInSecond(1);
1984       count-- ;
1985       obj = _NS->Resolve(containerNameInNS.c_str());
1986     }
1987     if (CORBA::is_nil(obj))
1988     {
1989       INFOS("[LaunchPaCONodeContainer] Launch of node failed (or not found) !");
1990       return false;
1991     }
1992   }
1993   return true;
1994 }
1995
1996 #else
1997
1998 Engines::Container_ptr
1999 SALOME_ContainerManager::StartPaCOPPContainer(const Engines::ContainerParameters& params,
2000                                               std::string resource_selected)
2001 {
2002   Engines::Container_ptr ret = Engines::Container::_nil();
2003   INFOS("[StarPaCOPPContainer] is disabled !");
2004   INFOS("[StarPaCOPPContainer] recompile SALOME Kernel to enable PaCO++ parallel extension");
2005   return ret;
2006 }
2007
2008 std::string
2009 SALOME_ContainerManager::BuildCommandToLaunchPaCOProxyContainer(const Engines::ContainerParameters& params,
2010                                                                 std::string machine_file_name,
2011                                                                 std::string & proxy_hostname)
2012 {
2013   return "";
2014 }
2015
2016 std::string
2017 SALOME_ContainerManager::BuildCommandToLaunchPaCONodeContainer(const Engines::ContainerParameters& params,
2018                                                                const std::string & machine_file_name,
2019                                                                SALOME_ContainerManager::actual_launch_machine_t & vect_machine,
2020                                                                const std::string & proxy_hostname)
2021 {
2022   return "";
2023 }
2024 void
2025 SALOME_ContainerManager::LogConfiguration(const std::string & log_type,
2026                                           const std::string & exe_type,
2027                                           const std::string & container_name,
2028                                           const std::string & hostname,
2029                                           std::string & begin,
2030                                           std::string & end)
2031 {
2032 }
2033
2034 CORBA::Object_ptr
2035 SALOME_ContainerManager::LaunchPaCOProxyContainer(const std::string& command,
2036                                                   const Engines::ContainerParameters& params,
2037                                                   const std::string& hostname)
2038 {
2039   CORBA::Object_ptr ret = CORBA::Object::_nil();
2040   return ret;
2041 }
2042
2043 bool
2044 SALOME_ContainerManager::LaunchPaCONodeContainer(const std::string& command,
2045                         const Engines::ContainerParameters& params,
2046                         const std::string& name,
2047                         SALOME_ContainerManager::actual_launch_machine_t & vect_machine)
2048 {
2049   return false;
2050 }
2051 #endif
2052