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