]> SALOME platform Git repositories - modules/kernel.git/blob - src/Launcher/SALOME_Launcher.cxx
Salome HOME
updated copyright message
[modules/kernel.git] / src / Launcher / SALOME_Launcher.cxx
1 // Copyright (C) 2007-2023  CEA, EDF, 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_Launcher.hxx"
24 #include "BatchTest.hxx"
25 #include "OpUtil.hxx"
26 #include "SALOME_ContainerManager.hxx"
27 #include "SALOME_NamingService.hxx"
28 #include "SALOME_ResourcesManager.hxx"
29 #include "Utils_CorbaException.hxx"
30
31
32 #include "Launcher_Job_Command.hxx"
33 #include "Launcher_Job_YACSFile.hxx"
34 #include "Launcher_Job_PythonSALOME.hxx"
35 #include "Launcher_Job_CommandSALOME.hxx"
36
37 #include "utilities.h"
38
39 #ifdef WIN32
40 # include <process.h>
41 #else
42 # include <unistd.h>
43 #endif
44 #include <sys/types.h>
45 #include <vector>
46 #include <list>
47
48 #include <stdio.h>
49 #include <sstream>
50
51 using namespace std;
52
53 const char *SALOME_Launcher::_LauncherNameInNS = "/SalomeLauncher";
54
55 //=============================================================================
56 /*!
57  *  Constructor
58  *  \param orb
59  */
60 //=============================================================================
61 SALOME_Launcher::SALOME_Launcher(CORBA::ORB_ptr orb, PortableServer::POA_var poa)
62 {
63   MESSAGE("SALOME_Launcher constructor");
64   _NS = new SALOME_NamingService(orb);
65   init(orb,poa);
66   MESSAGE("SALOME_Launcher constructor end");
67 }
68
69 SALOME_Launcher::SALOME_Launcher(CORBA::ORB_ptr orb, PortableServer::POA_var poa, SALOME_NamingService_Abstract *externalNS):_NS(externalNS)
70 {
71   init(orb,poa);
72 }
73
74 void SALOME_Launcher::init(CORBA::ORB_ptr orb, PortableServer::POA_var poa)
75 {
76   _ResManager = new SALOME_ResourcesManager(orb,poa,_NS);
77   _l.SetResourcesManager(_ResManager->GetImpl());
78   _ContManager = new SALOME_ContainerManager(orb,poa,_NS);
79   _ResManager->_remove_ref();
80   _ContManager->_remove_ref();
81
82   _orb = CORBA::ORB::_duplicate(orb) ;
83   _poa = PortableServer::POA::_duplicate(poa) ;
84   PortableServer::ObjectId_var id = _poa->activate_object(this);
85   CORBA::Object_var obj = _poa->id_to_reference(id);
86   Engines::SalomeLauncher_var refContMan = Engines::SalomeLauncher::_narrow(obj);
87   _NS->Register(refContMan,_LauncherNameInNS);
88 }
89
90 //=============================================================================
91 /*!
92  * destructor
93  */
94 //=============================================================================
95 SALOME_Launcher::~SALOME_Launcher()
96 {
97   MESSAGE("SALOME_Launcher destructor");
98   delete _NS;
99   MESSAGE("SALOME_Launcher destructor end");
100 }
101
102
103 CORBA::Long
104 SALOME_Launcher::createJob(const Engines::JobParameters & job_parameters)
105 {
106   JobParameters_cpp cpp_parameters = JobParameters_CORBA2CPP(job_parameters);
107   CORBA::Long jobNumber = -1;
108   try
109   {
110     jobNumber = _l.createJob(cpp_parameters);
111     std::ostringstream job_id;
112     job_id << jobNumber;
113     notifyObservers("NEW_JOB", job_id.str());
114   }
115   catch(const LauncherException &ex)
116   {
117     INFOS(ex.msg.c_str());
118     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::BAD_PARAM);
119   }
120   return jobNumber;
121 }
122
123 void
124 SALOME_Launcher::launchJob(CORBA::Long job_id)
125 {
126   try
127   {
128     _l.launchJob(job_id);
129   }
130   catch(const LauncherException &ex)
131   {
132     INFOS(ex.msg.c_str());
133     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::BAD_PARAM);
134   }
135 }
136
137 char *
138 SALOME_Launcher::getJobState(CORBA::Long job_id)
139 {
140   std::string result;
141   try
142   {
143     result = _l.getJobState(job_id);
144   }
145   catch(const LauncherException &ex)
146   {
147     INFOS(ex.msg.c_str());
148     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::BAD_PARAM);
149   }
150   return CORBA::string_dup(result.c_str());
151 }
152
153 // Get names or ids of hosts assigned to the job
154 char *
155 SALOME_Launcher::getAssignedHostnames(CORBA::Long job_id)
156 {
157   std::string result;
158   try
159   {
160     result = _l.getAssignedHostnames(job_id);
161   }
162   catch(const LauncherException &ex)
163   {
164     INFOS(ex.msg.c_str());
165     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::BAD_PARAM);
166   }
167   return CORBA::string_dup(result.c_str());
168 }
169
170 void
171 SALOME_Launcher::exportInputFiles(CORBA::Long job_id)
172 {
173   try
174   {
175     _l.exportInputFiles(job_id);
176   }
177   catch(const LauncherException &ex)
178   {
179     INFOS(ex.msg.c_str());
180     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::BAD_PARAM);
181   }
182 }
183
184 void
185 SALOME_Launcher::getJobResults(CORBA::Long job_id, const char * directory)
186 {
187   try
188   {
189     _l.getJobResults(job_id, directory);
190   }
191   catch(const LauncherException &ex)
192   {
193     INFOS(ex.msg.c_str());
194     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::BAD_PARAM);
195   }
196 }
197
198 void
199 SALOME_Launcher::clearJobWorkingDir(CORBA::Long job_id)
200 {
201   try
202   {
203     _l.clearJobWorkingDir(job_id);
204   }
205   catch(const LauncherException &ex)
206   {
207     INFOS(ex.msg.c_str());
208     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::BAD_PARAM);
209   }
210 }
211
212 CORBA::Boolean
213 SALOME_Launcher::getJobDumpState(CORBA::Long job_id, const char * directory)
214 {
215   CORBA::Boolean rtn = false;
216   try
217   {
218     rtn = _l.getJobDumpState(job_id, directory);
219   }
220   catch(const LauncherException &ex)
221   {
222     INFOS(ex.msg.c_str());
223     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::BAD_PARAM);
224   }
225   return rtn;
226 }
227
228 CORBA::Boolean
229 SALOME_Launcher::getJobWorkFile(CORBA::Long job_id, const char * work_file, const char * directory)
230 {
231   CORBA::Boolean rtn = false;
232   try
233   {
234     rtn = _l.getJobWorkFile(job_id, work_file, directory);
235   }
236   catch(const LauncherException &ex)
237   {
238     INFOS(ex.msg.c_str());
239     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::BAD_PARAM);
240   }
241   return rtn;
242 }
243
244 void SALOME_Launcher::DeclareUsingSalomeSession()
245 {
246   this->_ContManager->DeclareUsingSalomeSession();
247 }
248
249 void
250 SALOME_Launcher::removeJob(CORBA::Long job_id)
251 {
252   try
253   {
254     _l.removeJob(job_id);
255     std::ostringstream job_id_str;
256     job_id_str << job_id;
257     notifyObservers("REMOVE_JOB", job_id_str.str());
258   }
259   catch(const LauncherException &ex)
260   {
261     INFOS(ex.msg.c_str());
262     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::BAD_PARAM);
263   }
264 }
265
266 void
267 SALOME_Launcher::stopJob(CORBA::Long job_id)
268 {
269   try
270   {
271     _l.stopJob(job_id);
272     std::ostringstream job_id_str;
273     job_id_str << job_id;
274     notifyObservers("UPDATE_JOB_STATE", job_id_str.str());
275   }
276   catch(const LauncherException &ex)
277   {
278     INFOS(ex.msg.c_str());
279     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::BAD_PARAM);
280   }
281 }
282
283 char *
284 SALOME_Launcher::dumpJob(CORBA::Long job_id)
285 {
286   std::string result;
287   try
288   {
289     result = _l.dumpJob(job_id);
290   }
291   catch(const LauncherException &ex)
292   {
293     INFOS(ex.msg.c_str());
294     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::BAD_PARAM);
295   }
296   return CORBA::string_dup(result.c_str());
297 }
298
299 CORBA::Long
300 SALOME_Launcher::restoreJob(const char * dumpedJob)
301 {
302   CORBA::Long jobId;
303   try{
304     jobId = _l.restoreJob(dumpedJob);
305     if(jobId >= 0)
306     {
307       std::ostringstream job_str;
308       job_str << jobId;
309       notifyObservers("NEW_JOB", job_str.str());
310     }
311   }
312   catch(const LauncherException &ex){
313     INFOS(ex.msg.c_str());
314     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::INTERNAL_ERROR);
315   }
316
317   return jobId;
318 }
319
320 //=============================================================================
321 /*! CORBA Method:
322  *  Create a job in the launcher with a file
323  *  \param xmlExecuteFile     : .xml to parse that contains job description
324  *  \param clusterName        : machine chosen
325  */
326 //=============================================================================
327 CORBA::Long
328 SALOME_Launcher::createJobWithFile(const char * xmlExecuteFile,
329                                    const char * clusterName)
330 {
331   CORBA::Long jobId;
332   try{
333     jobId = _l.createJobWithFile(xmlExecuteFile, clusterName);
334   }
335   catch(const LauncherException &ex){
336     INFOS(ex.msg.c_str());
337     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::INTERNAL_ERROR);
338   }
339
340   return jobId;
341 }
342
343 //=============================================================================
344 /*! CORBA Method:
345  *  the test batch configuration
346  *  \param params             : The batch cluster
347  */
348 //=============================================================================
349 CORBA::Boolean
350 SALOME_Launcher::testBatch(const Engines::ResourceParameters& params)
351 {
352   MESSAGE("BEGIN OF SALOME_Launcher::testBatch");
353   CORBA::Boolean rtn = false;
354   try
355   {
356     // Consider only resources that can run batch jobs
357     Engines::ResourceParameters new_params(params);
358     new_params.can_launch_batch_jobs = true;
359
360     // find a resource matching the required parameters
361     Engines::ResourceList *aMachineList = _ResManager->GetFittingResources(new_params);
362     if (aMachineList->length() == 0)
363       throw SALOME_Exception("No resources have been found with your parameters");
364
365     const Engines::ResourceDefinition* p = _ResManager->GetResourceDefinition((*aMachineList)[0]);
366         std::string resource_name(p->name);
367     INFOS("Choose resource for test: " <<  resource_name);
368
369     BatchTest t(*p);
370     if (t.test())
371     {
372       rtn = true;
373     }
374   }
375   catch(const LauncherException &ex){
376     INFOS(ex.msg.c_str());
377     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::INTERNAL_ERROR);
378   }
379   return rtn;
380 }
381
382 //=============================================================================
383 /*! CORBA method:
384  *  shutdown all the containers, then the ContainerManager servant
385  */
386 //=============================================================================
387 void SALOME_Launcher::Shutdown()
388 {
389   MESSAGE("Shutdown");
390   if(!_NS)
391     return;
392   _NS->Destroy_Name(_LauncherNameInNS);
393   _ContManager->Shutdown();
394   _ResManager->Shutdown();
395   PortableServer::ObjectId_var oid = _poa->servant_to_id(this);
396   _poa->deactivate_object(oid);
397   if(!CORBA::is_nil(_orb))
398     _orb->shutdown(0);
399 }
400
401 //=============================================================================
402 /*! CORBA Method:
403  *  Returns the PID of the process
404  */
405 //=============================================================================
406 CORBA::Long SALOME_Launcher::getPID()
407 {
408   return
409 #ifndef WIN32
410     (CORBA::Long)getpid();
411 #else
412     (CORBA::Long)_getpid();
413 #endif
414 }
415
416 //=============================================================================
417 /*! CORBA Method:
418  *  Returns current launcher jobs list
419  */
420 //=============================================================================
421 Engines::JobsList *
422 SALOME_Launcher::getJobsList()
423 {
424   Engines::JobsList_var jobs_list = new Engines::JobsList();
425   std::map<int, Launcher::Job *> cpp_jobs = _l.getJobs();
426   std::map<int, Launcher::Job *>::const_iterator it_job;
427   int list_id = 0;
428   for(it_job = cpp_jobs.begin(); it_job != cpp_jobs.end(); it_job++)
429   {
430     int number          = it_job->first;
431     try
432     {
433       // Prepare CORBA job description
434       Engines::JobDescription_var job_descr = new Engines::JobDescription();
435       Engines::JobParameters_var job_parameters = getJobParameters(number);
436       job_descr->job_id = number;
437       job_descr->job_parameters = job_parameters;
438
439       // Add job description to the sequence
440       jobs_list->length(list_id + 1);
441       jobs_list[list_id] = job_descr;
442       list_id++;
443     }
444     catch (...) {}
445   }
446   return jobs_list._retn();
447 }
448
449 //=============================================================================
450 /*! CORBA Method:
451  * Returns the job description
452  */
453 //=============================================================================
454 Engines::JobParameters *
455 SALOME_Launcher::getJobParameters(CORBA::Long job_id)
456 {
457   Engines::JobParameters_var job_parameters;
458   try
459   {
460     JobParameters_cpp cpp_parameters = _l.getJobParameters(job_id);
461     job_parameters = JobParameters_CPP2CORBA(cpp_parameters);
462   }
463   catch(const LauncherException &ex)
464   {
465     INFOS(ex.msg.c_str());
466     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::BAD_PARAM);
467   }
468
469   return job_parameters._retn();
470 }
471
472 //=============================================================================
473 /*! CORBA Method:
474  *  Loads jobs saved in jobs_file
475  */
476 //=============================================================================
477 void
478 SALOME_Launcher::loadJobs(const char* jobs_file)
479 {
480   list<int> new_jobs_id_list;
481   try
482   {
483     // Load the jobs in Launcher
484     new_jobs_id_list = _l.loadJobs(jobs_file);
485   }
486   catch (const LauncherException & ex)
487   {
488     INFOS(ex.msg.c_str());
489     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(), SALOME::INTERNAL_ERROR);
490   }
491
492   // Notify observers of the new jobs
493   list<int>::const_iterator it_jobs_id;
494   for (it_jobs_id = new_jobs_id_list.begin(); it_jobs_id != new_jobs_id_list.end(); it_jobs_id++)
495   {
496     ostringstream job_id_sstr;
497     job_id_sstr << *it_jobs_id;
498     notifyObservers("NEW_JOB", job_id_sstr.str());
499   }
500   notifyObservers("LOAD_JOBS", jobs_file);
501 }
502
503 //=============================================================================
504 /*! CORBA Method:
505  *  Save jobs of Launcher (in any steps) in file jobs_file
506  */
507 //=============================================================================
508 void
509 SALOME_Launcher::saveJobs(const char* jobs_file)
510 {
511   _l.saveJobs(jobs_file);
512   notifyObservers("SAVE_JOBS", jobs_file);
513 }
514
515 //=============================================================================
516 /*! CORBA Method:
517  *  Add a new observer to the launcher
518  */
519 //=============================================================================
520 void
521 SALOME_Launcher::addObserver(Engines::SalomeLauncherObserver_ptr observer)
522 {
523   bool new_observer = true;
524   std::list<Engines::SalomeLauncherObserver_var>::iterator iter = _observers.begin();
525   while(iter != _observers.end())
526   {
527     if (std::string(_orb->object_to_string(*iter)) ==
528         std::string(_orb->object_to_string(observer)))
529     {
530       new_observer = false;
531       break;
532     }
533     iter++;
534   }
535   if (new_observer)
536     _observers.push_back(Engines::SalomeLauncherObserver::_duplicate(observer));
537
538   // We notify the new observer with all jobs that are currently in the Launcher
539   std::map<int, Launcher::Job *> cpp_jobs = _l.getJobs();
540   std::map<int, Launcher::Job *>::const_iterator it_job;
541   for(it_job = cpp_jobs.begin(); it_job != cpp_jobs.end(); it_job++)
542   {
543     int number = it_job->first;
544     std::ostringstream job_id;
545     job_id << number;
546     try
547     {
548       observer->notify("NEW_JOB", job_id.str().c_str());
549     }
550     catch (...)
551     {
552        MESSAGE("Notify Observer, exception catch");
553     }
554
555   }
556 }
557
558 //=============================================================================
559 /*! CORBA Method:
560  *  Add a new observer to the launcher
561  */
562 //=============================================================================
563 void
564 SALOME_Launcher::removeObserver(Engines::SalomeLauncherObserver_ptr observer)
565 {
566   std::list<Engines::SalomeLauncherObserver_var>::iterator iter = _observers.begin();
567   while(iter != _observers.end())
568   {
569     if (std::string(_orb->object_to_string(*iter)) ==
570         std::string(_orb->object_to_string(observer)))
571     {
572       // Observer found
573       iter =_observers.erase(iter++);
574     }
575     else
576     {
577       iter++;
578     }
579   }
580 }
581
582 //=============================================================================
583 /*! Internal Method:
584  *  Notify observers on a new event
585  */
586 //=============================================================================
587 void
588 SALOME_Launcher::notifyObservers(const std::string & event_name,
589                                  const std::string & event_data)
590 {
591   std::list<Engines::SalomeLauncherObserver_var>::iterator iter = _observers.begin();
592   while(iter != _observers.end())
593   {
594     try
595     {
596       (*iter)->notify(CORBA::string_dup(event_name.c_str()),
597                       CORBA::string_dup(event_data.c_str()));
598     }
599     catch (...)
600     {
601        MESSAGE("Notify Observer, exception catch");
602     }
603     iter++;
604   }
605
606 }
607
608 JobParameters_cpp
609 SALOME_Launcher::JobParameters_CORBA2CPP(
610                                    const Engines::JobParameters& job_parameters)
611 {
612   JobParameters_cpp result;
613
614   result.job_name = job_parameters.job_name.in();
615   result.job_type = job_parameters.job_type.in();
616   result.job_file = job_parameters.job_file.in();
617   result.pre_command = job_parameters.pre_command.in();
618   result.env_file = job_parameters.env_file.in();
619
620   result.in_files.clear();
621   for (CORBA::ULong i = 0; i < job_parameters.in_files.length(); i++)
622     result.in_files.push_back(job_parameters.in_files[i].in());
623   result.out_files.clear();
624   for (CORBA::ULong i = 0; i < job_parameters.out_files.length(); i++)
625     result.out_files.push_back(job_parameters.out_files[i].in());
626
627   result.work_directory = job_parameters.work_directory.in();
628   result.local_directory = job_parameters.local_directory.in();
629   result.result_directory = job_parameters.result_directory.in();
630   result.maximum_duration = job_parameters.maximum_duration.in();
631
632   result.resource_required = resourceParameters_CORBAtoCPP(job_parameters.resource_required);
633
634   result.queue = job_parameters.queue.in();
635   result.partition = job_parameters.partition.in();
636   result.exclusive = job_parameters.exclusive;
637   result.mem_per_cpu = job_parameters.mem_per_cpu;
638   result.wckey = job_parameters.wckey.in();
639   result.extra_params = job_parameters.extra_params.in();
640
641   result.specific_parameters.clear();
642   for (CORBA::ULong i = 0; i < job_parameters.specific_parameters.length(); i++)
643     result.specific_parameters[job_parameters.specific_parameters[i].name.in()]
644                              = job_parameters.specific_parameters[i].value.in();
645
646   result.launcher_file = job_parameters.launcher_file.in();
647   result.launcher_args = job_parameters.launcher_args.in();
648   return result;
649 }
650
651 Engines::JobParameters_var
652 SALOME_Launcher::JobParameters_CPP2CORBA(const JobParameters_cpp& job_parameters)
653 {
654   Engines::JobParameters_var result = new Engines::JobParameters;
655   result->job_name = CORBA::string_dup(job_parameters.job_name.c_str());
656   result->job_type = CORBA::string_dup(job_parameters.job_type.c_str());
657   result->job_file = CORBA::string_dup(job_parameters.job_file.c_str());
658   result->pre_command = CORBA::string_dup(job_parameters.pre_command.c_str());
659   result->env_file = CORBA::string_dup(job_parameters.env_file.c_str());
660   result->in_files.length((CORBA::ULong)job_parameters.in_files.size()); //!< TODO: conversion from size_t to CORBA::ULong
661
662   int i = 0;
663   for(const std::string& it : job_parameters.in_files)
664   {
665     result->in_files[i] = CORBA::string_dup(it.c_str());
666     i++;
667   }
668   result->out_files.length((CORBA::ULong)job_parameters.out_files.size()); //!< TODO: conversion from size_t to CORBA::ULong
669   i = 0;
670   for(const std::string& it : job_parameters.out_files)
671   {
672     result->out_files[i] = CORBA::string_dup(it.c_str());
673     i++;
674   }
675
676   result->work_directory = CORBA::string_dup(job_parameters.work_directory.c_str());
677   result->local_directory = CORBA::string_dup(job_parameters.local_directory.c_str());
678   result->result_directory = CORBA::string_dup(job_parameters.result_directory.c_str());
679   result->maximum_duration = CORBA::string_dup(job_parameters.maximum_duration.c_str());
680
681   result->resource_required = resourceParameters_CPPtoCORBA(job_parameters.resource_required);
682
683   result->queue = CORBA::string_dup(job_parameters.queue.c_str());
684   result->partition = CORBA::string_dup(job_parameters.partition.c_str());
685   result->exclusive = job_parameters.exclusive;
686   result->mem_per_cpu = job_parameters.mem_per_cpu;
687   result->wckey = CORBA::string_dup(job_parameters.wckey.c_str());
688   result->extra_params = CORBA::string_dup(job_parameters.extra_params.c_str());
689
690   const std::map<std::string, std::string>& specific_parameters
691                                        = job_parameters.specific_parameters;
692   if (!specific_parameters.empty())
693   {
694     result->specific_parameters.length((CORBA::ULong)specific_parameters.size()); //!< TODO: conversion from size_t to CORBA::ULong
695     CORBA::ULong i = 0;
696     for (const auto& it_specific : specific_parameters)
697     {
698       Engines::Parameter_var new_param = new Engines::Parameter;
699       new_param->name  = CORBA::string_dup(it_specific.first.c_str());
700       new_param->value = CORBA::string_dup(it_specific.second.c_str());
701       result->specific_parameters[i] = new_param;
702       i++;
703     }
704   }
705
706   result->launcher_file = CORBA::string_dup(job_parameters.launcher_file.c_str());
707   result->launcher_args = CORBA::string_dup(job_parameters.launcher_args.c_str());
708   return result;
709 }
710
711 static SALOME_Launcher *_launcher_singleton_ssl = nullptr;
712
713 #include "SALOME_Fake_NamingService.hxx"
714
715 SALOME_Launcher *KERNEL::getLauncherSA()
716 {
717   if(!_launcher_singleton_ssl)
718   {
719     CORBA::ORB_var orb = KERNEL::GetRefToORB();
720     //[EDF26673] : do not release the POA object returned by _the_root_poa.
721     PortableServer::POA_ptr root_poa = PortableServer::POA::_the_root_poa();
722     PortableServer::POAManager_var pman = root_poa->the_POAManager();
723     CORBA::PolicyList policies;
724     policies.length(1);
725     PortableServer::ThreadPolicy_var threadPol(root_poa->create_thread_policy(PortableServer::SINGLE_THREAD_MODEL));
726     policies[0] = PortableServer::ThreadPolicy::_duplicate(threadPol);
727     PortableServer::POA_var safePOA = root_poa->create_POA("SingleThreadPOA",
728                                                            pman,
729                                                            policies);
730     threadPol->destroy();
731     SALOME_Fake_NamingService *ns=new SALOME_Fake_NamingService(orb);
732     _launcher_singleton_ssl = new SALOME_Launcher(orb,safePOA,ns);//3rd arg is important to skip NS !
733   }
734   return _launcher_singleton_ssl;
735 }