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