X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FLauncher%2FSALOME_Launcher.cxx;h=6001ca9444171cdc6844bacdbc09fe3f917da983;hb=4d61f5b8863253a259cde301c39b60909a6b18fa;hp=1bb31a2661839e7dcc5b659e4240ad65417c1878;hpb=703cf8ca778de35a6b463d4b4fca7c36697d717f;p=modules%2Fkernel.git

diff --git a/src/Launcher/SALOME_Launcher.cxx b/src/Launcher/SALOME_Launcher.cxx
index 1bb31a266..6001ca944 100644
--- a/src/Launcher/SALOME_Launcher.cxx
+++ b/src/Launcher/SALOME_Launcher.cxx
@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2015  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
@@ -32,6 +32,7 @@
 #include "Launcher_Job_Command.hxx"
 #include "Launcher_Job_YACSFile.hxx"
 #include "Launcher_Job_PythonSALOME.hxx"
+#include "Launcher_Job_CommandSALOME.hxx"
 
 #include "utilities.h"
 
@@ -52,18 +53,29 @@ using namespace std;
 const char *SALOME_Launcher::_LauncherNameInNS = "/SalomeLauncher";
 
 //=============================================================================
-/*! 
+/*!
  *  Constructor
  *  \param orb
  */
 //=============================================================================
-SALOME_Launcher::SALOME_Launcher(CORBA::ORB_ptr orb, PortableServer::POA_var poa) : _l()
+SALOME_Launcher::SALOME_Launcher(CORBA::ORB_ptr orb, PortableServer::POA_var poa)
 {
   MESSAGE("SALOME_Launcher constructor");
   _NS = new SALOME_NamingService(orb);
-  _ResManager = new SALOME_ResourcesManager(orb,poa,_NS);
+  init(orb,poa);
+  MESSAGE("SALOME_Launcher constructor end");
+}
+
+SALOME_Launcher::SALOME_Launcher(CORBA::ORB_ptr orb, PortableServer::POA_var poa, SALOME_NamingService_Abstract *externalNS):_NS(externalNS)
+{
+  init(orb,poa);
+}
+
+void SALOME_Launcher::init(CORBA::ORB_ptr orb, PortableServer::POA_var poa)
+{
+  _ResManager = new SALOME_ResourcesManager(orb,poa,tradNS());
   _l.SetResourcesManager(_ResManager->GetImpl());
-  _ContManager = new SALOME_ContainerManager(orb,poa,_NS);
+  _ContManager = new SALOME_ContainerManager(orb,poa,tradNS());
   _ResManager->_remove_ref();
   _ContManager->_remove_ref();
 
@@ -72,13 +84,11 @@ SALOME_Launcher::SALOME_Launcher(CORBA::ORB_ptr orb, PortableServer::POA_var poa
   PortableServer::ObjectId_var id = _poa->activate_object(this);
   CORBA::Object_var obj = _poa->id_to_reference(id);
   Engines::SalomeLauncher_var refContMan = Engines::SalomeLauncher::_narrow(obj);
-
   _NS->Register(refContMan,_LauncherNameInNS);
-  MESSAGE("SALOME_Launcher constructor end");
 }
 
 //=============================================================================
-/*! 
+/*!
  * destructor
  */
 //=============================================================================
@@ -90,147 +100,79 @@ SALOME_Launcher::~SALOME_Launcher()
 }
 
 
