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