1 // Copyright (C) 2009-2012 CEA/DEN, EDF R&D
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License.
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 // Lesser General Public License for more details.
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
20 #include "BL_JobsManager.hxx"
27 BL::JobsManager::JobsManager(BL::SALOMEServices * salome_services)
29 DEBTRACE("Creating BL::JobsManager");
30 BL_ASSERT(salome_services);
31 _salome_services = salome_services;
32 _salome_services->set_manager(this);
37 BL::JobsManager::~JobsManager()
39 DEBTRACE("Destroying BL::JobsManager");
42 _jobs_it = _jobs.begin();
43 for(;_jobs_it != _jobs.end();_jobs_it++)
44 delete _jobs_it->second;
48 BL::JobsManager::setObserver(BL::Observer * observer)
55 BL::JobsManager::createJob(const std::string & name)
57 DEBTRACE("createJob BL::JobsManager");
59 BL::Job * new_job = NULL;
61 _thread_mutex_jobs_map.lock();
62 _jobs_it = _jobs.find(name);
63 if (_jobs_it == _jobs.end())
65 new_job = new BL::Job(name);
67 // Ajout dans la liste
68 _jobs[name] = new_job;
71 DEBTRACE("createJob Error !!!! Job already exist: " << name);
73 _thread_mutex_jobs_map.unlock();
78 BL::JobsManager::addJobToLauncher(const std::string & name)
80 DEBTRACE("addJobToLauncher BL::JobsManager");
82 _thread_mutex_jobs_map.lock();
83 _jobs_it = _jobs.find(name);
84 if (_jobs_it == _jobs.end())
86 // TODO: SHOULD SEND an exeception...
87 DEBMSG("[addJobToLauncher] failed, job was not found");
89 std::string result = "";
90 result = _salome_services->create_job(_jobs_it->second);
92 // Unlock is here to be sure that
93 // method setSalomeLauncherId is called if
94 // the creation is successfull
95 _thread_mutex_jobs_map.unlock();
100 _jobs_it->second->setState(BL::Job::NOT_CREATED);
101 _observer->sendEvent("create_job", "Error", name, result);
104 _observer->sendEvent("create_job", "Ok", name, "");
108 BL::JobsManager::removeJob(const std::string & name)
110 DEBTRACE("removeJob BL::JobsManager");
111 _thread_mutex_jobs_map.lock();
112 _jobs_it = _jobs.find(name);
113 if (_jobs_it != _jobs.end())
115 std::string result = "";
116 if (_jobs_it->second->getSalomeLauncherId() != -1)
117 result = _salome_services->delete_job(_jobs_it->second);
119 delete _jobs_it->second;
120 _jobs.erase(_jobs_it->first);
124 _observer->sendEvent("delete_job", "Error", name, result);
126 _observer->sendEvent("delete_job", "Ok", name, "");
129 DEBTRACE("removeJob Error !!!! Job does not exist: " << name);
130 _thread_mutex_jobs_map.unlock();
134 BL::JobsManager::getJob(const std::string & name)
136 DEBTRACE("getJob BL::JobsManager called");
140 std::map<std::string, BL::Job *> &
141 BL::JobsManager::getJobs()
147 BL::JobsManager::job_already_exist(const std::string & name)
151 _thread_mutex_jobs_map.lock();
152 _jobs_it = _jobs.find(name);
153 if (_jobs_it == _jobs.end())
155 _thread_mutex_jobs_map.unlock();
161 BL::JobsManager::start_job(const std::string & name)
163 DEBTRACE("BL::JobsManager::start_job called for job: " << name);
164 // Prepare Info for thread
165 BL::JobsManager::thread_info * ti = new thread_info();
166 ti->object_ptr = this;
168 omni_thread::create(BL::JobsManager::starting_job_thread, ti);
173 BL::JobsManager::starting_job_thread(void * object_ptr)
175 DEBTRACE("starting_job_thread BL::JobsManager called");
176 BL::JobsManager::thread_info * ti = reinterpret_cast<BL::JobsManager::thread_info*>(object_ptr);
177 BL::JobsManager * object = ti->object_ptr;
178 std::string job_name = ti->job_name;
181 object->_thread_mutex_jobs_map.lock();
182 object->_jobs_it = object->_jobs.find(job_name);
183 if (object->_jobs_it == object->_jobs.end())
185 DEBTRACE("BL::JobsManager::start_job job unknown: " << job_name);
189 BL::Job * job = object->getJob(job_name);
190 std::string result = object->_salome_services->start_job(job);
193 job->setState(BL::Job::QUEUED);
194 job->setThreadState(BL::Job::NOTHING);
195 if (object->_observer)
196 object->_observer->sendEvent("start_job", "Ok", job_name, "");
200 job->setState(BL::Job::ERROR);
201 job->setThreadState(BL::Job::NOTHING);
202 if (object->_observer)
203 object->_observer->sendEvent("start_job", "Error", job_name, result);
206 object->_thread_mutex_jobs_map.unlock();
210 BL::JobsManager::stop_job(const std::string & name)
212 DEBTRACE("stop_job BL::JobsManager called");
214 _thread_mutex_jobs_map.lock();
216 _jobs_it = _jobs.find(name);
217 if (_jobs_it == _jobs.end())
219 DEBTRACE("BL::JobsManager::stop_job job unknown: " << name);
220 _thread_mutex_jobs_map.unlock();
225 // Prepare Info for thread
226 BL::JobsManager::thread_info * ti = new thread_info();
227 ti->object_ptr = this;
229 omni_thread::create(BL::JobsManager::stop_job_thread, ti);
234 BL::JobsManager::stop_job_thread(void * object_ptr)
236 DEBTRACE("stop_job_thread BL::JobsManager called");
237 BL::JobsManager::thread_info * ti = reinterpret_cast<BL::JobsManager::thread_info*>(object_ptr);
238 BL::JobsManager * object = ti->object_ptr;
239 std::string job_name = ti->job_name;
240 BL::Job * job = object->getJob(job_name);
242 std::string result = object->_salome_services->stop_job(job);
247 if (object->_observer)
248 object->_observer->sendEvent("stop_job", "Ok", job_name, "");
252 if (object->_observer)
253 object->_observer->sendEvent("stop_job", "Error", job_name, result);
255 object->_thread_mutex_jobs_map.unlock();
259 BL::JobsManager::refresh_jobs()
261 DEBTRACE("refresh_jobs BL::JobsManager called");
263 omni_thread::create(BL::JobsManager::refresh_jobs_thread, this);
267 BL::JobsManager::refresh_jobs_thread(void * object_ptr)
269 DEBTRACE("refresh_job BL::JobsManager called");
270 BL::JobsManager * object = reinterpret_cast<BL::JobsManager*>(object_ptr);
272 //iterate on all jobs
273 object->_thread_mutex_jobs_map.lock();
274 _jobs_map::iterator jobs_it;
275 jobs_it = object->_jobs.begin();
276 for(;jobs_it != object->_jobs.end();jobs_it++)
278 BL::Job * job = jobs_it->second;
279 if (job->getSalomeLauncherId() != -1)
281 if (job->getThreadState() == BL::Job::NOTHING)
283 BL::Job::State job_state = job->getState();
284 if (job_state != BL::Job::FINISHED &&
285 job_state != BL::Job::ERROR &&
286 job_state != BL::Job::FAILED &&
287 job_state != BL::Job::NOT_CREATED)
289 std::string result_launcher = object->_salome_services->refresh_job(job);
290 std::string result_job = job->setStringState(result_launcher);
291 if (result_job == "RefreshError")
293 // Error using launcher...
294 if (object->_observer)
295 object->_observer->sendEvent("refresh_job", "Error", job->getName(), result_launcher);
297 else if (result_job != "")
299 if (object->_observer)
300 object->_observer->sendEvent("refresh_job", "Ok", job->getName(), result_job);
306 object->_thread_mutex_jobs_map.unlock();
310 BL::JobsManager::get_results_job(const std::string & name)
312 DEBTRACE("get_results_job BL::JobsManager called");
314 _thread_mutex_jobs_map.lock();
316 _jobs_it = _jobs.find(name);
317 if (_jobs_it == _jobs.end())
319 DEBTRACE("BL::JobsManager::get_results_job job unknown: " << name);
320 _thread_mutex_jobs_map.unlock();
325 BL::Job * job = _jobs_it->second;
326 if (job->getState() == BL::Job::FINISHED ||
327 job->getState() == BL::Job::ERROR ||
328 job->getState() == BL::Job::FAILED
331 // Prepare Info for thread
332 BL::JobsManager::thread_info * ti = new thread_info();
333 ti->object_ptr = this;
335 omni_thread::create(BL::JobsManager::get_results_job_thread, ti);
339 DEBTRACE("BL::JobsManager::get_results_job job bad job state !");
340 _thread_mutex_jobs_map.unlock();
347 BL::JobsManager::get_results_job_thread(void * object_ptr)
349 DEBTRACE("get_results_job_thread BL::JobsManager called");
350 BL::JobsManager::thread_info * ti = reinterpret_cast<BL::JobsManager::thread_info*>(object_ptr);
351 BL::JobsManager * object = ti->object_ptr;
352 std::string job_name = ti->job_name;
353 BL::Job * job = object->getJob(job_name);
355 std::string result = object->_salome_services->get_results_job(job);
360 if (object->_observer)
361 object->_observer->sendEvent("get_results_job", "Ok", job_name, "");
365 if (object->_observer)
366 object->_observer->sendEvent("get_results_job", "Error", job_name, result);
368 object->_thread_mutex_jobs_map.unlock();
372 BL::JobsManager::save_jobs(const std::string & xml_file)
374 DEBTRACE("BL::JobsManager::save_jobs called for : " << xml_file);
376 // Prepare Info for thread
377 BL::JobsManager::thread_info_file * ti = new thread_info_file();
378 ti->object_ptr = this;
379 ti->file_name = xml_file;
380 omni_thread::create(BL::JobsManager::save_jobs_thread, ti);
384 BL::JobsManager::load_jobs(const std::string & xml_file)
386 DEBTRACE("BL::JobsManager::load_jobs called for : " << xml_file);
388 // Prepare Info for thread
389 BL::JobsManager::thread_info_file * ti = new thread_info_file();
390 ti->object_ptr = this;
391 ti->file_name = xml_file;
392 omni_thread::create(BL::JobsManager::load_jobs_thread, ti);
396 BL::JobsManager::save_jobs_thread(void * object_ptr)
398 DEBTRACE("save_jobs_thread BL::JobsManager called");
399 BL::JobsManager::thread_info_file * ti = reinterpret_cast<BL::JobsManager::thread_info_file*>(object_ptr);
400 BL::JobsManager * object = ti->object_ptr;
401 std::string file_name = ti->file_name;
403 object->_thread_mutex_jobs_map.lock();
404 std::string result = object->_salome_services->save_jobs(file_name);
405 object->_thread_mutex_jobs_map.unlock();
408 if (object->_observer)
409 object->_observer->sendEvent("save_jobs", "Error", "", result);
413 BL::JobsManager::load_jobs_thread(void * object_ptr)
415 DEBTRACE("load_jobs_thread BL::JobsManager called");
416 BL::JobsManager::thread_info_file * ti = reinterpret_cast<BL::JobsManager::thread_info_file*>(object_ptr);
417 BL::JobsManager * object = ti->object_ptr;
418 std::string file_name = ti->file_name;
420 object->_thread_mutex_jobs_map.lock();
421 std::string result = object->_salome_services->load_jobs(file_name);
422 object->_thread_mutex_jobs_map.unlock();
425 if (object->_observer)
426 object->_observer->sendEvent("load_jobs", "Error", "", result);
430 BL::JobsManager::launcher_event_save_jobs(const std::string & data)
433 _observer->sendEvent("save_jobs", "Ok", "", data);
437 BL::JobsManager::launcher_event_load_jobs(const std::string & data)
440 _observer->sendEvent("load_jobs", "Ok", "", data);
444 BL::JobsManager::launcher_event_new_job(const std::string & data)
447 std::istringstream job_number_stream(data);
448 if (job_number_stream >> job_number)
450 DEBTRACE("Receive NEWJOB:" << job_number);
451 BL::JobsManager::thread_info_new_job * ti = new thread_info_new_job();
452 ti->object_ptr = this;
453 ti->job_number = job_number;
454 omni_thread::create(BL::JobsManager::launcher_event_new_job_thread, ti);
459 BL::JobsManager::launcher_event_update_job_state(const std::string & data)
465 BL::JobsManager::launcher_event_new_job_thread(void * object_ptr)
467 DEBTRACE("Start of BL::JobsManager::launcher_event_new_job_thread");
468 BL::JobsManager::thread_info_new_job * ti = reinterpret_cast<BL::JobsManager::thread_info_new_job*>(object_ptr);
469 BL::JobsManager * object = ti->object_ptr;
470 int job_number = ti->job_number;
472 object->_thread_mutex_jobs_map.lock();
474 // 1: Check if job is not already on our map
475 bool job_in_map = false;
476 _jobs_map::iterator jobs_it;
477 jobs_it = object->_jobs.begin();
478 for(;jobs_it != object->_jobs.end();jobs_it++)
480 BL::Job * job = jobs_it->second;
481 if (job->getSalomeLauncherId() == job_number)
487 // 2: We try to get job informations
489 BL::Job * new_job = object->_salome_services->get_new_job(job_number);
494 // 4: Check if job has a name or if the name already exists
495 if (new_job->getName() == "")
497 std::ostringstream name_stream;
498 name_stream << "no_name_" << object->_name_counter;
499 object->_name_counter++;
500 new_job->setName(name_stream.str());
503 _jobs_map::iterator _jobs_it_name = object->_jobs.find(new_job->getName());
504 if (_jobs_it_name != object->_jobs.end())
506 std::ostringstream name_stream;
507 name_stream << new_job->getName() << "_" << object->_name_counter;
508 object->_name_counter++;
509 new_job->setName(name_stream.str());
512 object->_jobs[new_job->getName()] = new_job;
513 if (object->_observer)
514 object->_observer->sendEvent("add_job", "Ok", new_job->getName(), "");
518 object->_thread_mutex_jobs_map.unlock();
522 BL::JobsManager::launcher_event_remove_job(const std::string & data)
525 std::istringstream job_number_stream(data);
526 if (job_number_stream >> job_number)
528 BL::JobsManager::thread_info_new_job * ti = new thread_info_new_job();
529 ti->object_ptr = this;
530 ti->job_number = job_number;
531 omni_thread::create(BL::JobsManager::launcher_event_remove_job_thread, ti);
536 BL::JobsManager::launcher_event_remove_job_thread(void * object_ptr)
538 DEBTRACE("Start of BL::JobsManager::launcher_event_remove_job_thread");
539 BL::JobsManager::thread_info_new_job * ti = reinterpret_cast<BL::JobsManager::thread_info_new_job*>(object_ptr);
540 BL::JobsManager * object = ti->object_ptr;
541 int job_number = ti->job_number;
543 object->_thread_mutex_jobs_map.lock();
545 _jobs_map::iterator jobs_it;
546 jobs_it = object->_jobs.begin();
547 for(;jobs_it != object->_jobs.end();jobs_it++)
549 BL::Job * job = jobs_it->second;
550 if (job->getSalomeLauncherId() == job_number)
552 job->setSalomeLauncherId(-1);
553 if (object->_observer)
554 object->_observer->sendEvent("to_remove_job", "Ok", job->getName(), "");
558 object->_thread_mutex_jobs_map.unlock();