-CORBA::Long 
+CORBA::Long
 SALOME_Launcher::createJob(const Engines::JobParameters & job_parameters)
 {
-  std::string job_type = job_parameters.job_type.in();
-
-  if (job_type != "command" && job_type != "yacs_file" && job_type != "python_salome")
-  {
-    std::string message("SALOME_Launcher::createJob: bad job type: ");
-    message += job_type;
-    THROW_SALOME_CORBA_EXCEPTION(message.c_str(), SALOME::INTERNAL_ERROR);
-  }
-
-  Launcher::Job * new_job; // It is Launcher_cpp that is going to destroy it
-
-  if (job_type == "command")
-    new_job = new Launcher::Job_Command();
-  else if (job_type == "yacs_file")
-    new_job = new Launcher::Job_YACSFile();
-  else if (job_type == "python_salome")
-    new_job = new Launcher::Job_PythonSALOME();
-
-  // Name
-  new_job->setJobName(job_parameters.job_name.in());
-
-  // Directories
-  std::string work_directory = job_parameters.work_directory.in();
-  std::string local_directory = job_parameters.local_directory.in();
-  std::string result_directory = job_parameters.result_directory.in();
-  new_job->setWorkDirectory(work_directory);
-  new_job->setLocalDirectory(local_directory);
-  new_job->setResultDirectory(result_directory);
-
-  // Parameters for COORM
-  std::string launcher_file = job_parameters.launcher_file.in();
-  std::string launcher_args = job_parameters.launcher_args.in();
-  new_job->setLauncherFile(launcher_file);
-  new_job->setLauncherArgs(launcher_args);
-
-  // Job File
-  std::string job_file = job_parameters.job_file.in();
+  JobParameters_cpp cpp_parameters = JobParameters_CORBA2CPP(job_parameters);
+  CORBA::Long jobNumber = -1;
   try
   {
-    new_job->setJobFile(job_file);
+    jobNumber = _l.createJob(cpp_parameters);
+    std::ostringstream job_id;
+    job_id << jobNumber;
+    notifyObservers("NEW_JOB", job_id.str());
   }
   catch(const LauncherException &ex)
   {
     INFOS(ex.msg.c_str());
-    THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::INTERNAL_ERROR);
+    THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::BAD_PARAM);
   }
+  return jobNumber;
+}
 
-  // Files
-  std::string env_file = job_parameters.env_file.in();
-  new_job->setEnvFile(env_file);
-  for (CORBA::ULong i = 0; i < job_parameters.in_files.length(); i++)
-    new_job->add_in_file(job_parameters.in_files[i].in());
-  for (CORBA::ULong i = 0; i < job_parameters.out_files.length(); i++)
-    new_job->add_out_file(job_parameters.out_files[i].in());
-
-  // Expected During Time
+void
+SALOME_Launcher::launchJob(CORBA::Long job_id)
+{
   try
   {
-    std::string maximum_duration = job_parameters.maximum_duration.in();
-    new_job->setMaximumDuration(maximum_duration);
-  }
-  catch(const LauncherException &ex){
-    INFOS(ex.msg.c_str());
-    THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::INTERNAL_ERROR);
+    _l.launchJob(job_id);
   }
-
-  // Queue
-  std::string queue = job_parameters.queue.in();
-  new_job->setQueue(queue);
-
-  // Exclusive
-  new_job->setExclusive(job_parameters.exclusive);
-
-  // Memory required per CPU
-  new_job->setMemPerCpu(job_parameters.mem_per_cpu);
-
-  // WC Key
-  std::string wckey = job_parameters.wckey.in();
-  new_job->setWCKey(wckey);
-
-  // Extra params
-  std::string extra_params = job_parameters.extra_params.in();
-  new_job->setExtraParams(extra_params);
-
-  // Resources requirements
-  try
+  catch(const LauncherException &ex)
   {
-    resourceParams p;
-    p.name = job_parameters.resource_required.name;
-    p.hostname = job_parameters.resource_required.hostname;
-    p.OS = job_parameters.resource_required.OS;
-    p.nb_proc = job_parameters.resource_required.nb_proc;
-    p.nb_node = job_parameters.resource_required.nb_node;
-    p.nb_proc_per_node = job_parameters.resource_required.nb_proc_per_node;
-    p.cpu_clock = job_parameters.resource_required.cpu_clock;
-    p.mem_mb = job_parameters.resource_required.mem_mb;
-    new_job->setResourceRequiredParams(p);
-  }
-  catch(const LauncherException &ex){
     INFOS(ex.msg.c_str());
-    THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::INTERNAL_ERROR);
+    THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::BAD_PARAM);
   }
