1 // Copyright (C) 2009 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"
22 BL::JobsManager::JobsManager(BL::SALOMEServices * salome_services)
24 DEBTRACE("Creating BL::JobsManager");
25 BL_ASSERT(salome_services);
26 _salome_services = salome_services;
30 BL::JobsManager::~JobsManager()
32 DEBTRACE("Destroying BL::JobsManager");
35 _jobs_it = _jobs.begin();
36 for(;_jobs_it != _jobs.end();_jobs_it++)
37 delete _jobs_it->second;
41 BL::JobsManager::setObserver(BL::Observer * observer)
48 BL::JobsManager::addNewJob(const std::string & name)
50 DEBTRACE("addNewJob BL::JobsManager");
52 BL::Job * new_job = NULL;
54 _jobs_it = _jobs.find(name);
55 if (_jobs_it == _jobs.end())
57 new_job = new BL::Job(name);
59 // Ajout dans la liste
60 _jobs[name] = new_job;
63 DEBTRACE("addNewJob Error !!!! Job already exist: " << name);
69 BL::JobsManager::removeJob(const std::string & name)
71 DEBTRACE("removeJob BL::JobsManager");
72 _jobs_it = _jobs.find(name);
73 if (_jobs_it != _jobs.end())
75 std::string result = "";
76 if (_jobs_it->second->getSalomeLauncherId() != -1)
77 result = _salome_services->delete_job(_jobs_it->second);
79 delete _jobs_it->second;
80 _jobs.erase(_jobs_it->first);
84 _observer->sendEvent("delete_job", "Error", name, result);
86 _observer->sendEvent("delete_job", "Ok", name, "");
89 DEBTRACE("removeJob Error !!!! Job does not exist: " << name);
93 BL::JobsManager::getJob(const std::string & name)
95 DEBTRACE("getJob BL::JobsManager called");
99 std::map<std::string, BL::Job *> &
100 BL::JobsManager::getJobs()
106 BL::JobsManager::job_already_exist(const std::string & name)
108 _jobs_it = _jobs.find(name);
110 if (_jobs_it == _jobs.end())
118 BL::JobsManager::start_job(const std::string & name)
120 DEBTRACE("BL::JobsManager::start_job called for job: " << name);
123 _jobs_it = _jobs.find(name);
124 if (_jobs_it == _jobs.end())
126 DEBTRACE("BL::JobsManager::start_job job unknown: " << name);
131 _thread_mutex.lock();
132 BL::Job * job = _jobs_it->second;
133 // Check Job Exec State - multithread protection
134 if (job->getThreadState() == BL::Job::NOTHING)
136 // Prepare Info for thread
137 BL::JobsManager::thread_info * ti = new thread_info();
138 ti->object_ptr = this;
140 job->setState(BL::Job::IN_PROCESS);
141 job->setThreadState(BL::Job::STARTING);
142 omni_thread::create(BL::JobsManager::starting_job_thread, ti);
146 DEBTRACE("BL::JobsManager::start_job nothin to do, job already starting, job name: " << name);
148 _thread_mutex.unlock();
153 BL::JobsManager::starting_job_thread(void * object_ptr)
155 DEBTRACE("starting_job_thread BL::JobsManager called");
156 BL::JobsManager::thread_info * ti = reinterpret_cast<BL::JobsManager::thread_info*>(object_ptr);
157 BL::JobsManager * object = ti->object_ptr;
158 std::string job_name = ti->job_name;
159 BL::Job * job = object->getJob(job_name);
161 std::string result = object->_salome_services->start_job(job);
163 object->_thread_mutex.lock();
167 if (object->_observer)
168 object->_observer->sendEvent("start_job", "Ok", job_name, "");
169 job->setState(BL::Job::QUEUED);
170 job->setThreadState(BL::Job::NOTHING);
174 if (object->_observer)
175 object->_observer->sendEvent("start_job", "Error", job_name, result);
176 job->setState(BL::Job::ERROR);
177 job->setThreadState(BL::Job::NOTHING);
179 object->_thread_mutex.unlock();
183 BL::JobsManager::refresh_jobs()
185 DEBTRACE("refresh_jobs BL::JobsManager called");
187 omni_thread::create(BL::JobsManager::refresh_job, this);
191 BL::JobsManager::refresh_job(void * object_ptr)
193 DEBTRACE("refresh_job BL::JobsManager called");
194 BL::JobsManager * object = reinterpret_cast<BL::JobsManager*>(object_ptr);
196 //iterate on all jobs
197 _jobs_map::iterator jobs_it;
198 jobs_it = object->_jobs.begin();
199 for(;jobs_it != object->_jobs.end();jobs_it++)
201 BL::Job * job = jobs_it->second;
202 if (job->getSalomeLauncherId() != -1)
204 object->_thread_mutex.lock();
205 if (job->getThreadState() == BL::Job::NOTHING)
207 BL::Job::State job_state = job->getState();
208 if (job_state != BL::Job::FINISHED or job_state != BL::Job::ERROR)
210 std::string result = object->_salome_services->refresh_job(job);
211 if (result == "QUEUED")
213 if (job_state != BL::Job::QUEUED)
215 job->setState(BL::Job::QUEUED);
216 if (object->_observer)
217 object->_observer->sendEvent("refresh_job", "Ok", job->getName(), "new state");
220 else if (result == "IN_PROCESS")
222 if (job_state != BL::Job::IN_PROCESS)
224 job->setState(BL::Job::IN_PROCESS);
225 if (object->_observer)
226 object->_observer->sendEvent("refresh_job", "Ok", job->getName(), "new state");
229 else if (result == "RUNNING")
231 if (job_state != BL::Job::RUNNING)
233 job->setState(BL::Job::RUNNING);
234 if (object->_observer)
235 object->_observer->sendEvent("refresh_job", "Ok", job->getName(), "new state");
238 else if (result == "PAUSED")
240 if (job_state != BL::Job::PAUSED)
242 job->setState(BL::Job::PAUSED);
243 if (object->_observer)
244 object->_observer->sendEvent("refresh_job", "Ok", job->getName(), "new state");
247 else if (result == "FINISHED")
249 job->setState(BL::Job::FINISHED);
250 if (object->_observer)
251 object->_observer->sendEvent("refresh_job", "Ok", job->getName(), "new state");
253 else if (result == "ERROR")
255 job->setState(BL::Job::ERROR);
256 if (object->_observer)
257 object->_observer->sendEvent("refresh_job", "Ok", job->getName(), "new state");
261 // Error using launcher...
262 if (object->_observer)
263 object->_observer->sendEvent("refresh_job", "Error", job->getName(), result);
267 object->_thread_mutex.unlock();
273 BL::JobsManager::get_results_job(const std::string & name)
275 DEBTRACE("get_results_job BL::JobsManager called");
278 _jobs_it = _jobs.find(name);
279 if (_jobs_it == _jobs.end())
281 DEBTRACE("BL::JobsManager::get_results_job job unknown: " << name);
286 BL::Job * job = _jobs_it->second;
287 if (job->getState() == BL::Job::FINISHED)
289 // Prepare Info for thread
290 BL::JobsManager::thread_info * ti = new thread_info();
291 ti->object_ptr = this;
293 omni_thread::create(BL::JobsManager::get_results_job_thread, ti);
297 DEBTRACE("BL::JobsManager::get_results_job job bad job state !");
304 BL::JobsManager::get_results_job_thread(void * object_ptr)
306 DEBTRACE("get_results_job_thread BL::JobsManager called");
307 BL::JobsManager::thread_info * ti = reinterpret_cast<BL::JobsManager::thread_info*>(object_ptr);
308 BL::JobsManager * object = ti->object_ptr;
309 std::string job_name = ti->job_name;
310 BL::Job * job = object->getJob(job_name);
312 object->_thread_mutex_results.lock();
313 std::string result = object->_salome_services->get_results_job(job);
318 if (object->_observer)
319 object->_observer->sendEvent("get_results_job", "Ok", job_name, "");
323 if (object->_observer)
324 object->_observer->sendEvent("get_results_job", "Error", job_name, result);
326 object->_thread_mutex_results.unlock();