src/Launcher/SALOME_Launcher.cxx

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