+}
 
-  // Adding specific parameters to the job
-  for (CORBA::ULong i = 0; i < job_parameters.specific_parameters.length(); i++)
-    new_job->addSpecificParameter(job_parameters.specific_parameters[i].name.in(),
-                                  job_parameters.specific_parameters[i].value.in());
+char *
+SALOME_Launcher::getJobState(CORBA::Long job_id)
+{
+  std::string result;
   try
   {
-    new_job->checkSpecificParameters();
+    result = _l.getJobState(job_id);
   }
   catch(const LauncherException &ex)
   {
     INFOS(ex.msg.c_str());
-    THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::INTERNAL_ERROR);
+    THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::BAD_PARAM);
   }
+  return CORBA::string_dup(result.c_str());
+}
 
+// Get names or ids of hosts assigned to the job
+char *
+SALOME_Launcher::getAssignedHostnames(CORBA::Long job_id)
+{
+  std::string result;
   try
   {
-    _l.createJob(new_job);
-    std::ostringstream job_id;
-    job_id << new_job->getNumber();
-    notifyObservers("NEW_JOB", job_id.str());
+    result = _l.getAssignedHostnames(job_id);
   }
   catch(const LauncherException &ex)
   {
     INFOS(ex.msg.c_str());
     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::BAD_PARAM);
   }
-  return new_job->getNumber();
+  return CORBA::string_dup(result.c_str());
 }
 
-void 
-SALOME_Launcher::launchJob(CORBA::Long job_id)
+void
+SALOME_Launcher::exportInputFiles(CORBA::Long job_id)
 {
   try
   {
-    _l.launchJob(job_id);
+    _l.exportInputFiles(job_id);
   }
   catch(const LauncherException &ex)
   {
@@ -239,60 +181,57 @@ SALOME_Launcher::launchJob(CORBA::Long job_id)
   }
 }
 
-char *
-SALOME_Launcher::getJobState(CORBA::Long job_id)
+void
+SALOME_Launcher::getJobResults(CORBA::Long job_id, const char * directory)
 {
-  std::string result;
   try
   {
-    result = _l.getJobState(job_id);
+    _l.getJobResults(job_id, directory);
   }
   catch(const LauncherException &ex)
   {
     INFOS(ex.msg.c_str());
     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::BAD_PARAM);
   }
-  return CORBA::string_dup(result.c_str());
 }
 
-// Get names or ids of hosts assigned to the job
-char *
-SALOME_Launcher::getAssignedHostnames(CORBA::Long job_id)
+void
+SALOME_Launcher::clearJobWorkingDir(CORBA::Long job_id)
 {
-  std::string result;
   try
   {
-    result = _l.getAssignedHostnames(job_id);
+    _l.clearJobWorkingDir(job_id);
   }
   catch(const LauncherException &ex)
   {
     INFOS(ex.msg.c_str());
     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::BAD_PARAM);
   }
-  return CORBA::string_dup(result.c_str());
 }
 
-void
-SALOME_Launcher::getJobResults(CORBA::Long job_id, const char * directory)
+CORBA::Boolean
+SALOME_Launcher::getJobDumpState(CORBA::Long job_id, const char * directory)
 {
+  CORBA::Boolean rtn = false;
   try
   {
-    _l.getJobResults(job_id, directory);
+    rtn = _l.getJobDumpState(job_id, directory);
   }
   catch(const LauncherException &ex)
   {
     INFOS(ex.msg.c_str());
     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::BAD_PARAM);
   }
+  return rtn;
 }
 
 CORBA::Boolean
