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   // Exclusive
 168   new_job->setExclusive(job_parameters.exclusive);
 169
 170   // Memory required per CPU
 171   new_job->setMemPerCpu(job_parameters.mem_per_cpu);
 172
 173   // WC Key
 174   std::string wckey = job_parameters.wckey.in();
 175   new_job->setWCKey(wckey);
 176
 177   // Extra params
 178   std::string extra_params = job_parameters.extra_params.in();
 179   new_job->setExtraParams(extra_params);
 180
 181   // Resources requirements
 182   try
 183   {
 184     resourceParams p;
 185     p.name = job_parameters.resource_required.name;
 186     p.hostname = job_parameters.resource_required.hostname;
 187     p.OS = job_parameters.resource_required.OS;
 188     p.nb_proc = job_parameters.resource_required.nb_proc;
 189     p.nb_node = job_parameters.resource_required.nb_node;
 190     p.nb_proc_per_node = job_parameters.resource_required.nb_proc_per_node;
 191     p.cpu_clock = job_parameters.resource_required.cpu_clock;
 192     p.mem_mb = job_parameters.resource_required.mem_mb;
 193     new_job->setResourceRequiredParams(p);
 194   }
 195   catch(const LauncherException &ex){
 196     INFOS(ex.msg.c_str());
 197     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::INTERNAL_ERROR);
 198   }
 199
 200   // Adding specific parameters to the job
 201   for (CORBA::ULong i = 0; i < job_parameters.specific_parameters.length(); i++)
 202     new_job->addSpecificParameter(job_parameters.specific_parameters[i].name.in(),
 203                                   job_parameters.specific_parameters[i].value.in());
 204   try
 205   {
 206     new_job->checkSpecificParameters();
 207   }
 208   catch(const LauncherException &ex)
 209   {
 210     INFOS(ex.msg.c_str());
 211     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::INTERNAL_ERROR);
 212   }
 213
 214   try
 215   {
 216     _l.createJob(new_job);
 217     std::ostringstream job_id;
 218     job_id << new_job->getNumber();
 219     notifyObservers("NEW_JOB", job_id.str());
 220   }
 221   catch(const LauncherException &ex)
 222   {
 223     INFOS(ex.msg.c_str());
 224     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::BAD_PARAM);
 225   }
 226   return new_job->getNumber();
 227 }
 228
 229 void
 230 SALOME_Launcher::launchJob(CORBA::Long job_id)
 231 {
 232   try
 233   {
 234     _l.launchJob(job_id);
 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 }
 242
 243 char *
 244 SALOME_Launcher::getJobState(CORBA::Long job_id)
 245 {
 246   std::string result;
 247   try
 248   {
 249     result = _l.getJobState(job_id);
 250   }
 251   catch(const LauncherException &ex)
 252   {
 253     INFOS(ex.msg.c_str());
 254     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::BAD_PARAM);
 255   }
 256   return CORBA::string_dup(result.c_str());
 257 }
 258
 259 // Get names or ids of hosts assigned to the job
 260 char *
 261 SALOME_Launcher::getAssignedHostnames(CORBA::Long job_id)
 262 {
 263   std::string result;
 264   try
 265   {
 266     result = _l.getAssignedHostnames(job_id);
 267   }
 268   catch(const LauncherException &ex)
 269   {
 270     INFOS(ex.msg.c_str());
 271     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::BAD_PARAM);
 272   }
 273   return CORBA::string_dup(result.c_str());
 274 }
 275
 276 void
 277 SALOME_Launcher::getJobResults(CORBA::Long job_id, const char * directory)
 278 {
 279   try
 280   {
 281     _l.getJobResults(job_id, directory);
 282   }
 283   catch(const LauncherException &ex)
 284   {
 285     INFOS(ex.msg.c_str());
 286     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::BAD_PARAM);
 287   }
 288 }
 289
 290 void
 291 SALOME_Launcher::clearJobWorkingDir(CORBA::Long job_id)
 292 {
 293   try
 294   {
 295     _l.clearJobWorkingDir(job_id);
 296   }
 297   catch(const LauncherException &ex)
 298   {
 299     INFOS(ex.msg.c_str());
 300     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::BAD_PARAM);
 301   }
 302 }
 303
 304 CORBA::Boolean
 305 SALOME_Launcher::getJobDumpState(CORBA::Long job_id, const char * directory)
 306 {
 307   CORBA::Boolean rtn = false;
 308   try
 309   {
 310     rtn = _l.getJobDumpState(job_id, directory);
 311   }
 312   catch(const LauncherException &ex)
 313   {
 314     INFOS(ex.msg.c_str());
 315     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::BAD_PARAM);
 316   }
 317   return rtn;
 318 }
 319
 320 CORBA::Boolean
 321 SALOME_Launcher::getJobWorkFile(CORBA::Long job_id, const char * work_file, const char * directory)
 322 {
 323   CORBA::Boolean rtn = false;
 324   try
 325   {
 326     rtn = _l.getJobWorkFile(job_id, work_file, directory);
 327   }
 328   catch(const LauncherException &ex)
 329   {
 330     INFOS(ex.msg.c_str());
 331     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::BAD_PARAM);
 332   }
 333   return rtn;
 334 }
 335
 336 void
 337 SALOME_Launcher::removeJob(CORBA::Long job_id)
 338 {
 339   try
 340   {
 341     _l.removeJob(job_id);
 342     std::ostringstream job_id_str;
 343     job_id_str << job_id;
 344     notifyObservers("REMOVE_JOB", job_id_str.str());
 345   }
 346   catch(const LauncherException &ex)
 347   {
 348     INFOS(ex.msg.c_str());
 349     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::BAD_PARAM);
 350   }
 351 }
 352
 353 void
 354 SALOME_Launcher::stopJob(CORBA::Long job_id)
 355 {
 356   try
 357   {
 358     _l.stopJob(job_id);
 359     std::ostringstream job_id_str;
 360     job_id_str << job_id;
 361     notifyObservers("UPDATE_JOB_STATE", job_id_str.str());
 362   }
 363   catch(const LauncherException &ex)
 364   {
 365     INFOS(ex.msg.c_str());
 366     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::BAD_PARAM);
 367   }
 368 }
 369
 370 //=============================================================================
 371 /*! CORBA Method:
 372  *  Create a job in the launcher with a file
 373  *  \param xmlExecuteFile     : .xml to parse that contains job description
 374  *  \param clusterName        : machine choosed
 375  */
 376 //=============================================================================
 377 CORBA::Long
 378 SALOME_Launcher::createJobWithFile(const char * xmlExecuteFile,
 379                                    const char * clusterName)
 380 {
 381   CORBA::Long jobId;
 382   try{
 383     jobId = _l.createJobWithFile(xmlExecuteFile, clusterName);
 384   }
 385   catch(const LauncherException &ex){
 386     INFOS(ex.msg.c_str());
 387     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::INTERNAL_ERROR);
 388   }
 389
 390   return jobId;
 391 }
 392
 393 //=============================================================================
 394 /*! CORBA Method:
 395  *  the test batch configuration
 396  *  \param params             : The batch cluster
 397  */
 398 //=============================================================================
 399 CORBA::Boolean
 400 SALOME_Launcher::testBatch(const Engines::ResourceParameters& params)
 401 {
 402   MESSAGE("BEGIN OF SALOME_Launcher::testBatch");
 403   CORBA::Boolean rtn = false;
 404   try
 405   {
 406     // Consider only resources that can run batch jobs
 407     Engines::ResourceParameters new_params(params);
 408     new_params.can_launch_batch_jobs = true;
 409
 410     // find a resource matching the required parameters
 411     Engines::ResourceList *aMachineList = _ResManager->GetFittingResources(new_params);
 412     if (aMachineList->length() == 0)
 413       throw SALOME_Exception("No resources have been found with your parameters");
 414
 415     const Engines::ResourceDefinition* p = _ResManager->GetResourceDefinition((*aMachineList)[0]);
 416         std::string resource_name(p->name);
 417     INFOS("Choose resource for test: " <<  resource_name);
 418
 419     BatchTest t(*p);
 420     if (t.test())
 421     {
 422       rtn = true;
 423     }
 424   }
 425   catch(const LauncherException &ex){
 426     INFOS(ex.msg.c_str());
 427     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(),SALOME::INTERNAL_ERROR);
 428   }
 429   return rtn;
 430 }
 431
 432 //=============================================================================
 433 /*! CORBA method:
 434  *  shutdown all the containers, then the ContainerManager servant
 435  */
 436 //=============================================================================
 437 void SALOME_Launcher::Shutdown()
 438 {
 439   MESSAGE("Shutdown");
 440   _NS->Destroy_Name(_LauncherNameInNS);
 441   _ContManager->Shutdown();
 442   _ResManager->Shutdown();
 443   PortableServer::ObjectId_var oid = _poa->servant_to_id(this);
 444   _poa->deactivate_object(oid);
 445   if(!CORBA::is_nil(_orb))
 446     _orb->shutdown(0);
 447 }
 448
 449 //=============================================================================
 450 /*! CORBA Method:
 451  *  Returns the PID of the process
 452  */
 453 //=============================================================================
 454 CORBA::Long SALOME_Launcher::getPID()
 455 {
 456   return
 457 #ifndef WIN32
 458     (CORBA::Long)getpid();
 459 #else
 460     (CORBA::Long)_getpid();
 461 #endif
 462 }
 463
 464 //=============================================================================
 465 /*! CORBA Method:
 466  *  Returns current launcher jobs list
 467  */
 468 //=============================================================================
 469 Engines::JobsList *
 470 SALOME_Launcher::getJobsList()
 471 {
 472   Engines::JobsList_var jobs_list = new Engines::JobsList();
 473   std::map<int, Launcher::Job *> cpp_jobs = _l.getJobs();
 474   std::map<int, Launcher::Job *>::const_iterator it_job;
 475   int list_id = 0;
 476   for(it_job = cpp_jobs.begin(); it_job != cpp_jobs.end(); it_job++)
 477   {
 478     int number          = it_job->first;
 479     try
 480     {
 481       // Prepare CORBA job description
 482       Engines::JobDescription_var job_descr = new Engines::JobDescription();
 483       Engines::JobParameters_var job_parameters = getJobParameters(number);
 484       job_descr->job_id = number;
 485       job_descr->job_parameters = job_parameters;
 486
 487       // Add job description to the sequence
 488       jobs_list->length(list_id + 1);
 489       jobs_list[list_id] = job_descr;
 490       list_id++;
 491     }
 492     catch (...) {}
 493   }
 494   return jobs_list._retn();
 495 }
 496
 497 //=============================================================================
 498 /*! CORBA Method:
 499  * Returns the job description
 500  */
 501 //=============================================================================
 502 Engines::JobParameters *
 503 SALOME_Launcher::getJobParameters(CORBA::Long job_id)
 504 {
 505   std::map<int, Launcher::Job *> cpp_jobs = _l.getJobs();
 506   std::map<int, Launcher::Job *>::const_iterator it_job = cpp_jobs.find(job_id);
 507   if (it_job == cpp_jobs.end())
 508   {
 509     INFOS("Cannot find the job, is it created ? job number: " << job_id);
 510     THROW_SALOME_CORBA_EXCEPTION("Job does not exist", SALOME::INTERNAL_ERROR);
 511   }
 512
 513   Launcher::Job * job = it_job->second;
 514   Engines::JobParameters_var job_parameters = new Engines::JobParameters;
 515   job_parameters->job_name         = CORBA::string_dup(job->getJobName().c_str());
 516   job_parameters->job_type         = CORBA::string_dup(job->getJobType().c_str());
 517   job_parameters->job_file         = CORBA::string_dup(job->getJobFile().c_str());
 518   job_parameters->env_file         = CORBA::string_dup(job->getEnvFile().c_str());
 519   job_parameters->work_directory   = CORBA::string_dup(job->getWorkDirectory().c_str());
 520   job_parameters->local_directory  = CORBA::string_dup(job->getLocalDirectory().c_str());
 521   job_parameters->result_directory = CORBA::string_dup(job->getResultDirectory().c_str());
 522   job_parameters->pre_command      = CORBA::string_dup(job->getPreCommand().c_str());
 523
 524   // Parameters for COORM
 525   job_parameters->launcher_file = CORBA::string_dup(job->getLauncherFile().c_str());
 526   job_parameters->launcher_args = CORBA::string_dup(job->getLauncherArgs().c_str());
 527
 528   int i = 0;
 529   int j = 0;
 530   std::list<std::string> in_files  = job->get_in_files();
 531   std::list<std::string> out_files = job->get_out_files();
 532   job_parameters->in_files.length(in_files.size());
 533   for(std::list<std::string>::iterator it = in_files.begin(); it != in_files.end(); it++)
 534   {
 535     job_parameters->in_files[i] = CORBA::string_dup((*it).c_str());
 536     i++;
 537   }
 538   job_parameters->out_files.length(out_files.size());
 539   for(std::list<std::string>::iterator it = out_files.begin(); it != out_files.end(); it++)
 540   {
 541     job_parameters->out_files[j] = CORBA::string_dup((*it).c_str());
 542     j++;
 543   }
 544
 545   job_parameters->maximum_duration = CORBA::string_dup(job->getMaximumDuration().c_str());
 546   job_parameters->queue            = CORBA::string_dup(job->getQueue().c_str());
 547   job_parameters->exclusive        = job->getExclusive();
 548   job_parameters->mem_per_cpu      = job->getMemPerCpu();
 549   job_parameters->wckey            = CORBA::string_dup(job->getWCKey().c_str());
 550   job_parameters->extra_params     = CORBA::string_dup(job->getExtraParams().c_str());
 551
 552   resourceParams resource_params = job->getResourceRequiredParams();
 553   job_parameters->resource_required.name             = CORBA::string_dup(resource_params.name.c_str());
 554   job_parameters->resource_required.hostname         = CORBA::string_dup(resource_params.hostname.c_str());
 555   job_parameters->resource_required.OS               = CORBA::string_dup(resource_params.OS.c_str());
 556   job_parameters->resource_required.nb_proc          = resource_params.nb_proc;
 557   job_parameters->resource_required.nb_node          = resource_params.nb_node;
 558   job_parameters->resource_required.nb_proc_per_node = resource_params.nb_proc_per_node;
 559   job_parameters->resource_required.cpu_clock        = resource_params.cpu_clock;
 560   job_parameters->resource_required.mem_mb           = resource_params.mem_mb;
 561
 562   std::map<std::string, std::string> specific_parameters = job->getSpecificParameters();
 563   if (!specific_parameters.empty())
 564   {
 565     job_parameters->specific_parameters.length(specific_parameters.size());
 566     std::map<std::string, std::string>::const_iterator it_specific;
 567     CORBA::ULong i = 0;
 568     for (it_specific = specific_parameters.begin() ; it_specific != specific_parameters.end(); it_specific++)
 569     {
 570       Engines::Parameter_var new_param = new Engines::Parameter;
 571       new_param->name  = CORBA::string_dup((it_specific->first).c_str());
 572       new_param->value = CORBA::string_dup((it_specific->second).c_str());
 573       job_parameters->specific_parameters[i] = new_param;
 574       i++;
 575     }
 576   }
 577
 578   return job_parameters._retn();
 579 }
 580
 581 //=============================================================================
 582 /*! CORBA Method:
 583  *  Loads jobs saved in jobs_file
 584  */
 585 //=============================================================================
 586 void
 587 SALOME_Launcher::loadJobs(const char* jobs_file)
 588 {
 589   list<int> new_jobs_id_list;
 590   try
 591   {
 592     // Load the jobs in Launcher
 593     new_jobs_id_list = _l.loadJobs(jobs_file);
 594   }
 595   catch (const LauncherException & ex)
 596   {
 597     INFOS(ex.msg.c_str());
 598     THROW_SALOME_CORBA_EXCEPTION(ex.msg.c_str(), SALOME::INTERNAL_ERROR);
 599   }
 600
 601   // Notify observers of the new jobs
 602   list<int>::const_iterator it_jobs_id;
 603   for (it_jobs_id = new_jobs_id_list.begin(); it_jobs_id != new_jobs_id_list.end(); it_jobs_id++)
 604   {
 605     ostringstream job_id_sstr;
 606     job_id_sstr << *it_jobs_id;
 607     notifyObservers("NEW_JOB", job_id_sstr.str());
 608   }
 609   notifyObservers("LOAD_JOBS", jobs_file);
 610 }
 611
 612 //=============================================================================
 613 /*! CORBA Method:
 614  *  Save jobs of Launcher (in any steps) in file jobs_file
 615  */
 616 //=============================================================================
 617 void
 618 SALOME_Launcher::saveJobs(const char* jobs_file)
 619 {
 620   _l.saveJobs(jobs_file);
 621   notifyObservers("SAVE_JOBS", jobs_file);
 622 }
 623
 624 //=============================================================================
 625 /*! CORBA Method:
 626  *  Add a new observer to the launcher
 627  */
 628 //=============================================================================
 629 void
 630 SALOME_Launcher::addObserver(Engines::SalomeLauncherObserver_ptr observer)
 631 {
 632   bool new_observer = true;
 633   std::list<Engines::SalomeLauncherObserver_var>::iterator iter = _observers.begin();
 634   while(iter != _observers.end())
 635   {
 636     if (std::string(_orb->object_to_string(*iter)) ==
 637         std::string(_orb->object_to_string(observer)))
 638     {
 639       new_observer = false;
 640       break;
 641     }
 642     iter++;
 643   }
 644   if (new_observer)
 645     _observers.push_back(Engines::SalomeLauncherObserver::_duplicate(observer));
 646
 647   // We notify the new observer with all jobs that are currently in the Launcher
 648   std::map<int, Launcher::Job *> cpp_jobs = _l.getJobs();
 649   std::map<int, Launcher::Job *>::const_iterator it_job;
 650   for(it_job = cpp_jobs.begin(); it_job != cpp_jobs.end(); it_job++)
 651   {
 652     int number = it_job->first;
 653     std::ostringstream job_id;
 654     job_id << number;
 655     try
 656     {
 657       observer->notify("NEW_JOB", job_id.str().c_str());
 658     }
 659     catch (...)
 660     {
 661        MESSAGE("Notify Observer, exception catch");
 662     }
 663
 664   }
 665 }
 666
 667 //=============================================================================
 668 /*! CORBA Method:
 669  *  Add a new observer to the launcher
 670  */
 671 //=============================================================================
 672 void
 673 SALOME_Launcher::removeObserver(Engines::SalomeLauncherObserver_ptr observer)
 674 {
 675   std::list<Engines::SalomeLauncherObserver_var>::iterator iter = _observers.begin();
 676   while(iter != _observers.end())
 677   {
 678     if (std::string(_orb->object_to_string(*iter)) ==
 679         std::string(_orb->object_to_string(observer)))
 680     {
 681       // Observer found
 682       iter =_observers.erase(iter++);
 683     }
 684     else
 685     {
 686       iter++;
 687     }
 688   }
 689 }
 690
 691 //=============================================================================
 692 /*! Internal Method:
 693  *  Notify observers on a new event
 694  */
 695 //=============================================================================
 696 void
 697 SALOME_Launcher::notifyObservers(const std::string & event_name,
 698                                  const std::string & event_data)
 699 {
 700   std::list<Engines::SalomeLauncherObserver_var>::iterator iter = _observers.begin();
 701   while(iter != _observers.end())
 702   {
 703     try
 704     {
 705       (*iter)->notify(CORBA::string_dup(event_name.c_str()),
 706                       CORBA::string_dup(event_data.c_str()));
 707     }
 708     catch (...)
 709     {
 710        MESSAGE("Notify Observer, exception catch");
 711     }
 712     iter++;
 713   }
 714
 715 }