src/Launcher/SALOME_Launcher.cxx

   1 // Copyright (C) 2007-2016  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 // This library is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU Lesser General Public
   8 // License as published by the Free Software Foundation; either
   9 // version 2.1 of the License, or (at your option) any later version.
  10 //
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // Lesser General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU Lesser General Public
  17 // License along with this library; if not, write to the Free Software
  18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22
  23 #include "SALOME_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
  36 #include "utilities.h"
  37
  38 #ifdef WIN32
  39 # include <process.h>
  40 #else
  41 # include <unistd.h>
  42 #endif
  43 #include <sys/types.h>
  44 #include <vector>
  45 #include <list>
  46
  47 #include <stdio.h>
  48 #include <sstream>
  49
  50 using namespace std;
  51
  52 const char *SALOME_Launcher::_LauncherNameInNS = "/SalomeLauncher";
  53
  54 //=============================================================================
  55 /*!
  56  *  Constructor
  57  *  \param orb
  58  */
  59 //=============================================================================
  60 SALOME_Launcher::SALOME_Launcher(CORBA::ORB_ptr orb, PortableServer::POA_var poa) : _l()
  61 {
  62   MESSAGE("SALOME_Launcher constructor");
  63   _NS = new SALOME_NamingService(orb);
  64   _ResManager = new SALOME_ResourcesManager(orb,poa,_NS);
  65   _l.SetResourcesManager(_ResManager->GetImpl());
  66   _ContManager = new SALOME_ContainerManager(orb,poa,_NS);
  67   _ResManager->_remove_ref();
  68   _ContManager->_remove_ref();
  69
  70   _orb = CORBA::ORB::_duplicate(orb) ;
  71   _poa = PortableServer::POA::_duplicate(poa) ;
  72   PortableServer::ObjectId_var id = _poa->activate_object(this);
  73   CORBA::Object_var obj = _poa->id_to_reference(id);
  74   Engines::SalomeLauncher_var refContMan = Engines::SalomeLauncher::_narrow(obj);
  75
  76   _NS->Register(refContMan,_LauncherNameInNS);
  77   MESSAGE("SALOME_Launcher constructor end");
  78 }
  79
  80 //=============================================================================
  81 /*!
  82  * destructor
  83  */
  84 //=============================================================================
  85 SALOME_Launcher::~SALOME_Launcher()
  86 {
  87   MESSAGE("SALOME_Launcher destructor");
  88   delete _NS;
  89   MESSAGE("SALOME_Launcher destructor end");
  90 }
  91
  92
  93 CORBA::Long
  94 SALOME_Launcher::createJob(const Engines::JobParameters & job_parameters)
  95 {
  96   std::string job_type = job_parameters.job_type.in();
  97
  98   if (job_type != "command" && job_type != "yacs_file" && job_type != "python_salome")
  99   {
 100     std::string message("SALOME_Launcher::createJob: bad job type: ");
 101     message += job_type;
 102     THROW_SALOME_CORBA_EXCEPTION(message.c_str(), SALOME::INTERNAL_ERROR);
 103   }
 104
 105   Launcher::Job * new_job; // It is Launcher_cpp that is going to destroy it
 106
 107   if (job_type == "command")
 108     new_job = new Launcher::Job_Command();
 109   else if (job_type == "yacs_file")
 110     new_job = new Launcher::Job_YACSFile();
 111   else if (job_type == "python_salome")
 112     new_job = new Launcher::Job_PythonSALOME();
 113
 114   // Name
 115   new_job->setJobName(job_parameters.job_name.in());
 116
 117   // Directories
 118   std::string work_directory = job_parameters.work_directory.in();
 119   std::string local_directory = job_parameters.local_directory.in();
 120   std::string result_directory = job_parameters.result_directory.in();
 121   new_job->setWorkDirectory(work_directory);
 122   new_job->setLocalDirectory(local_directory);
 123   new_job->setResultDirectory(result_directory);
 124
 125   // Parameters for COORM
 126   std::string launcher_file = job_parameters.launcher_file.in();
 127   std::string launcher_args = job_parameters.launcher_args.in();
 128   new_job->setLauncherFile(launcher_file);
 129   new_job->setLauncherArgs(launcher_args);
 130
 131   // Job File
 132   std::string job_file = job_parameters.job_file.in();
 133   try
 134   {
 135     new_job->setJobFile(job_file);
 136   }
 137   catch(const LauncherException &ex)
 138   {
 139     INFOS(ex.msg.c_str());
 140     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::INTERNAL_ERROR);
 141   }
 142   new_job->setPreCommand(job_parameters.pre_command.in());
 143
 144   // Files
 145   std::string env_file = job_parameters.env_file.in();
 146   new_job->setEnvFile(env_file);
 147   for (CORBA::ULong i = 0; i < job_parameters.in_files.length(); i++)
 148     new_job->add_in_file(job_parameters.in_files[i].in());
 149   for (CORBA::ULong i = 0; i < job_parameters.out_files.length(); i++)
 150     new_job->add_out_file(job_parameters.out_files[i].in());
 151
 152   // Expected During Time
 153   try
 154   {
 155     std::string maximum_duration = job_parameters.maximum_duration.in();
 156     new_job->setMaximumDuration(maximum_duration);
 157   }
 158   catch(const LauncherException &ex){
 159     INFOS(ex.msg.c_str());
 160     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::INTERNAL_ERROR);
 161   }
 162
 163   // Queue
 164   std::string queue = job_parameters.queue.in();
 165   new_job->setQueue(queue);
 166
 167   // Partition
 168   std::string partition = job_parameters.partition.in();
 169   new_job->setPartition(partition);
 170
 171   // Exclusive
 172   new_job->setExclusive(job_parameters.exclusive);
 173
 174   // Memory required per CPU
 175   new_job->setMemPerCpu(job_parameters.mem_per_cpu);
 176
 177   // WC Key
 178   std::string wckey = job_parameters.wckey.in();
 179   new_job->setWCKey(wckey);
 180
 181   // Extra params
 182   std::string extra_params = job_parameters.extra_params.in();
 183   new_job->setExtraParams(extra_params);
 184
 185   // Resources requirements
 186   try
 187   {
 188     resourceParams p;
 189     p.name = job_parameters.resource_required.name;
 190     p.hostname = job_parameters.resource_required.hostname;
 191     p.OS = job_parameters.resource_required.OS;
 192     p.nb_proc = job_parameters.resource_required.nb_proc;
 193     p.nb_node = job_parameters.resource_required.nb_node;
 194     p.nb_proc_per_node = job_parameters.resource_required.nb_proc_per_node;
 195     p.cpu_clock = job_parameters.resource_required.cpu_clock;
 196     p.mem_mb = job_parameters.resource_required.mem_mb;
 197     new_job->setResourceRequiredParams(p);
 198   }
 199   catch(const LauncherException &ex){
 200     INFOS(ex.msg.c_str());
 201     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::INTERNAL_ERROR);
 202   }
 203
 204   // Adding specific parameters to the job
 205   for (CORBA::ULong i = 0; i < job_parameters.specific_parameters.length(); i++)
 206     new_job->addSpecificParameter(job_parameters.specific_parameters[i].name.in(),
 207                                   job_parameters.specific_parameters[i].value.in());
 208   try
 209   {
 210     new_job->checkSpecificParameters();
 211   }
 212   catch(const LauncherException &ex)
 213   {
 214     INFOS(ex.msg.c_str());
 215     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::INTERNAL_ERROR);
 216   }
 217
 218   try
 219   {
 220     _l.createJob(new_job);
 221     std::ostringstream job_id;
 222     job_id << new_job->getNumber();
 223     notifyObservers("NEW_JOB", job_id.str());
 224   }
 225   catch(const LauncherException &ex)
 226   {
 227     INFOS(ex.msg.c_str());
 228     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::BAD_PARAM);
 229   }
 230   return new_job->getNumber();
 231 }
 232
 233 void
 234 SALOME_Launcher::launchJob(CORBA::Long job_id)
 235 {
 236   try
 237   {
 238     _l.launchJob(job_id);
 239   }
 240   catch(const LauncherException &ex)
 241   {
 242     INFOS(ex.msg.c_str());
 243     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::BAD_PARAM);
 244   }
 245 }
 246
 247 char *
 248 SALOME_Launcher::getJobState(CORBA::Long job_id)
 249 {
 250   std::string result;
 251   try
 252   {
 253     result = _l.getJobState(job_id);
 254   }
 255   catch(const LauncherException &ex)
 256   {
 257     INFOS(ex.msg.c_str());
 258     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::BAD_PARAM);
 259   }
 260   return CORBA::string_dup(result.c_str());
 261 }
 262
 263 // Get names or ids of hosts assigned to the job
 264 char *
 265 SALOME_Launcher::getAssignedHostnames(CORBA::Long job_id)
 266 {
 267   std::string result;
 268   try
 269   {
 270     result = _l.getAssignedHostnames(job_id);
 271   }
 272   catch(const LauncherException &ex)
 273   {
 274     INFOS(ex.msg.c_str());
 275     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::BAD_PARAM);
 276   }
 277   return CORBA::string_dup(result.c_str());
 278 }
 279
 280 void
 281 SALOME_Launcher::getJobResults(CORBA::Long job_id, const char * directory)
 282 {
 283   try
 284   {
 285     _l.getJobResults(job_id, directory);
 286   }
 287   catch(const LauncherException &ex)
 288   {
 289     INFOS(ex.msg.c_str());
 290     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::BAD_PARAM);
 291   }
 292 }
 293
 294 void
 295 SALOME_Launcher::clearJobWorkingDir(CORBA::Long job_id)
 296 {
 297   try
 298   {
 299     _l.clearJobWorkingDir(job_id);
 300   }
 301   catch(const LauncherException &ex)
 302   {
 303     INFOS(ex.msg.c_str());
 304     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::BAD_PARAM);
 305   }
 306 }
 307
 308 CORBA::Boolean
 309 SALOME_Launcher::getJobDumpState(CORBA::Long job_id, const char * directory)
 310 {
 311   CORBA::Boolean rtn = false;
 312   try
 313   {
 314     rtn = _l.getJobDumpState(job_id, directory);
 315   }
 316   catch(const LauncherException &ex)
 317   {
 318     INFOS(ex.msg.c_str());
 319     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::BAD_PARAM);
 320   }
 321   return rtn;
 322 }
 323
 324 CORBA::Boolean
 325 SALOME_Launcher::getJobWorkFile(CORBA::Long job_id, const char * work_file, const char * directory)
 326 {
 327   CORBA::Boolean rtn = false;
 328   try
 329   {
 330     rtn = _l.getJobWorkFile(job_id, work_file, directory);
 331   }
 332   catch(const LauncherException &ex)
 333   {
 334     INFOS(ex.msg.c_str());
 335     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::BAD_PARAM);
 336   }
 337   return rtn;
 338 }
 339
 340 void
 341 SALOME_Launcher::removeJob(CORBA::Long job_id)
 342 {
 343   try
 344   {
 345     _l.removeJob(job_id);
 346     std::ostringstream job_id_str;
 347     job_id_str << job_id;
 348     notifyObservers("REMOVE_JOB", job_id_str.str());
 349   }
 350   catch(const LauncherException &ex)
 351   {
 352     INFOS(ex.msg.c_str());
 353     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::BAD_PARAM);
 354   }
 355 }
 356
 357 void
 358 SALOME_Launcher::stopJob(CORBA::Long job_id)
 359 {
 360   try
 361   {
 362     _l.stopJob(job_id);
 363     std::ostringstream job_id_str;
 364     job_id_str << job_id;
 365     notifyObservers("UPDATE_JOB_STATE", job_id_str.str());
 366   }
 367   catch(const LauncherException &ex)
 368   {
 369     INFOS(ex.msg.c_str());
 370     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::BAD_PARAM);
 371   }
 372 }
 373
 374 //=============================================================================
 375 /*! CORBA Method:
 376  *  Create a job in the launcher with a file
 377  *  \param xmlExecuteFile     : .xml to parse that contains job description
 378  *  \param clusterName        : machine choosed
 379  */
 380 //=============================================================================
 381 CORBA::Long
 382 SALOME_Launcher::createJobWithFile(const char * xmlExecuteFile,
 383                                    const char * clusterName)
 384 {
 385   CORBA::Long jobId;
 386   try{
 387     jobId = _l.createJobWithFile(xmlExecuteFile, clusterName);
 388   }
 389   catch(const LauncherException &ex){
 390     INFOS(ex.msg.c_str());
 391     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::INTERNAL_ERROR);
 392   }
 393
 394   return jobId;
 395 }
 396
 397 //=============================================================================
 398 /*! CORBA Method:
 399  *  the test batch configuration
 400  *  \param params             : The batch cluster
 401  */
 402 //=============================================================================
 403 CORBA::Boolean
 404 SALOME_Launcher::testBatch(const Engines::ResourceParameters& params)
 405 {
 406   MESSAGE("BEGIN OF SALOME_Launcher::testBatch");
 407   CORBA::Boolean rtn = false;
 408   try
 409   {
 410     // Consider only resources that can run batch jobs
 411     Engines::ResourceParameters new_params(params);
 412     new_params.can_launch_batch_jobs = true;
 413
 414     // find a resource matching the required parameters
 415     Engines::ResourceList *aMachineList = _ResManager->GetFittingResources(new_params);
 416     if (aMachineList->length() == 0)
 417       throw SALOME_Exception("No resources have been found with your parameters");
 418
 419     const Engines::ResourceDefinition* p = _ResManager->GetResourceDefinition((*aMachineList)[0]);
 420         std::string resource_name(p->name);
 421     INFOS("Choose resource for test: " <<  resource_name);
 422
 423     BatchTest t(*p);
 424     if (t.test())
 425     {
 426       rtn = true;
 427     }
 428   }
 429   catch(const LauncherException &ex){
 430     INFOS(ex.msg.c_str());
 431     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::INTERNAL_ERROR);
 432   }
 433   return rtn;
 434 }
 435
 436 //=============================================================================
 437 /*! CORBA method:
 438  *  shutdown all the containers, then the ContainerManager servant
 439  */
 440 //=============================================================================
 441 void SALOME_Launcher::Shutdown()
 442 {
 443   MESSAGE("Shutdown");
 444   _NS->Destroy_Name(_LauncherNameInNS);
 445   _ContManager->Shutdown();
 446   _ResManager->Shutdown();
 447   PortableServer::ObjectId_var oid = _poa->servant_to_id(this);
 448   _poa->deactivate_object(oid);
 449   if(!CORBA::is_nil(_orb))
 450     _orb->shutdown(0);
 451 }
 452
 453 //=============================================================================
 454 /*! CORBA Method:
 455  *  Returns the PID of the process
 456  */
 457 //=============================================================================
 458 CORBA::Long SALOME_Launcher::getPID()
 459 {
 460   return
 461 #ifndef WIN32
 462     (CORBA::Long)getpid();
 463 #else
 464     (CORBA::Long)_getpid();
 465 #endif
 466 }
 467
 468 //=============================================================================
 469 /*! CORBA Method:
 470  *  Returns current launcher jobs list
 471  */
 472 //=============================================================================
 473 Engines::JobsList *
 474 SALOME_Launcher::getJobsList()
 475 {
 476   Engines::JobsList_var jobs_list = new Engines::JobsList();
 477   std::map<int, Launcher::Job *> cpp_jobs = _l.getJobs();
 478   std::map<int, Launcher::Job *>::const_iterator it_job;
 479   int list_id = 0;
 480   for(it_job = cpp_jobs.begin(); it_job != cpp_jobs.end(); it_job++)
 481   {
 482     int number          = it_job->first;
 483     try
 484     {
 485       // Prepare CORBA job description
 486       Engines::JobDescription_var job_descr = new Engines::JobDescription();
 487       Engines::JobParameters_var job_parameters = getJobParameters(number);
 488       job_descr->job_id = number;
 489       job_descr->job_parameters = job_parameters;
 490
 491       // Add job description to the sequence
 492       jobs_list->length(list_id + 1);
 493       jobs_list[list_id] = job_descr;
 494       list_id++;
 495     }
 496     catch (...) {}
 497   }
 498   return jobs_list._retn();
 499 }
 500
 501 //=============================================================================
 502 /*! CORBA Method:
 503  * Returns the job description
 504  */
 505 //=============================================================================
 506 Engines::JobParameters *
 507 SALOME_Launcher::getJobParameters(CORBA::Long job_id)
 508 {
 509   std::map<int, Launcher::Job *> cpp_jobs = _l.getJobs();
 510   std::map<int, Launcher::Job *>::const_iterator it_job = cpp_jobs.find(job_id);
 511   if (it_job == cpp_jobs.end())
 512   {
 513     INFOS("Cannot find the job, is it created ? job number: " << job_id);
 514     THROW_SALOME_CORBA_EXCEPTION("Job does not exist", SALOME::INTERNAL_ERROR);
 515   }
 516
 517   Launcher::Job * job = it_job->second;
 518   Engines::JobParameters_var job_parameters = new Engines::JobParameters;
 519   job_parameters->job_name         = CORBA::string_dup(job->getJobName().c_str());
 520   job_parameters->job_type         = CORBA::string_dup(job->getJobType().c_str());
 521   job_parameters->job_file         = CORBA::string_dup(job->getJobFile().c_str());
 522   job_parameters->env_file         = CORBA::string_dup(job->getEnvFile().c_str());
 523   job_parameters->work_directory   = CORBA::string_dup(job->getWorkDirectory().c_str());
 524   job_parameters->local_directory  = CORBA::string_dup(job->getLocalDirectory().c_str());
 525   job_parameters->result_directory = CORBA::string_dup(job->getResultDirectory().c_str());
 526   job_parameters->pre_command      = CORBA::string_dup(job->getPreCommand().c_str());
 527
 528   // Parameters for COORM
 529   job_parameters->launcher_file = CORBA::string_dup(job->getLauncherFile().c_str());
 530   job_parameters->launcher_args = CORBA::string_dup(job->getLauncherArgs().c_str());
 531
 532   int i = 0;
 533   int j = 0;
 534   std::list<std::string> in_files  = job->get_in_files();
 535   std::list<std::string> out_files = job->get_out_files();
 536   job_parameters->in_files.length(in_files.size());
 537   for(std::list<std::string>::iterator it = in_files.begin(); it != in_files.end(); it++)
 538   {
 539     job_parameters->in_files[i] = CORBA::string_dup((*it).c_str());
 540     i++;
 541   }
 542   job_parameters->out_files.length(out_files.size());
 543   for(std::list<std::string>::iterator it = out_files.begin(); it != out_files.end(); it++)
 544   {
 545     job_parameters->out_files[j] = CORBA::string_dup((*it).c_str());
 546     j++;
 547   }
 548
 549   job_parameters->maximum_duration = CORBA::string_dup(job->getMaximumDuration().c_str());
 550   job_parameters->queue            = CORBA::string_dup(job->getQueue().c_str());
 551   job_parameters->partition        = CORBA::string_dup(job->getPartition().c_str());
 552   job_parameters->exclusive        = job->getExclusive();
 553   job_parameters->mem_per_cpu      = job->getMemPerCpu();
 554   job_parameters->wckey            = CORBA::string_dup(job->getWCKey().c_str());
 555   job_parameters->extra_params     = CORBA::string_dup(job->getExtraParams().c_str());
 556
 557   resourceParams resource_params = job->getResourceRequiredParams();
 558   job_parameters->resource_required.name             = CORBA::string_dup(resource_params.name.c_str());
 559   job_parameters->resource_required.hostname         = CORBA::string_dup(resource_params.hostname.c_str());
 560   job_parameters->resource_required.OS               = CORBA::string_dup(resource_params.OS.c_str());
 561   job_parameters->resource_required.nb_proc          = resource_params.nb_proc;
 562   job_parameters->resource_required.nb_node          = resource_params.nb_node;
 563   job_parameters->resource_required.nb_proc_per_node = resource_params.nb_proc_per_node;
 564   job_parameters->resource_required.cpu_clock        = resource_params.cpu_clock;
 565   job_parameters->resource_required.mem_mb           = resource_params.mem_mb;
 566
 567   std::map<std::string, std::string> specific_parameters = job->getSpecificParameters();
 568   if (!specific_parameters.empty())
 569   {
 570     job_parameters->specific_parameters.length(specific_parameters.size());
 571     std::map<std::string, std::string>::const_iterator it_specific;
 572     CORBA::ULong i = 0;
 573     for (it_specific = specific_parameters.begin() ; it_specific != specific_parameters.end(); it_specific++)
 574     {
 575       Engines::Parameter_var new_param = new Engines::Parameter;
 576       new_param->name  = CORBA::string_dup((it_specific->first).c_str());
 577       new_param->value = CORBA::string_dup((it_specific->second).c_str());
 578       job_parameters->specific_parameters[i] = new_param;
 579       i++;
 580     }
 581   }
 582
 583   return job_parameters._retn();
 584 }
 585
 586 //=============================================================================
 587 /*! CORBA Method:
 588  *  Loads jobs saved in jobs_file
 589  */
 590 //=============================================================================
 591 void
 592 SALOME_Launcher::loadJobs(const char* jobs_file)
 593 {
 594   list<int> new_jobs_id_list;
 595   try
 596   {
 597     // Load the jobs in Launcher
 598     new_jobs_id_list = _l.loadJobs(jobs_file);
 599   }
 600   catch (const LauncherException & ex)
 601   {
 602     INFOS(ex.msg.c_str());
 603     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(), SALOME::INTERNAL_ERROR);
 604   }
 605
 606   // Notify observers of the new jobs
 607   list<int>::const_iterator it_jobs_id;
 608   for (it_jobs_id = new_jobs_id_list.begin(); it_jobs_id != new_jobs_id_list.end(); it_jobs_id++)
 609   {
 610     ostringstream job_id_sstr;
 611     job_id_sstr << *it_jobs_id;
 612     notifyObservers("NEW_JOB", job_id_sstr.str());
 613   }
 614   notifyObservers("LOAD_JOBS", jobs_file);
 615 }
 616
 617 //=============================================================================
 618 /*! CORBA Method:
 619  *  Save jobs of Launcher (in any steps) in file jobs_file
 620  */
 621 //=============================================================================
 622 void
 623 SALOME_Launcher::saveJobs(const char* jobs_file)
 624 {
 625   _l.saveJobs(jobs_file);
 626   notifyObservers("SAVE_JOBS", jobs_file);
 627 }
 628
 629 //=============================================================================
 630 /*! CORBA Method:
 631  *  Add a new observer to the launcher
 632  */
 633 //=============================================================================
 634 void
 635 SALOME_Launcher::addObserver(Engines::SalomeLauncherObserver_ptr observer)
 636 {
 637   bool new_observer = true;
 638   std::list<Engines::SalomeLauncherObserver_var>::iterator iter = _observers.begin();
 639   while(iter != _observers.end())
 640   {
 641     if (std::string(_orb->object_to_string(*iter)) ==
 642         std::string(_orb->object_to_string(observer)))
 643     {
 644       new_observer = false;
 645       break;
 646     }
 647     iter++;
 648   }
 649   if (new_observer)
 650     _observers.push_back(Engines::SalomeLauncherObserver::_duplicate(observer));
 651
 652   // We notify the new observer with all jobs that are currently in the Launcher
 653   std::map<int, Launcher::Job *> cpp_jobs = _l.getJobs();
 654   std::map<int, Launcher::Job *>::const_iterator it_job;
 655   for(it_job = cpp_jobs.begin(); it_job != cpp_jobs.end(); it_job++)
 656   {
 657     int number = it_job->first;
 658     std::ostringstream job_id;
 659     job_id << number;
 660     try
 661     {
 662       observer->notify("NEW_JOB", job_id.str().c_str());
 663     }
 664     catch (...)
 665     {
 666        MESSAGE("Notify Observer, exception catch");
 667     }
 668
 669   }
 670 }
 671
 672 //=============================================================================
 673 /*! CORBA Method:
 674  *  Add a new observer to the launcher
 675  */
 676 //=============================================================================
 677 void
 678 SALOME_Launcher::removeObserver(Engines::SalomeLauncherObserver_ptr observer)
 679 {
 680   std::list<Engines::SalomeLauncherObserver_var>::iterator iter = _observers.begin();
 681   while(iter != _observers.end())
 682   {
 683     if (std::string(_orb->object_to_string(*iter)) ==
 684         std::string(_orb->object_to_string(observer)))
 685     {
 686       // Observer found
 687       iter =_observers.erase(iter++);
 688     }
 689     else
 690     {
 691       iter++;
 692     }
 693   }
 694 }
 695
 696 //=============================================================================
 697 /*! Internal Method:
 698  *  Notify observers on a new event
 699  */
 700 //=============================================================================
 701 void
 702 SALOME_Launcher::notifyObservers(const std::string & event_name,
 703                                  const std::string & event_data)
 704 {
 705   std::list<Engines::SalomeLauncherObserver_var>::iterator iter = _observers.begin();
 706   while(iter != _observers.end())
 707   {
 708     try
 709     {
 710       (*iter)->notify(CORBA::string_dup(event_name.c_str()),
 711                       CORBA::string_dup(event_data.c_str()));
 712     }
 713     catch (...)
 714     {
 715        MESSAGE("Notify Observer, exception catch");
 716     }
 717     iter++;
 718   }
 719
 720 }