src/Container/SALOME_ContainerManager.cxx

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