-SALOME_Launcher::getJobDumpState(CORBA::Long job_id, const char * directory)
+SALOME_Launcher::getJobWorkFile(CORBA::Long job_id, const char * work_file, const char * directory)
 {
   CORBA::Boolean rtn = false;
   try
   {
-    rtn = _l.getJobDumpState(job_id, directory);
+    rtn = _l.getJobWorkFile(job_id, work_file, directory);
   }
   catch(const LauncherException &ex)
   {
@@ -302,7 +241,7 @@ SALOME_Launcher::getJobDumpState(CORBA::Long job_id, const char * directory)
   return rtn;
 }
 
-void 
+void
 SALOME_Launcher::removeJob(CORBA::Long job_id)
 {
   try
@@ -319,7 +258,7 @@ SALOME_Launcher::removeJob(CORBA::Long job_id)
   }
 }
 
-void 
+void
 SALOME_Launcher::stopJob(CORBA::Long job_id)
 {
   try
@@ -336,14 +275,51 @@ SALOME_Launcher::stopJob(CORBA::Long job_id)
   }
 }
 
+char *
+SALOME_Launcher::dumpJob(CORBA::Long job_id)
+{
+  std::string result;
+  try
+  {
+    result = _l.dumpJob(job_id);
+  }
+  catch(const LauncherException &ex)
+  {
+    INFOS(ex.msg.c_str());
+    THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::BAD_PARAM);
+  }
+  return CORBA::string_dup(result.c_str());
+}
+
+CORBA::Long
+SALOME_Launcher::restoreJob(const char * dumpedJob)
+{
+  CORBA::Long jobId;
+  try{
+    jobId = _l.restoreJob(dumpedJob);
+    if(jobId >= 0)
+    {
+      std::ostringstream job_str;
+      job_str << jobId;
+      notifyObservers("NEW_JOB", job_str.str());
+    }
+  }
+  catch(const LauncherException &ex){
+    INFOS(ex.msg.c_str());
+    THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::INTERNAL_ERROR);
+  }
+
+  return jobId;
+}
+
 //=============================================================================
 /*! CORBA Method:
  *  Create a job in the launcher with a file
  *  \param xmlExecuteFile     : .xml to parse that contains job description
- *  \param clusterName        : machine choosed
+ *  \param clusterName        : machine chosen
  */
 //=============================================================================
-CORBA::Long 
+CORBA::Long
 SALOME_Launcher::createJobWithFile(const char * xmlExecuteFile,
                                    const char * clusterName)
 {
@@ -361,11 +337,11 @@ SALOME_Launcher::createJobWithFile(const char * xmlExecuteFile,
 
 //=============================================================================
 /*! CORBA Method:
- *  the test batch configuration 
+ *  the test batch configuration
  *  \param params             : The batch cluster
  */
 //=============================================================================
-CORBA::Boolean 
+CORBA::Boolean
 SALOME_Launcher::testBatch(const Engines::ResourceParameters& params)
 {
   MESSAGE("BEGIN OF SALOME_Launcher::testBatch");
@@ -384,9 +360,9 @@ SALOME_Launcher::testBatch(const Engines::ResourceParameters& params)
     const Engines::ResourceDefinition* p = _ResManager->GetResourceDefinition((*aMachineList)[0]);
         std::string resource_name(p->name);
     INFOS("Choose resource for test: " <<  resource_name);
-    
+
     BatchTest t(*p);
-    if (t.test()) 
+    if (t.test())
     {
       rtn = true;
     }
@@ -406,6 +382,8 @@ SALOME_Launcher::testBatch(const Engines::ResourceParameters& params)
 void SALOME_Launcher::Shutdown()
 {
   MESSAGE("Shutdown");
+  if(!_NS)
+    return;
   _NS->Destroy_Name(_LauncherNameInNS);
   _ContManager->Shutdown();
   _ResManager->Shutdown();
@@ -422,7 +400,7 @@ void SALOME_Launcher::Shutdown()
 //=============================================================================
 CORBA::Long SALOME_Launcher::getPID()
 {
-  return 
+  return
 #ifndef WIN32
     (CORBA::Long)getpid();
 #else
@@ -471,76 +449,16 @@ SALOME_Launcher::getJobsList()
 Engines::JobParameters *
 SALOME_Launcher::getJobParameters(CORBA::Long job_id)
 {
-  std::map<int, Launcher::Job *> cpp_jobs = _l.getJobs();
-  std::map<int, Launcher::Job *>::const_iterator it_job = cpp_jobs.find(job_id);
-  if (it_job == cpp_jobs.end())
-  {
-    INFOS("Cannot find the job, is it created ? job number: " << job_id);
-    THROW_SALOME_CORBA_EXCEPTION("Job does not exist", SALOME::INTERNAL_ERROR);
-  }
-
-  Launcher::Job * job = it_job->second;
-  Engines::JobParameters_var job_parameters = new Engines::JobParameters;
-  job_parameters->job_name         = CORBA::string_dup(job->getJobName().c_str());
-  job_parameters->job_type         = CORBA::string_dup(job->getJobType().c_str());
-  job_parameters->job_file         = CORBA::string_dup(job->getJobFile().c_str());
-  job_parameters->env_file         = CORBA::string_dup(job->getEnvFile().c_str());
-  job_parameters->work_directory   = CORBA::string_dup(job->getWorkDirectory().c_str());
-  job_parameters->local_directory  = CORBA::string_dup(job->getLocalDirectory().c_str());
-  job_parameters->result_directory = CORBA::string_dup(job->getResultDirectory().c_str());
-
-  // Parameters for COORM
-  job_parameters->launcher_file = CORBA::string_dup(job->getLauncherFile().c_str());
-  job_parameters->launcher_args = CORBA::string_dup(job->getLauncherArgs().c_str());
-
-  int i = 0;
-  int j = 0;
-  std::list<std::string> in_files  = job->get_in_files();
-  std::list<std::string> out_files = job->get_out_files();
-  job_parameters->in_files.length(in_files.size());
-  for(std::list<std::string>::iterator it = in_files.begin(); it != in_files.end(); it++)
-  {
-    job_parameters->in_files[i] = CORBA::string_dup((*it).c_str());
-    i++;
-  }
-  job_parameters->out_files.length(out_files.size());
-  for(std::list<std::string>::iterator it = out_files.begin(); it != out_files.end(); it++)
+  Engines::JobParameters_var job_parameters;
+  try
   {
-    job_parameters->out_files[j] = CORBA::string_dup((*it).c_str());
-    j++;
+    JobParameters_cpp cpp_parameters = _l.getJobParameters(job_id);
+    job_parameters = JobParameters_CPP2CORBA(cpp_parameters);
   }
-
-  job_parameters->maximum_duration = CORBA::string_dup(job->getMaximumDuration().c_str());
-  job_parameters->queue            = CORBA::string_dup(job->getQueue().c_str());
-  job_parameters->exclusive        = job->getExclusive();
-  job_parameters->mem_per_cpu      = job->getMemPerCpu();
-  job_parameters->wckey            = CORBA::string_dup(job->getWCKey().c_str());
-  job_parameters->extra_params     = CORBA::string_dup(job->getExtraParams().c_str());
-
-  resourceParams resource_params = job->getResourceRequiredParams();
-  job_parameters->resource_required.name             = CORBA::string_dup(resource_params.name.c_str());
-  job_parameters->resource_required.hostname         = CORBA::string_dup(resource_params.hostname.c_str());
-  job_parameters->resource_required.OS               = CORBA::string_dup(resource_params.OS.c_str());
-  job_parameters->resource_required.nb_proc          = resource_params.nb_proc;
-  job_parameters->resource_required.nb_node          = resource_params.nb_node;
-  job_parameters->resource_required.nb_proc_per_node = resource_params.nb_proc_per_node;
-  job_parameters->resource_required.cpu_clock        = resource_params.cpu_clock;
-  job_parameters->resource_required.mem_mb           = resource_params.mem_mb;
-
-  std::map<std::string, std::string> specific_parameters = job->getSpecificParameters();
-  if (!specific_parameters.empty())
+  catch(const LauncherException &ex)
   {
-    job_parameters->specific_parameters.length(specific_parameters.size());
-    std::map<std::string, std::string>::const_iterator it_specific;
-    CORBA::ULong i = 0;
-    for (it_specific = specific_parameters.begin() ; it_specific != specific_parameters.end(); it_specific++)
-    {
-      Engines::Parameter_var new_param = new Engines::Parameter;
-      new_param->name  = CORBA::string_dup((it_specific->first).c_str());
-      new_param->value = CORBA::string_dup((it_specific->second).c_str());
-      job_parameters->specific_parameters[i] = new_param;
-      i++;
-    }
+    INFOS(ex.msg.c_str());
+    THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::BAD_PARAM);
   }
 
   return job_parameters._retn();
@@ -624,7 +542,7 @@ SALOME_Launcher::addObserver(Engines::SalomeLauncherObserver_ptr observer)
     {
       observer->notify("NEW_JOB", job_id.str().c_str());
     }
-    catch (...) 
+    catch (...)
     {
        MESSAGE("Notify Observer, exception catch");
     }
@@ -673,7 +591,7 @@ SALOME_Launcher::notifyObservers(const std::string & event_name,
       (*iter)->notify(CORBA::string_dup(event_name.c_str()),
                       CORBA::string_dup(event_data.c_str()));
     }
-    catch (...) 
+    catch (...)
     {
        MESSAGE("Notify Observer, exception catch");
     }
@@ -681,3 +599,123 @@ SALOME_Launcher::notifyObservers(const std::string & event_name,
   }
 
 }
+
+JobParameters_cpp
+SALOME_Launcher::JobParameters_CORBA2CPP(
+                                   const Engines::JobParameters& job_parameters)
+{
+  JobParameters_cpp result;
+
+  result.job_name = job_parameters.job_name.in();
+  result.job_type = job_parameters.job_type.in();
+  result.job_file = job_parameters.job_file.in();
+  result.pre_command = job_parameters.pre_command.in();
+  result.env_file = job_parameters.env_file.in();
+
+  result.in_files.clear();
+  for (CORBA::ULong i = 0; i < job_parameters.in_files.length(); i++)
+    result.in_files.push_back(job_parameters.in_files[i].in());
+  result.out_files.clear();
+  for (CORBA::ULong i = 0; i < job_parameters.out_files.length(); i++)
+    result.out_files.push_back(job_parameters.out_files[i].in());
+
+  result.work_directory = job_parameters.work_directory.in();
+  result.local_directory = job_parameters.local_directory.in();
+  result.result_directory = job_parameters.result_directory.in();
+  result.maximum_duration = job_parameters.maximum_duration.in();
+
+  result.resource_required = resourceParameters_CORBAtoCPP(job_parameters.resource_required);
+
+  result.queue = job_parameters.queue.in();
+  result.partition = job_parameters.partition.in();
+  result.exclusive = job_parameters.exclusive;
+  result.mem_per_cpu = job_parameters.mem_per_cpu;
+  result.wckey = job_parameters.wckey.in();
+  result.extra_params = job_parameters.extra_params.in();
+
+  result.specific_parameters.clear();
+  for (CORBA::ULong i = 0; i < job_parameters.specific_parameters.length(); i++)
+    result.specific_parameters[job_parameters.specific_parameters[i].name.in()]
+                             = job_parameters.specific_parameters[i].value.in();
+
+  result.launcher_file = job_parameters.launcher_file.in();
+  result.launcher_args = job_parameters.launcher_args.in();
+  return result;
+}
+
+Engines::JobParameters_var
+SALOME_Launcher::JobParameters_CPP2CORBA(const JobParameters_cpp& job_parameters)
+{
+  Engines::JobParameters_var result = new Engines::JobParameters;
+  result->job_name = CORBA::string_dup(job_parameters.job_name.c_str());
+  result->job_type = CORBA::string_dup(job_parameters.job_type.c_str());
+  result->job_file = CORBA::string_dup(job_parameters.job_file.c_str());
+  result->pre_command = CORBA::string_dup(job_parameters.pre_command.c_str());
+  result->env_file = CORBA::string_dup(job_parameters.env_file.c_str());
+  result->in_files.length((CORBA::ULong)job_parameters.in_files.size()); //!< TODO: conversion from size_t to CORBA::ULong
+
+  int i = 0;
+  for(const std::string& it : job_parameters.in_files)
+  {
+    result->in_files[i] = CORBA::string_dup(it.c_str());
+    i++;
+  }
+  result->out_files.length((CORBA::ULong)job_parameters.out_files.size()); //!< TODO: conversion from size_t to CORBA::ULong
+  i = 0;
+  for(const std::string& it : job_parameters.out_files)
+  {
+    result->out_files[i] = CORBA::string_dup(it.c_str());
+    i++;
+  }
+
+  result->work_directory = CORBA::string_dup(job_parameters.work_directory.c_str());
+  result->local_directory = CORBA::string_dup(job_parameters.local_directory.c_str());
+  result->result_directory = CORBA::string_dup(job_parameters.result_directory.c_str());
+  result->maximum_duration = CORBA::string_dup(job_parameters.maximum_duration.c_str());
+
+  result->resource_required = resourceParameters_CPPtoCORBA(job_parameters.resource_required);
+
+  result->queue = CORBA::string_dup(job_parameters.queue.c_str());
+  result->partition = CORBA::string_dup(job_parameters.partition.c_str());
+  result->exclusive = job_parameters.exclusive;
+  result->mem_per_cpu = job_parameters.mem_per_cpu;
+  result->wckey = CORBA::string_dup(job_parameters.wckey.c_str());
+  result->extra_params = CORBA::string_dup(job_parameters.extra_params.c_str());
+
+  const std::map<std::string, std::string>& specific_parameters
+                                       = job_parameters.specific_parameters;
+  if (!specific_parameters.empty())
+  {
+    result->specific_parameters.length((CORBA::ULong)specific_parameters.size()); //!< TODO: conversion from size_t to CORBA::ULong
+    CORBA::ULong i = 0;
+    for (const auto& it_specific : specific_parameters)
+    {
+      Engines::Parameter_var new_param = new Engines::Parameter;
+      new_param->name  = CORBA::string_dup(it_specific.first.c_str());
+      new_param->value = CORBA::string_dup(it_specific.second.c_str());
+      result->specific_parameters[i] = new_param;
+      i++;
+    }
+  }
+
+  result->launcher_file = CORBA::string_dup(job_parameters.launcher_file.c_str());
+  result->launcher_args = CORBA::string_dup(job_parameters.launcher_args.c_str());
+  return result;
+}
+
+static SALOME_Launcher *_launcher_singleton_ssl = nullptr;
+
+#include "SALOME_Fake_NamingService.hxx"
+
+SALOME_Launcher *KERNEL::getLauncherSA()
+{
+  if(!_launcher_singleton_ssl)
+  {
+    int argc(0);
+    CORBA::ORB_var orb = CORBA::ORB_init(argc,nullptr);
+    PortableServer::POA_var root_poa=PortableServer::POA::_the_root_poa();
+    SALOME_Fake_NamingService *ns=new SALOME_Fake_NamingService(orb);
+    _launcher_singleton_ssl = new SALOME_Launcher(orb,root_poa,ns);//3rd arg is important to skip NS !
+  }
+  return _launcher_singleton_ssl;
+}