Mercurial > hg > orthanc
annotate Core/JobsEngine/JobsRegistry.cpp @ 2919:2ca9cd064b15
PamReader::ReadFromMemory
| author | Sebastien Jodogne <s.jodogne@gmail.com> |
|---|---|
| date | Tue, 06 Nov 2018 15:41:21 +0100 |
| parents | 251614c2edac |
| children | 577786f59252 |
| rev | line source |
|---|---|
| 2569 | 1 /** |
| 2 * Orthanc - A Lightweight, RESTful DICOM Store | |
| 3 * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics | |
| 4 * Department, University Hospital of Liege, Belgium | |
| 5 * Copyright (C) 2017-2018 Osimis S.A., Belgium | |
| 6 * | |
| 7 * This program is free software: you can redistribute it and/or | |
| 8 * modify it under the terms of the GNU General Public License as | |
| 9 * published by the Free Software Foundation, either version 3 of the | |
| 10 * License, or (at your option) any later version. | |
| 11 * | |
| 12 * In addition, as a special exception, the copyright holders of this | |
| 13 * program give permission to link the code of its release with the | |
| 14 * OpenSSL project's "OpenSSL" library (or with modified versions of it | |
| 15 * that use the same license as the "OpenSSL" library), and distribute | |
| 16 * the linked executables. You must obey the GNU General Public License | |
| 17 * in all respects for all of the code used other than "OpenSSL". If you | |
| 18 * modify file(s) with this exception, you may extend this exception to | |
| 19 * your version of the file(s), but you are not obligated to do so. If | |
| 20 * you do not wish to do so, delete this exception statement from your | |
| 21 * version. If you delete this exception statement from all source files | |
| 22 * in the program, then also delete it here. | |
| 23 * | |
| 24 * This program is distributed in the hope that it will be useful, but | |
| 25 * WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 26 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| 27 * General Public License for more details. | |
| 28 * | |
| 29 * You should have received a copy of the GNU General Public License | |
| 30 * along with this program. If not, see <http://www.gnu.org/licenses/>. | |
| 31 **/ | |
| 32 | |
| 33 | |
| 34 #include "../PrecompiledHeaders.h" | |
| 35 #include "JobsRegistry.h" | |
| 36 | |
| 37 #include "../Logging.h" | |
| 38 #include "../OrthancException.h" | |
| 39 #include "../Toolbox.h" | |
|
2656
a6d3e45eeff5
SerializationToolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2655
diff
changeset
|
40 #include "../SerializationToolbox.h" |
| 2569 | 41 |
| 42 namespace Orthanc | |
| 43 { | |
|
2667
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
44 static const char* STATE = "State"; |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
45 static const char* TYPE = "Type"; |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
46 static const char* PRIORITY = "Priority"; |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
47 static const char* JOB = "Job"; |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
48 static const char* JOBS = "Jobs"; |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
49 static const char* JOBS_REGISTRY = "JobsRegistry"; |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
50 static const char* MAX_COMPLETED_JOBS = "MaxCompletedJobs"; |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
51 static const char* CREATION_TIME = "CreationTime"; |
|
2669
eaf10085ffa1
no passwords in public content of jobs
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2668
diff
changeset
|
52 static const char* LAST_CHANGE_TIME = "LastChangeTime"; |
|
2667
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
53 static const char* RUNTIME = "Runtime"; |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
54 |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
55 |
| 2569 | 56 class JobsRegistry::JobHandler : public boost::noncopyable |
| 57 { | |
| 58 private: | |
| 59 std::string id_; | |
| 60 JobState state_; | |
|
2648
e1893d31652a
serialization of JobHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2630
diff
changeset
|
61 std::string jobType_; |
| 2569 | 62 std::auto_ptr<IJob> job_; |
| 63 int priority_; // "+inf()" means highest priority | |
| 64 boost::posix_time::ptime creationTime_; | |
| 65 boost::posix_time::ptime lastStateChangeTime_; | |
| 66 boost::posix_time::time_duration runtime_; | |
| 67 boost::posix_time::ptime retryTime_; | |
| 68 bool pauseScheduled_; | |
|
2581
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
69 bool cancelScheduled_; |
| 2569 | 70 JobStatus lastStatus_; |
| 71 | |
| 72 void Touch() | |
| 73 { | |
| 74 const boost::posix_time::ptime now = boost::posix_time::microsec_clock::universal_time(); | |
| 75 | |
| 76 if (state_ == JobState_Running) | |
| 77 { | |
| 78 runtime_ += (now - lastStateChangeTime_); | |
| 79 } | |
| 80 | |
| 81 lastStateChangeTime_ = now; | |
| 82 } | |
| 83 | |
| 84 void SetStateInternal(JobState state) | |
| 85 { | |
| 86 state_ = state; | |
| 87 pauseScheduled_ = false; | |
|
2581
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
88 cancelScheduled_ = false; |
| 2569 | 89 Touch(); |
| 90 } | |
| 91 | |
| 92 public: | |
| 93 JobHandler(IJob* job, | |
| 94 int priority) : | |
| 95 id_(Toolbox::GenerateUuid()), | |
| 96 state_(JobState_Pending), | |
| 97 job_(job), | |
| 98 priority_(priority), | |
| 99 creationTime_(boost::posix_time::microsec_clock::universal_time()), | |
| 100 lastStateChangeTime_(creationTime_), | |
| 101 runtime_(boost::posix_time::milliseconds(0)), | |
| 102 retryTime_(creationTime_), | |
|
2581
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
103 pauseScheduled_(false), |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
104 cancelScheduled_(false) |
| 2569 | 105 { |
| 106 if (job == NULL) | |
| 107 { | |
| 108 throw OrthancException(ErrorCode_NullPointer); | |
| 109 } | |
| 110 | |
|
2648
e1893d31652a
serialization of JobHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2630
diff
changeset
|
111 job->GetJobType(jobType_); |
|
2668
d26dd081df97
saving jobs engine on exit
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2667
diff
changeset
|
112 job->Start(); |
|
2630
00327e989458
creating archives/medias is now a job
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2620
diff
changeset
|
113 |
|
2648
e1893d31652a
serialization of JobHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2630
diff
changeset
|
114 lastStatus_ = JobStatus(ErrorCode_Success, *job_); |
| 2569 | 115 } |
| 116 | |
| 117 const std::string& GetId() const | |
| 118 { | |
| 119 return id_; | |
| 120 } | |
| 121 | |
| 122 IJob& GetJob() const | |
| 123 { | |
| 124 assert(job_.get() != NULL); | |
| 125 return *job_; | |
| 126 } | |
| 127 | |
| 128 void SetPriority(int priority) | |
| 129 { | |
| 130 priority_ = priority; | |
| 131 } | |
| 132 | |
| 133 int GetPriority() const | |
| 134 { | |
| 135 return priority_; | |
| 136 } | |
| 137 | |
| 138 JobState GetState() const | |
| 139 { | |
| 140 return state_; | |
| 141 } | |
| 142 | |
| 143 void SetState(JobState state) | |
| 144 { | |
| 145 if (state == JobState_Retry) | |
| 146 { | |
| 147 // Use "SetRetryState()" | |
| 148 throw OrthancException(ErrorCode_BadSequenceOfCalls); | |
| 149 } | |
| 150 else | |
| 151 { | |
| 152 SetStateInternal(state); | |
| 153 } | |
| 154 } | |
| 155 | |
| 156 void SetRetryState(unsigned int timeout) | |
| 157 { | |
| 158 if (state_ == JobState_Running) | |
| 159 { | |
| 160 SetStateInternal(JobState_Retry); | |
| 161 retryTime_ = (boost::posix_time::microsec_clock::universal_time() + | |
| 162 boost::posix_time::milliseconds(timeout)); | |
| 163 } | |
| 164 else | |
| 165 { | |
| 166 // Only valid for running jobs | |
| 167 throw OrthancException(ErrorCode_BadSequenceOfCalls); | |
| 168 } | |
| 169 } | |
| 170 | |
| 171 void SchedulePause() | |
| 172 { | |
| 173 if (state_ == JobState_Running) | |
| 174 { | |
| 175 pauseScheduled_ = true; | |
| 176 } | |
| 177 else | |
| 178 { | |
| 179 // Only valid for running jobs | |
| 180 throw OrthancException(ErrorCode_BadSequenceOfCalls); | |
| 181 } | |
| 182 } | |
| 183 | |
|
2581
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
184 void ScheduleCancel() |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
185 { |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
186 if (state_ == JobState_Running) |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
187 { |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
188 cancelScheduled_ = true; |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
189 } |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
190 else |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
191 { |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
192 // Only valid for running jobs |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
193 throw OrthancException(ErrorCode_BadSequenceOfCalls); |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
194 } |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
195 } |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
196 |
| 2569 | 197 bool IsPauseScheduled() |
| 198 { | |
| 199 return pauseScheduled_; | |
| 200 } | |
| 201 | |
|
2581
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
202 bool IsCancelScheduled() |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
203 { |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
204 return cancelScheduled_; |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
205 } |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
206 |
| 2569 | 207 bool IsRetryReady(const boost::posix_time::ptime& now) const |
| 208 { | |
| 209 if (state_ != JobState_Retry) | |
| 210 { | |
| 211 throw OrthancException(ErrorCode_BadSequenceOfCalls); | |
| 212 } | |
| 213 else | |
| 214 { | |
| 215 return retryTime_ <= now; | |
| 216 } | |
| 217 } | |
| 218 | |
| 219 const boost::posix_time::ptime& GetCreationTime() const | |
| 220 { | |
| 221 return creationTime_; | |
| 222 } | |
| 223 | |
| 224 const boost::posix_time::ptime& GetLastStateChangeTime() const | |
| 225 { | |
| 226 return lastStateChangeTime_; | |
| 227 } | |
| 228 | |
|
2669
eaf10085ffa1
no passwords in public content of jobs
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2668
diff
changeset
|
229 void SetLastStateChangeTime(const boost::posix_time::ptime& time) |
|
eaf10085ffa1
no passwords in public content of jobs
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2668
diff
changeset
|
230 { |
|
eaf10085ffa1
no passwords in public content of jobs
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2668
diff
changeset
|
231 lastStateChangeTime_ = time; |
|
eaf10085ffa1
no passwords in public content of jobs
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2668
diff
changeset
|
232 } |
|
eaf10085ffa1
no passwords in public content of jobs
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2668
diff
changeset
|
233 |
| 2569 | 234 const boost::posix_time::time_duration& GetRuntime() const |
| 235 { | |
| 236 return runtime_; | |
| 237 } | |
| 238 | |
| 239 const JobStatus& GetLastStatus() const | |
| 240 { | |
| 241 return lastStatus_; | |
| 242 } | |
| 243 | |
| 244 void SetLastStatus(const JobStatus& status) | |
| 245 { | |
| 246 lastStatus_ = status; | |
| 247 Touch(); | |
| 248 } | |
|
2581
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
249 |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
250 void SetLastErrorCode(ErrorCode code) |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
251 { |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
252 lastStatus_.SetErrorCode(code); |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
253 } |
|
2648
e1893d31652a
serialization of JobHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2630
diff
changeset
|
254 |
|
2663
228e2783ce83
some jobs might not be serializable
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2656
diff
changeset
|
255 bool Serialize(Json::Value& target) const |
|
2648
e1893d31652a
serialization of JobHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2630
diff
changeset
|
256 { |
| 2655 | 257 target = Json::objectValue; |
|
2663
228e2783ce83
some jobs might not be serializable
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2656
diff
changeset
|
258 |
|
228e2783ce83
some jobs might not be serializable
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2656
diff
changeset
|
259 bool ok; |
|
2648
e1893d31652a
serialization of JobHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2630
diff
changeset
|
260 |
|
e1893d31652a
serialization of JobHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2630
diff
changeset
|
261 if (state_ == JobState_Running) |
|
e1893d31652a
serialization of JobHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2630
diff
changeset
|
262 { |
|
e1893d31652a
serialization of JobHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2630
diff
changeset
|
263 // WARNING: Cannot directly access the "job_" member, as long |
|
e1893d31652a
serialization of JobHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2630
diff
changeset
|
264 // as a "RunningJob" instance is running. We do not use a |
|
e1893d31652a
serialization of JobHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2630
diff
changeset
|
265 // mutex at the "JobHandler" level, as serialization would be |
|
e1893d31652a
serialization of JobHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2630
diff
changeset
|
266 // blocked while a step in the job is running. Instead, we |
|
e1893d31652a
serialization of JobHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2630
diff
changeset
|
267 // save a snapshot of the serialized job. |
|
2663
228e2783ce83
some jobs might not be serializable
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2656
diff
changeset
|
268 |
|
228e2783ce83
some jobs might not be serializable
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2656
diff
changeset
|
269 if (lastStatus_.HasSerialized()) |
|
228e2783ce83
some jobs might not be serializable
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2656
diff
changeset
|
270 { |
|
2667
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
271 target[JOB] = lastStatus_.GetSerialized(); |
|
2663
228e2783ce83
some jobs might not be serializable
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2656
diff
changeset
|
272 ok = true; |
|
228e2783ce83
some jobs might not be serializable
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2656
diff
changeset
|
273 } |
|
228e2783ce83
some jobs might not be serializable
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2656
diff
changeset
|
274 else |
|
228e2783ce83
some jobs might not be serializable
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2656
diff
changeset
|
275 { |
|
228e2783ce83
some jobs might not be serializable
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2656
diff
changeset
|
276 ok = false; |
|
228e2783ce83
some jobs might not be serializable
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2656
diff
changeset
|
277 } |
|
228e2783ce83
some jobs might not be serializable
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2656
diff
changeset
|
278 } |
|
228e2783ce83
some jobs might not be serializable
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2656
diff
changeset
|
279 else |
|
228e2783ce83
some jobs might not be serializable
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2656
diff
changeset
|
280 { |
|
2667
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
281 ok = job_->Serialize(target[JOB]); |
|
2663
228e2783ce83
some jobs might not be serializable
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2656
diff
changeset
|
282 } |
|
228e2783ce83
some jobs might not be serializable
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2656
diff
changeset
|
283 |
|
228e2783ce83
some jobs might not be serializable
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2656
diff
changeset
|
284 if (ok) |
|
228e2783ce83
some jobs might not be serializable
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2656
diff
changeset
|
285 { |
|
2667
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
286 target[STATE] = EnumerationToString(state_); |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
287 target[PRIORITY] = priority_; |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
288 target[CREATION_TIME] = boost::posix_time::to_iso_string(creationTime_); |
|
2669
eaf10085ffa1
no passwords in public content of jobs
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2668
diff
changeset
|
289 target[LAST_CHANGE_TIME] = boost::posix_time::to_iso_string(lastStateChangeTime_); |
|
2667
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
290 target[RUNTIME] = static_cast<unsigned int>(runtime_.total_milliseconds()); |
|
2663
228e2783ce83
some jobs might not be serializable
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2656
diff
changeset
|
291 return true; |
|
2648
e1893d31652a
serialization of JobHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2630
diff
changeset
|
292 } |
|
e1893d31652a
serialization of JobHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2630
diff
changeset
|
293 else |
|
e1893d31652a
serialization of JobHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2630
diff
changeset
|
294 { |
|
2673
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
295 LOG(INFO) << "Job backup is not supported for job of type: " << jobType_; |
|
2663
228e2783ce83
some jobs might not be serializable
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2656
diff
changeset
|
296 return false; |
|
2648
e1893d31652a
serialization of JobHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2630
diff
changeset
|
297 } |
|
e1893d31652a
serialization of JobHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2630
diff
changeset
|
298 } |
|
e1893d31652a
serialization of JobHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2630
diff
changeset
|
299 |
|
e1893d31652a
serialization of JobHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2630
diff
changeset
|
300 JobHandler(IJobUnserializer& unserializer, |
|
2670
c5646f766b3e
serialize jobs as an object
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2669
diff
changeset
|
301 const Json::Value& serialized, |
|
c5646f766b3e
serialize jobs as an object
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2669
diff
changeset
|
302 const std::string& id) : |
|
c5646f766b3e
serialize jobs as an object
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2669
diff
changeset
|
303 id_(id), |
|
2648
e1893d31652a
serialization of JobHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2630
diff
changeset
|
304 pauseScheduled_(false), |
|
e1893d31652a
serialization of JobHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2630
diff
changeset
|
305 cancelScheduled_(false) |
|
e1893d31652a
serialization of JobHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2630
diff
changeset
|
306 { |
|
2667
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
307 state_ = StringToJobState(SerializationToolbox::ReadString(serialized, STATE)); |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
308 priority_ = SerializationToolbox::ReadInteger(serialized, PRIORITY); |
|
2648
e1893d31652a
serialization of JobHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2630
diff
changeset
|
309 creationTime_ = boost::posix_time::from_iso_string |
|
2667
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
310 (SerializationToolbox::ReadString(serialized, CREATION_TIME)); |
|
2669
eaf10085ffa1
no passwords in public content of jobs
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2668
diff
changeset
|
311 lastStateChangeTime_ = boost::posix_time::from_iso_string |
|
eaf10085ffa1
no passwords in public content of jobs
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2668
diff
changeset
|
312 (SerializationToolbox::ReadString(serialized, LAST_CHANGE_TIME)); |
|
2667
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
313 runtime_ = boost::posix_time::milliseconds |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
314 (SerializationToolbox::ReadInteger(serialized, RUNTIME)); |
|
2648
e1893d31652a
serialization of JobHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2630
diff
changeset
|
315 |
|
e1893d31652a
serialization of JobHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2630
diff
changeset
|
316 retryTime_ = creationTime_; |
|
e1893d31652a
serialization of JobHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2630
diff
changeset
|
317 |
|
2667
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
318 job_.reset(unserializer.UnserializeJob(serialized[JOB])); |
| 2652 | 319 job_->GetJobType(jobType_); |
| 320 job_->Start(); | |
|
2648
e1893d31652a
serialization of JobHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2630
diff
changeset
|
321 |
|
e1893d31652a
serialization of JobHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2630
diff
changeset
|
322 lastStatus_ = JobStatus(ErrorCode_Success, *job_); |
|
e1893d31652a
serialization of JobHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2630
diff
changeset
|
323 } |
| 2569 | 324 }; |
| 325 | |
| 326 | |
| 327 bool JobsRegistry::PriorityComparator::operator() (JobHandler*& a, | |
| 328 JobHandler*& b) const | |
| 329 { | |
| 330 return a->GetPriority() < b->GetPriority(); | |
| 331 } | |
| 332 | |
| 333 | |
| 334 #if defined(NDEBUG) | |
| 335 void JobsRegistry::CheckInvariants() const | |
| 336 { | |
| 337 } | |
| 338 | |
| 339 #else | |
| 340 bool JobsRegistry::IsPendingJob(const JobHandler& job) const | |
| 341 { | |
| 342 PendingJobs copy = pendingJobs_; | |
| 343 while (!copy.empty()) | |
| 344 { | |
| 345 if (copy.top() == &job) | |
| 346 { | |
| 347 return true; | |
| 348 } | |
| 349 | |
| 350 copy.pop(); | |
| 351 } | |
| 352 | |
| 353 return false; | |
| 354 } | |
| 355 | |
| 356 bool JobsRegistry::IsCompletedJob(JobHandler& job) const | |
| 357 { | |
| 358 for (CompletedJobs::const_iterator it = completedJobs_.begin(); | |
| 359 it != completedJobs_.end(); ++it) | |
| 360 { | |
| 361 if (*it == &job) | |
| 362 { | |
| 363 return true; | |
| 364 } | |
| 365 } | |
| 366 | |
| 367 return false; | |
| 368 } | |
| 369 | |
| 370 bool JobsRegistry::IsRetryJob(JobHandler& job) const | |
| 371 { | |
| 372 return retryJobs_.find(&job) != retryJobs_.end(); | |
| 373 } | |
| 374 | |
| 375 void JobsRegistry::CheckInvariants() const | |
| 376 { | |
| 377 { | |
| 378 PendingJobs copy = pendingJobs_; | |
| 379 while (!copy.empty()) | |
| 380 { | |
| 381 assert(copy.top()->GetState() == JobState_Pending); | |
| 382 copy.pop(); | |
| 383 } | |
| 384 } | |
| 385 | |
| 386 assert(completedJobs_.size() <= maxCompletedJobs_); | |
| 387 | |
| 388 for (CompletedJobs::const_iterator it = completedJobs_.begin(); | |
| 389 it != completedJobs_.end(); ++it) | |
| 390 { | |
| 391 assert((*it)->GetState() == JobState_Success || | |
| 392 (*it)->GetState() == JobState_Failure); | |
| 393 } | |
| 394 | |
| 395 for (RetryJobs::const_iterator it = retryJobs_.begin(); | |
| 396 it != retryJobs_.end(); ++it) | |
| 397 { | |
| 398 assert((*it)->GetState() == JobState_Retry); | |
| 399 } | |
| 400 | |
| 401 for (JobsIndex::const_iterator it = jobsIndex_.begin(); | |
| 402 it != jobsIndex_.end(); ++it) | |
| 403 { | |
| 404 JobHandler& job = *it->second; | |
| 405 | |
| 406 assert(job.GetId() == it->first); | |
| 407 | |
| 408 switch (job.GetState()) | |
| 409 { | |
| 410 case JobState_Pending: | |
| 411 assert(!IsRetryJob(job) && IsPendingJob(job) && !IsCompletedJob(job)); | |
| 412 break; | |
| 413 | |
| 414 case JobState_Success: | |
| 415 case JobState_Failure: | |
| 416 assert(!IsRetryJob(job) && !IsPendingJob(job) && IsCompletedJob(job)); | |
| 417 break; | |
| 418 | |
| 419 case JobState_Retry: | |
| 420 assert(IsRetryJob(job) && !IsPendingJob(job) && !IsCompletedJob(job)); | |
| 421 break; | |
| 422 | |
| 423 case JobState_Running: | |
| 424 case JobState_Paused: | |
| 425 assert(!IsRetryJob(job) && !IsPendingJob(job) && !IsCompletedJob(job)); | |
| 426 break; | |
| 427 | |
| 428 default: | |
| 429 throw OrthancException(ErrorCode_InternalError); | |
| 430 } | |
| 431 } | |
| 432 } | |
| 433 #endif | |
| 434 | |
| 435 | |
| 436 void JobsRegistry::ForgetOldCompletedJobs() | |
| 437 { | |
| 438 if (maxCompletedJobs_ != 0) | |
| 439 { | |
| 440 while (completedJobs_.size() > maxCompletedJobs_) | |
| 441 { | |
| 442 assert(completedJobs_.front() != NULL); | |
| 443 | |
| 444 std::string id = completedJobs_.front()->GetId(); | |
| 445 assert(jobsIndex_.find(id) != jobsIndex_.end()); | |
| 446 | |
| 447 jobsIndex_.erase(id); | |
| 448 delete(completedJobs_.front()); | |
| 449 completedJobs_.pop_front(); | |
| 450 } | |
| 451 } | |
| 452 } | |
| 453 | |
| 454 | |
|
2581
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
455 void JobsRegistry::SetCompletedJob(JobHandler& job, |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
456 bool success) |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
457 { |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
458 job.SetState(success ? JobState_Success : JobState_Failure); |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
459 |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
460 completedJobs_.push_back(&job); |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
461 ForgetOldCompletedJobs(); |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
462 |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
463 someJobComplete_.notify_all(); |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
464 } |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
465 |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
466 |
| 2569 | 467 void JobsRegistry::MarkRunningAsCompleted(JobHandler& job, |
| 468 bool success) | |
| 469 { | |
| 470 LOG(INFO) << "Job has completed with " << (success ? "success" : "failure") | |
| 471 << ": " << job.GetId(); | |
| 472 | |
| 473 CheckInvariants(); | |
|
2581
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
474 |
| 2569 | 475 assert(job.GetState() == JobState_Running); |
|
2581
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
476 SetCompletedJob(job, success); |
|
2570
2e879c796ec7
JobsRegistry::SubmitAndWait(), StoreScuJob
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2569
diff
changeset
|
477 |
|
2673
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
478 if (observer_ != NULL) |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
479 { |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
480 if (success) |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
481 { |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
482 observer_->SignalJobSuccess(job.GetId()); |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
483 } |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
484 else |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
485 { |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
486 observer_->SignalJobFailure(job.GetId()); |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
487 } |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
488 } |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
489 |
| 2569 | 490 CheckInvariants(); |
| 491 } | |
| 492 | |
| 493 | |
| 494 void JobsRegistry::MarkRunningAsRetry(JobHandler& job, | |
| 495 unsigned int timeout) | |
| 496 { | |
| 497 LOG(INFO) << "Job scheduled for retry in " << timeout << "ms: " << job.GetId(); | |
| 498 | |
| 499 CheckInvariants(); | |
| 500 | |
| 501 assert(job.GetState() == JobState_Running && | |
| 502 retryJobs_.find(&job) == retryJobs_.end()); | |
| 503 | |
| 504 retryJobs_.insert(&job); | |
| 505 job.SetRetryState(timeout); | |
| 506 | |
| 507 CheckInvariants(); | |
| 508 } | |
| 509 | |
| 510 | |
| 511 void JobsRegistry::MarkRunningAsPaused(JobHandler& job) | |
| 512 { | |
| 513 LOG(INFO) << "Job paused: " << job.GetId(); | |
| 514 | |
| 515 CheckInvariants(); | |
| 516 assert(job.GetState() == JobState_Running); | |
| 517 | |
| 518 job.SetState(JobState_Paused); | |
| 519 | |
| 520 CheckInvariants(); | |
| 521 } | |
| 522 | |
| 523 | |
|
2570
2e879c796ec7
JobsRegistry::SubmitAndWait(), StoreScuJob
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2569
diff
changeset
|
524 bool JobsRegistry::GetStateInternal(JobState& state, |
|
2e879c796ec7
JobsRegistry::SubmitAndWait(), StoreScuJob
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2569
diff
changeset
|
525 const std::string& id) |
|
2e879c796ec7
JobsRegistry::SubmitAndWait(), StoreScuJob
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2569
diff
changeset
|
526 { |
|
2e879c796ec7
JobsRegistry::SubmitAndWait(), StoreScuJob
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2569
diff
changeset
|
527 CheckInvariants(); |
|
2e879c796ec7
JobsRegistry::SubmitAndWait(), StoreScuJob
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2569
diff
changeset
|
528 |
|
2e879c796ec7
JobsRegistry::SubmitAndWait(), StoreScuJob
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2569
diff
changeset
|
529 JobsIndex::const_iterator it = jobsIndex_.find(id); |
|
2e879c796ec7
JobsRegistry::SubmitAndWait(), StoreScuJob
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2569
diff
changeset
|
530 if (it == jobsIndex_.end()) |
|
2e879c796ec7
JobsRegistry::SubmitAndWait(), StoreScuJob
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2569
diff
changeset
|
531 { |
|
2e879c796ec7
JobsRegistry::SubmitAndWait(), StoreScuJob
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2569
diff
changeset
|
532 return false; |
|
2e879c796ec7
JobsRegistry::SubmitAndWait(), StoreScuJob
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2569
diff
changeset
|
533 } |
|
2e879c796ec7
JobsRegistry::SubmitAndWait(), StoreScuJob
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2569
diff
changeset
|
534 else |
|
2e879c796ec7
JobsRegistry::SubmitAndWait(), StoreScuJob
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2569
diff
changeset
|
535 { |
|
2e879c796ec7
JobsRegistry::SubmitAndWait(), StoreScuJob
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2569
diff
changeset
|
536 state = it->second->GetState(); |
|
2e879c796ec7
JobsRegistry::SubmitAndWait(), StoreScuJob
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2569
diff
changeset
|
537 return true; |
|
2e879c796ec7
JobsRegistry::SubmitAndWait(), StoreScuJob
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2569
diff
changeset
|
538 } |
|
2e879c796ec7
JobsRegistry::SubmitAndWait(), StoreScuJob
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2569
diff
changeset
|
539 } |
|
2e879c796ec7
JobsRegistry::SubmitAndWait(), StoreScuJob
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2569
diff
changeset
|
540 |
|
2e879c796ec7
JobsRegistry::SubmitAndWait(), StoreScuJob
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2569
diff
changeset
|
541 |
| 2569 | 542 JobsRegistry::~JobsRegistry() |
| 543 { | |
| 544 for (JobsIndex::iterator it = jobsIndex_.begin(); it != jobsIndex_.end(); ++it) | |
| 545 { | |
| 546 assert(it->second != NULL); | |
| 547 delete it->second; | |
| 548 } | |
| 549 } | |
| 550 | |
| 551 | |
|
2620
1232922c8793
speeding up shutdown if Lua script is in trailing phase
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2600
diff
changeset
|
552 void JobsRegistry::SetMaxCompletedJobs(size_t n) |
| 2569 | 553 { |
| 554 boost::mutex::scoped_lock lock(mutex_); | |
| 555 CheckInvariants(); | |
| 556 | |
|
2620
1232922c8793
speeding up shutdown if Lua script is in trailing phase
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2600
diff
changeset
|
557 LOG(INFO) << "The size of the history of the jobs engine is set to: " << n << " job(s)"; |
|
1232922c8793
speeding up shutdown if Lua script is in trailing phase
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2600
diff
changeset
|
558 |
|
1232922c8793
speeding up shutdown if Lua script is in trailing phase
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2600
diff
changeset
|
559 maxCompletedJobs_ = n; |
| 2569 | 560 ForgetOldCompletedJobs(); |
| 561 | |
| 562 CheckInvariants(); | |
| 563 } | |
| 564 | |
| 565 | |
| 566 void JobsRegistry::ListJobs(std::set<std::string>& target) | |
| 567 { | |
| 568 boost::mutex::scoped_lock lock(mutex_); | |
| 569 CheckInvariants(); | |
| 570 | |
| 571 for (JobsIndex::const_iterator it = jobsIndex_.begin(); | |
| 572 it != jobsIndex_.end(); ++it) | |
| 573 { | |
| 574 target.insert(it->first); | |
| 575 } | |
| 576 } | |
| 577 | |
| 578 | |
| 579 bool JobsRegistry::GetJobInfo(JobInfo& target, | |
| 580 const std::string& id) | |
| 581 { | |
| 582 boost::mutex::scoped_lock lock(mutex_); | |
| 583 CheckInvariants(); | |
| 584 | |
| 585 JobsIndex::const_iterator found = jobsIndex_.find(id); | |
| 586 | |
| 587 if (found == jobsIndex_.end()) | |
| 588 { | |
| 589 return false; | |
| 590 } | |
| 591 else | |
| 592 { | |
| 593 const JobHandler& handler = *found->second; | |
| 594 target = JobInfo(handler.GetId(), | |
| 595 handler.GetPriority(), | |
| 596 handler.GetState(), | |
| 597 handler.GetLastStatus(), | |
| 598 handler.GetCreationTime(), | |
| 599 handler.GetLastStateChangeTime(), | |
| 600 handler.GetRuntime()); | |
| 601 return true; | |
| 602 } | |
| 603 } | |
| 604 | |
| 605 | |
|
2667
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
606 void JobsRegistry::SubmitInternal(std::string& id, |
|
2669
eaf10085ffa1
no passwords in public content of jobs
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2668
diff
changeset
|
607 JobHandler* handlerRaw, |
|
eaf10085ffa1
no passwords in public content of jobs
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2668
diff
changeset
|
608 bool keepLastChangeTime) |
|
2648
e1893d31652a
serialization of JobHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2630
diff
changeset
|
609 { |
|
2668
d26dd081df97
saving jobs engine on exit
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2667
diff
changeset
|
610 if (handlerRaw == NULL) |
|
d26dd081df97
saving jobs engine on exit
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2667
diff
changeset
|
611 { |
|
d26dd081df97
saving jobs engine on exit
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2667
diff
changeset
|
612 throw OrthancException(ErrorCode_NullPointer); |
|
d26dd081df97
saving jobs engine on exit
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2667
diff
changeset
|
613 } |
|
d26dd081df97
saving jobs engine on exit
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2667
diff
changeset
|
614 |
|
2667
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
615 std::auto_ptr<JobHandler> handler(handlerRaw); |
| 2569 | 616 |
|
2669
eaf10085ffa1
no passwords in public content of jobs
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2668
diff
changeset
|
617 boost::posix_time::ptime lastChangeTime = handler->GetLastStateChangeTime(); |
|
eaf10085ffa1
no passwords in public content of jobs
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2668
diff
changeset
|
618 |
|
2673
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
619 { |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
620 boost::mutex::scoped_lock lock(mutex_); |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
621 CheckInvariants(); |
| 2569 | 622 |
|
2673
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
623 id = handler->GetId(); |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
624 int priority = handler->GetPriority(); |
| 2569 | 625 |
|
2673
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
626 switch (handler->GetState()) |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
627 { |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
628 case JobState_Pending: |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
629 case JobState_Retry: |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
630 case JobState_Running: |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
631 handler->SetState(JobState_Pending); |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
632 pendingJobs_.push(handler.get()); |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
633 pendingJobAvailable_.notify_one(); |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
634 break; |
|
2668
d26dd081df97
saving jobs engine on exit
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2667
diff
changeset
|
635 |
|
2673
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
636 case JobState_Success: |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
637 SetCompletedJob(*handler, true); |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
638 break; |
|
2668
d26dd081df97
saving jobs engine on exit
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2667
diff
changeset
|
639 |
|
2673
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
640 case JobState_Failure: |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
641 SetCompletedJob(*handler, false); |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
642 break; |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
643 |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
644 case JobState_Paused: |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
645 break; |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
646 |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
647 default: |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
648 LOG(ERROR) << "A job should not be loaded from state: " |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
649 << EnumerationToString(handler->GetState()); |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
650 throw OrthancException(ErrorCode_InternalError); |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
651 } |
|
2668
d26dd081df97
saving jobs engine on exit
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2667
diff
changeset
|
652 |
|
2673
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
653 if (keepLastChangeTime) |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
654 { |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
655 handler->SetLastStateChangeTime(lastChangeTime); |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
656 } |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
657 |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
658 jobsIndex_.insert(std::make_pair(id, handler.release())); |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
659 |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
660 LOG(INFO) << "New job submitted with priority " << priority << ": " << id; |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
661 |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
662 if (observer_ != NULL) |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
663 { |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
664 observer_->SignalJobSubmitted(id); |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
665 } |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
666 |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
667 CheckInvariants(); |
|
2668
d26dd081df97
saving jobs engine on exit
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2667
diff
changeset
|
668 } |
| 2569 | 669 } |
| 670 | |
| 671 | |
|
2667
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
672 void JobsRegistry::Submit(std::string& id, |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
673 IJob* job, // Takes ownership |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
674 int priority) |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
675 { |
|
2669
eaf10085ffa1
no passwords in public content of jobs
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2668
diff
changeset
|
676 SubmitInternal(id, new JobHandler(job, priority), false); |
|
2667
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
677 } |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
678 |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
679 |
| 2569 | 680 void JobsRegistry::Submit(IJob* job, // Takes ownership |
| 681 int priority) | |
| 682 { | |
| 683 std::string id; | |
|
2669
eaf10085ffa1
no passwords in public content of jobs
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2668
diff
changeset
|
684 SubmitInternal(id, new JobHandler(job, priority), false); |
| 2569 | 685 } |
| 686 | |
| 687 | |
| 2867 | 688 bool JobsRegistry::SubmitAndWait(Json::Value& successContent, |
| 689 IJob* job, // Takes ownership | |
|
2570
2e879c796ec7
JobsRegistry::SubmitAndWait(), StoreScuJob
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2569
diff
changeset
|
690 int priority) |
|
2e879c796ec7
JobsRegistry::SubmitAndWait(), StoreScuJob
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2569
diff
changeset
|
691 { |
|
2e879c796ec7
JobsRegistry::SubmitAndWait(), StoreScuJob
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2569
diff
changeset
|
692 std::string id; |
|
2e879c796ec7
JobsRegistry::SubmitAndWait(), StoreScuJob
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2569
diff
changeset
|
693 Submit(id, job, priority); |
|
2e879c796ec7
JobsRegistry::SubmitAndWait(), StoreScuJob
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2569
diff
changeset
|
694 |
| 2867 | 695 JobState state = JobState_Pending; // Dummy initialization |
|
2570
2e879c796ec7
JobsRegistry::SubmitAndWait(), StoreScuJob
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2569
diff
changeset
|
696 |
|
2e879c796ec7
JobsRegistry::SubmitAndWait(), StoreScuJob
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2569
diff
changeset
|
697 { |
|
2e879c796ec7
JobsRegistry::SubmitAndWait(), StoreScuJob
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2569
diff
changeset
|
698 boost::mutex::scoped_lock lock(mutex_); |
|
2e879c796ec7
JobsRegistry::SubmitAndWait(), StoreScuJob
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2569
diff
changeset
|
699 |
| 2867 | 700 for (;;) |
|
2570
2e879c796ec7
JobsRegistry::SubmitAndWait(), StoreScuJob
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2569
diff
changeset
|
701 { |
| 2867 | 702 if (!GetStateInternal(state, id)) |
| 703 { | |
| 704 // Job has finished and has been lost (should not happen) | |
| 705 state = JobState_Failure; | |
| 706 break; | |
| 707 } | |
| 708 else if (state == JobState_Failure) | |
| 709 { | |
| 710 // Failure | |
| 711 break; | |
| 712 } | |
| 713 else if (state == JobState_Success) | |
| 714 { | |
| 715 // Success, try and retrieve the status of the job | |
| 716 JobsIndex::const_iterator it = jobsIndex_.find(id); | |
| 717 if (it == jobsIndex_.end()) | |
| 718 { | |
| 719 // Should not happen | |
| 720 state = JobState_Failure; | |
| 721 } | |
| 722 else | |
| 723 { | |
| 724 const JobStatus& status = it->second->GetLastStatus(); | |
| 725 successContent = status.GetPublicContent(); | |
| 726 } | |
| 727 | |
| 728 break; | |
| 729 } | |
| 730 else | |
| 731 { | |
| 732 // This job has not finished yet, wait for new completion | |
| 733 someJobComplete_.wait(lock); | |
| 734 } | |
|
2570
2e879c796ec7
JobsRegistry::SubmitAndWait(), StoreScuJob
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2569
diff
changeset
|
735 } |
|
2e879c796ec7
JobsRegistry::SubmitAndWait(), StoreScuJob
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2569
diff
changeset
|
736 } |
|
2e879c796ec7
JobsRegistry::SubmitAndWait(), StoreScuJob
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2569
diff
changeset
|
737 |
|
2e879c796ec7
JobsRegistry::SubmitAndWait(), StoreScuJob
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2569
diff
changeset
|
738 return (state == JobState_Success); |
|
2e879c796ec7
JobsRegistry::SubmitAndWait(), StoreScuJob
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2569
diff
changeset
|
739 } |
|
2e879c796ec7
JobsRegistry::SubmitAndWait(), StoreScuJob
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2569
diff
changeset
|
740 |
|
2e879c796ec7
JobsRegistry::SubmitAndWait(), StoreScuJob
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2569
diff
changeset
|
741 |
|
2573
3372c5255333
StoreScuJob, Orthanc Explorer for jobs
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2570
diff
changeset
|
742 bool JobsRegistry::SetPriority(const std::string& id, |
| 2569 | 743 int priority) |
| 744 { | |
| 745 LOG(INFO) << "Changing priority to " << priority << " for job: " << id; | |
| 746 | |
| 747 boost::mutex::scoped_lock lock(mutex_); | |
| 748 CheckInvariants(); | |
| 749 | |
| 750 JobsIndex::iterator found = jobsIndex_.find(id); | |
| 751 | |
| 752 if (found == jobsIndex_.end()) | |
| 753 { | |
| 754 LOG(WARNING) << "Unknown job: " << id; | |
|
2573
3372c5255333
StoreScuJob, Orthanc Explorer for jobs
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2570
diff
changeset
|
755 return false; |
| 2569 | 756 } |
| 757 else | |
| 758 { | |
| 759 found->second->SetPriority(priority); | |
| 760 | |
| 761 if (found->second->GetState() == JobState_Pending) | |
| 762 { | |
| 763 // If the job is pending, we need to reconstruct the | |
| 764 // priority queue, as the heap condition has changed | |
| 765 | |
| 766 PendingJobs copy; | |
| 767 std::swap(copy, pendingJobs_); | |
| 768 | |
| 769 assert(pendingJobs_.empty()); | |
| 770 while (!copy.empty()) | |
| 771 { | |
| 772 pendingJobs_.push(copy.top()); | |
| 773 copy.pop(); | |
| 774 } | |
| 775 } | |
|
2573
3372c5255333
StoreScuJob, Orthanc Explorer for jobs
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2570
diff
changeset
|
776 |
|
3372c5255333
StoreScuJob, Orthanc Explorer for jobs
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2570
diff
changeset
|
777 CheckInvariants(); |
|
3372c5255333
StoreScuJob, Orthanc Explorer for jobs
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2570
diff
changeset
|
778 return true; |
| 2569 | 779 } |
| 780 } | |
| 781 | |
| 782 | |
|
2581
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
783 void JobsRegistry::RemovePendingJob(const std::string& id) |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
784 { |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
785 // If the job is pending, we need to reconstruct the priority |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
786 // queue to remove it |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
787 PendingJobs copy; |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
788 std::swap(copy, pendingJobs_); |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
789 |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
790 assert(pendingJobs_.empty()); |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
791 while (!copy.empty()) |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
792 { |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
793 if (copy.top()->GetId() != id) |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
794 { |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
795 pendingJobs_.push(copy.top()); |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
796 } |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
797 |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
798 copy.pop(); |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
799 } |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
800 } |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
801 |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
802 |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
803 void JobsRegistry::RemoveRetryJob(JobHandler* handler) |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
804 { |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
805 RetryJobs::iterator item = retryJobs_.find(handler); |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
806 assert(item != retryJobs_.end()); |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
807 retryJobs_.erase(item); |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
808 } |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
809 |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
810 |
|
2573
3372c5255333
StoreScuJob, Orthanc Explorer for jobs
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2570
diff
changeset
|
811 bool JobsRegistry::Pause(const std::string& id) |
| 2569 | 812 { |
| 813 LOG(INFO) << "Pausing job: " << id; | |
| 814 | |
| 815 boost::mutex::scoped_lock lock(mutex_); | |
| 816 CheckInvariants(); | |
| 817 | |
| 818 JobsIndex::iterator found = jobsIndex_.find(id); | |
| 819 | |
| 820 if (found == jobsIndex_.end()) | |
| 821 { | |
| 822 LOG(WARNING) << "Unknown job: " << id; | |
|
2573
3372c5255333
StoreScuJob, Orthanc Explorer for jobs
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2570
diff
changeset
|
823 return false; |
| 2569 | 824 } |
| 825 else | |
| 826 { | |
| 827 switch (found->second->GetState()) | |
| 828 { | |
| 829 case JobState_Pending: | |
|
2581
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
830 RemovePendingJob(id); |
| 2569 | 831 found->second->SetState(JobState_Paused); |
| 832 break; | |
| 833 | |
| 834 case JobState_Retry: | |
|
2581
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
835 RemoveRetryJob(found->second); |
| 2569 | 836 found->second->SetState(JobState_Paused); |
| 837 break; | |
| 838 | |
| 839 case JobState_Paused: | |
| 840 case JobState_Success: | |
| 841 case JobState_Failure: | |
| 842 // Nothing to be done | |
| 843 break; | |
| 844 | |
| 845 case JobState_Running: | |
| 846 found->second->SchedulePause(); | |
| 847 break; | |
| 848 | |
| 849 default: | |
| 850 throw OrthancException(ErrorCode_InternalError); | |
| 851 } | |
|
2573
3372c5255333
StoreScuJob, Orthanc Explorer for jobs
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2570
diff
changeset
|
852 |
|
3372c5255333
StoreScuJob, Orthanc Explorer for jobs
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2570
diff
changeset
|
853 CheckInvariants(); |
|
3372c5255333
StoreScuJob, Orthanc Explorer for jobs
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2570
diff
changeset
|
854 return true; |
| 2569 | 855 } |
| 856 } | |
| 857 | |
| 858 | |
|
2581
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
859 bool JobsRegistry::Cancel(const std::string& id) |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
860 { |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
861 LOG(INFO) << "Canceling job: " << id; |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
862 |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
863 boost::mutex::scoped_lock lock(mutex_); |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
864 CheckInvariants(); |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
865 |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
866 JobsIndex::iterator found = jobsIndex_.find(id); |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
867 |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
868 if (found == jobsIndex_.end()) |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
869 { |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
870 LOG(WARNING) << "Unknown job: " << id; |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
871 return false; |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
872 } |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
873 else |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
874 { |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
875 switch (found->second->GetState()) |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
876 { |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
877 case JobState_Pending: |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
878 RemovePendingJob(id); |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
879 SetCompletedJob(*found->second, false); |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
880 found->second->SetLastErrorCode(ErrorCode_CanceledJob); |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
881 break; |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
882 |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
883 case JobState_Retry: |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
884 RemoveRetryJob(found->second); |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
885 SetCompletedJob(*found->second, false); |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
886 found->second->SetLastErrorCode(ErrorCode_CanceledJob); |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
887 break; |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
888 |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
889 case JobState_Paused: |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
890 SetCompletedJob(*found->second, false); |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
891 found->second->SetLastErrorCode(ErrorCode_CanceledJob); |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
892 break; |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
893 |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
894 case JobState_Success: |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
895 case JobState_Failure: |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
896 // Nothing to be done |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
897 break; |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
898 |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
899 case JobState_Running: |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
900 found->second->ScheduleCancel(); |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
901 break; |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
902 |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
903 default: |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
904 throw OrthancException(ErrorCode_InternalError); |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
905 } |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
906 |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
907 CheckInvariants(); |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
908 return true; |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
909 } |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
910 } |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
911 |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
912 |
|
2573
3372c5255333
StoreScuJob, Orthanc Explorer for jobs
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2570
diff
changeset
|
913 bool JobsRegistry::Resume(const std::string& id) |
| 2569 | 914 { |
| 915 LOG(INFO) << "Resuming job: " << id; | |
| 916 | |
| 917 boost::mutex::scoped_lock lock(mutex_); | |
| 918 CheckInvariants(); | |
| 919 | |
| 920 JobsIndex::iterator found = jobsIndex_.find(id); | |
| 921 | |
| 922 if (found == jobsIndex_.end()) | |
| 923 { | |
| 924 LOG(WARNING) << "Unknown job: " << id; | |
|
2573
3372c5255333
StoreScuJob, Orthanc Explorer for jobs
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2570
diff
changeset
|
925 return false; |
| 2569 | 926 } |
| 927 else if (found->second->GetState() != JobState_Paused) | |
| 928 { | |
| 929 LOG(WARNING) << "Cannot resume a job that is not paused: " << id; | |
|
2573
3372c5255333
StoreScuJob, Orthanc Explorer for jobs
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2570
diff
changeset
|
930 return false; |
| 2569 | 931 } |
| 932 else | |
| 933 { | |
| 934 found->second->SetState(JobState_Pending); | |
| 935 pendingJobs_.push(found->second); | |
| 936 pendingJobAvailable_.notify_one(); | |
|
2573
3372c5255333
StoreScuJob, Orthanc Explorer for jobs
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2570
diff
changeset
|
937 CheckInvariants(); |
|
3372c5255333
StoreScuJob, Orthanc Explorer for jobs
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2570
diff
changeset
|
938 return true; |
| 2569 | 939 } |
| 940 } | |
| 941 | |
| 942 | |
|
2573
3372c5255333
StoreScuJob, Orthanc Explorer for jobs
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2570
diff
changeset
|
943 bool JobsRegistry::Resubmit(const std::string& id) |
| 2569 | 944 { |
| 945 LOG(INFO) << "Resubmitting failed job: " << id; | |
| 946 | |
| 947 boost::mutex::scoped_lock lock(mutex_); | |
| 948 CheckInvariants(); | |
| 949 | |
| 950 JobsIndex::iterator found = jobsIndex_.find(id); | |
| 951 | |
| 952 if (found == jobsIndex_.end()) | |
| 953 { | |
| 954 LOG(WARNING) << "Unknown job: " << id; | |
|
2573
3372c5255333
StoreScuJob, Orthanc Explorer for jobs
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2570
diff
changeset
|
955 return false; |
| 2569 | 956 } |
| 957 else if (found->second->GetState() != JobState_Failure) | |
| 958 { | |
| 959 LOG(WARNING) << "Cannot resubmit a job that has not failed: " << id; | |
|
2573
3372c5255333
StoreScuJob, Orthanc Explorer for jobs
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2570
diff
changeset
|
960 return false; |
| 2569 | 961 } |
| 962 else | |
| 963 { | |
|
2812
ea7aea6f6a95
improved naming of methods in IJob
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2673
diff
changeset
|
964 found->second->GetJob().Reset(); |
|
2583
1b6a6d80b6f2
OrthancPeerStoreJob
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2581
diff
changeset
|
965 |
| 2569 | 966 bool ok = false; |
| 967 for (CompletedJobs::iterator it = completedJobs_.begin(); | |
| 968 it != completedJobs_.end(); ++it) | |
| 969 { | |
| 970 if (*it == found->second) | |
| 971 { | |
| 972 ok = true; | |
| 973 completedJobs_.erase(it); | |
| 974 break; | |
| 975 } | |
| 976 } | |
| 977 | |
| 978 assert(ok); | |
| 979 | |
| 980 found->second->SetState(JobState_Pending); | |
| 981 pendingJobs_.push(found->second); | |
| 982 pendingJobAvailable_.notify_one(); | |
|
2573
3372c5255333
StoreScuJob, Orthanc Explorer for jobs
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2570
diff
changeset
|
983 |
|
3372c5255333
StoreScuJob, Orthanc Explorer for jobs
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2570
diff
changeset
|
984 CheckInvariants(); |
|
3372c5255333
StoreScuJob, Orthanc Explorer for jobs
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2570
diff
changeset
|
985 return true; |
| 2569 | 986 } |
| 987 } | |
| 988 | |
| 989 | |
| 990 void JobsRegistry::ScheduleRetries() | |
| 991 { | |
| 992 boost::mutex::scoped_lock lock(mutex_); | |
| 993 CheckInvariants(); | |
| 994 | |
| 995 RetryJobs copy; | |
| 996 std::swap(copy, retryJobs_); | |
| 997 | |
| 998 const boost::posix_time::ptime now = boost::posix_time::microsec_clock::universal_time(); | |
| 999 | |
| 1000 assert(retryJobs_.empty()); | |
| 1001 for (RetryJobs::iterator it = copy.begin(); it != copy.end(); ++it) | |
| 1002 { | |
| 1003 if ((*it)->IsRetryReady(now)) | |
| 1004 { | |
| 1005 LOG(INFO) << "Retrying job: " << (*it)->GetId(); | |
| 1006 (*it)->SetState(JobState_Pending); | |
| 1007 pendingJobs_.push(*it); | |
| 1008 pendingJobAvailable_.notify_one(); | |
| 1009 } | |
| 1010 else | |
| 1011 { | |
| 1012 retryJobs_.insert(*it); | |
| 1013 } | |
| 1014 } | |
| 1015 | |
| 1016 CheckInvariants(); | |
| 1017 } | |
| 1018 | |
| 1019 | |
| 1020 bool JobsRegistry::GetState(JobState& state, | |
| 1021 const std::string& id) | |
| 1022 { | |
| 1023 boost::mutex::scoped_lock lock(mutex_); | |
|
2570
2e879c796ec7
JobsRegistry::SubmitAndWait(), StoreScuJob
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2569
diff
changeset
|
1024 return GetStateInternal(state, id); |
| 2569 | 1025 } |
| 1026 | |
|
2673
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
1027 |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
1028 void JobsRegistry::SetObserver(JobsRegistry::IObserver& observer) |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
1029 { |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
1030 boost::mutex::scoped_lock lock(mutex_); |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
1031 observer_ = &observer; |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
1032 } |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
1033 |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
1034 |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
1035 void JobsRegistry::ResetObserver() |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
1036 { |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
1037 boost::mutex::scoped_lock lock(mutex_); |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
1038 observer_ = NULL; |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
1039 } |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
1040 |
| 2569 | 1041 |
| 1042 JobsRegistry::RunningJob::RunningJob(JobsRegistry& registry, | |
| 1043 unsigned int timeout) : | |
| 1044 registry_(registry), | |
| 1045 handler_(NULL), | |
| 1046 targetState_(JobState_Failure), | |
|
2581
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
1047 targetRetryTimeout_(0), |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
1048 canceled_(false) |
| 2569 | 1049 { |
| 1050 { | |
| 1051 boost::mutex::scoped_lock lock(registry_.mutex_); | |
| 1052 | |
| 1053 while (registry_.pendingJobs_.empty()) | |
| 1054 { | |
| 1055 if (timeout == 0) | |
| 1056 { | |
| 1057 registry_.pendingJobAvailable_.wait(lock); | |
| 1058 } | |
| 1059 else | |
| 1060 { | |
| 1061 bool success = registry_.pendingJobAvailable_.timed_wait | |
| 1062 (lock, boost::posix_time::milliseconds(timeout)); | |
| 1063 if (!success) | |
| 1064 { | |
| 1065 // No pending job | |
| 1066 return; | |
| 1067 } | |
| 1068 } | |
| 1069 } | |
| 1070 | |
| 1071 handler_ = registry_.pendingJobs_.top(); | |
| 1072 registry_.pendingJobs_.pop(); | |
| 1073 | |
| 1074 assert(handler_->GetState() == JobState_Pending); | |
| 1075 handler_->SetState(JobState_Running); | |
|
2581
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
1076 handler_->SetLastErrorCode(ErrorCode_Success); |
| 2569 | 1077 |
| 1078 job_ = &handler_->GetJob(); | |
| 1079 id_ = handler_->GetId(); | |
| 1080 priority_ = handler_->GetPriority(); | |
| 1081 } | |
| 1082 } | |
| 1083 | |
| 1084 | |
| 1085 JobsRegistry::RunningJob::~RunningJob() | |
| 1086 { | |
| 1087 if (IsValid()) | |
| 1088 { | |
| 1089 boost::mutex::scoped_lock lock(registry_.mutex_); | |
| 1090 | |
| 1091 switch (targetState_) | |
| 1092 { | |
| 1093 case JobState_Failure: | |
| 1094 registry_.MarkRunningAsCompleted(*handler_, false); | |
|
2581
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
1095 |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
1096 if (canceled_) |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
1097 { |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
1098 handler_->SetLastErrorCode(ErrorCode_CanceledJob); |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
1099 } |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
1100 |
| 2569 | 1101 break; |
| 1102 | |
| 1103 case JobState_Success: | |
| 1104 registry_.MarkRunningAsCompleted(*handler_, true); | |
| 1105 break; | |
| 1106 | |
| 1107 case JobState_Paused: | |
| 1108 registry_.MarkRunningAsPaused(*handler_); | |
| 1109 break; | |
| 1110 | |
| 1111 case JobState_Retry: | |
| 1112 registry_.MarkRunningAsRetry(*handler_, targetRetryTimeout_); | |
| 1113 break; | |
| 1114 | |
| 1115 default: | |
| 1116 assert(0); | |
| 1117 } | |
| 1118 } | |
| 1119 } | |
| 1120 | |
| 1121 | |
| 1122 bool JobsRegistry::RunningJob::IsValid() const | |
| 1123 { | |
| 1124 return (handler_ != NULL && | |
| 1125 job_ != NULL); | |
| 1126 } | |
| 1127 | |
| 1128 | |
| 1129 const std::string& JobsRegistry::RunningJob::GetId() const | |
| 1130 { | |
| 1131 if (!IsValid()) | |
| 1132 { | |
| 1133 throw OrthancException(ErrorCode_BadSequenceOfCalls); | |
| 1134 } | |
| 1135 else | |
| 1136 { | |
| 1137 return id_; | |
| 1138 } | |
| 1139 } | |
| 1140 | |
| 1141 | |
| 1142 int JobsRegistry::RunningJob::GetPriority() const | |
| 1143 { | |
| 1144 if (!IsValid()) | |
| 1145 { | |
| 1146 throw OrthancException(ErrorCode_BadSequenceOfCalls); | |
| 1147 } | |
| 1148 else | |
| 1149 { | |
| 1150 return priority_; | |
| 1151 } | |
| 1152 } | |
| 1153 | |
| 1154 | |
| 1155 IJob& JobsRegistry::RunningJob::GetJob() | |
| 1156 { | |
| 1157 if (!IsValid()) | |
| 1158 { | |
| 1159 throw OrthancException(ErrorCode_BadSequenceOfCalls); | |
| 1160 } | |
| 1161 else | |
| 1162 { | |
| 1163 return *job_; | |
| 1164 } | |
| 1165 } | |
| 1166 | |
| 1167 | |
| 1168 bool JobsRegistry::RunningJob::IsPauseScheduled() | |
| 1169 { | |
| 1170 if (!IsValid()) | |
| 1171 { | |
| 1172 throw OrthancException(ErrorCode_BadSequenceOfCalls); | |
| 1173 } | |
| 1174 else | |
| 1175 { | |
| 1176 boost::mutex::scoped_lock lock(registry_.mutex_); | |
| 1177 registry_.CheckInvariants(); | |
| 1178 assert(handler_->GetState() == JobState_Running); | |
| 1179 | |
| 1180 return handler_->IsPauseScheduled(); | |
| 1181 } | |
| 1182 } | |
| 1183 | |
| 1184 | |
|
2581
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
1185 bool JobsRegistry::RunningJob::IsCancelScheduled() |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
1186 { |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
1187 if (!IsValid()) |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
1188 { |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
1189 throw OrthancException(ErrorCode_BadSequenceOfCalls); |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
1190 } |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
1191 else |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
1192 { |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
1193 boost::mutex::scoped_lock lock(registry_.mutex_); |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
1194 registry_.CheckInvariants(); |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
1195 assert(handler_->GetState() == JobState_Running); |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
1196 |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
1197 return handler_->IsCancelScheduled(); |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
1198 } |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
1199 } |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
1200 |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
1201 |
| 2569 | 1202 void JobsRegistry::RunningJob::MarkSuccess() |
| 1203 { | |
| 1204 if (!IsValid()) | |
| 1205 { | |
| 1206 throw OrthancException(ErrorCode_BadSequenceOfCalls); | |
| 1207 } | |
| 1208 else | |
| 1209 { | |
| 1210 targetState_ = JobState_Success; | |
| 1211 } | |
| 1212 } | |
| 1213 | |
| 1214 | |
| 1215 void JobsRegistry::RunningJob::MarkFailure() | |
| 1216 { | |
| 1217 if (!IsValid()) | |
| 1218 { | |
| 1219 throw OrthancException(ErrorCode_BadSequenceOfCalls); | |
| 1220 } | |
| 1221 else | |
| 1222 { | |
| 1223 targetState_ = JobState_Failure; | |
| 1224 } | |
| 1225 } | |
| 1226 | |
| 1227 | |
|
2581
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
1228 void JobsRegistry::RunningJob::MarkCanceled() |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
1229 { |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
1230 if (!IsValid()) |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
1231 { |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
1232 throw OrthancException(ErrorCode_BadSequenceOfCalls); |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
1233 } |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
1234 else |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
1235 { |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
1236 targetState_ = JobState_Failure; |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
1237 canceled_ = true; |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
1238 } |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
1239 } |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
1240 |
|
8da2cffc2378
JobsRegistry::Cancel()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2573
diff
changeset
|
1241 |
| 2569 | 1242 void JobsRegistry::RunningJob::MarkPause() |
| 1243 { | |
| 1244 if (!IsValid()) | |
| 1245 { | |
| 1246 throw OrthancException(ErrorCode_BadSequenceOfCalls); | |
| 1247 } | |
| 1248 else | |
| 1249 { | |
| 1250 targetState_ = JobState_Paused; | |
| 1251 } | |
| 1252 } | |
| 1253 | |
| 1254 | |
| 1255 void JobsRegistry::RunningJob::MarkRetry(unsigned int timeout) | |
| 1256 { | |
| 1257 if (!IsValid()) | |
| 1258 { | |
| 1259 throw OrthancException(ErrorCode_BadSequenceOfCalls); | |
| 1260 } | |
| 1261 else | |
| 1262 { | |
| 1263 targetState_ = JobState_Retry; | |
| 1264 targetRetryTimeout_ = timeout; | |
| 1265 } | |
| 1266 } | |
| 1267 | |
| 1268 | |
| 1269 void JobsRegistry::RunningJob::UpdateStatus(ErrorCode code) | |
| 1270 { | |
| 1271 if (!IsValid()) | |
| 1272 { | |
| 1273 throw OrthancException(ErrorCode_BadSequenceOfCalls); | |
| 1274 } | |
| 1275 else | |
| 1276 { | |
| 1277 JobStatus status(code, *job_); | |
| 1278 | |
| 1279 boost::mutex::scoped_lock lock(registry_.mutex_); | |
| 1280 registry_.CheckInvariants(); | |
| 1281 assert(handler_->GetState() == JobState_Running); | |
| 1282 | |
| 1283 handler_->SetLastStatus(status); | |
| 1284 } | |
| 1285 } | |
|
2667
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
1286 |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
1287 |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
1288 |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
1289 void JobsRegistry::Serialize(Json::Value& target) |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
1290 { |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
1291 boost::mutex::scoped_lock lock(mutex_); |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
1292 CheckInvariants(); |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
1293 |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
1294 target = Json::objectValue; |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
1295 target[TYPE] = JOBS_REGISTRY; |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
1296 target[MAX_COMPLETED_JOBS] = static_cast<unsigned int>(maxCompletedJobs_); |
|
2670
c5646f766b3e
serialize jobs as an object
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2669
diff
changeset
|
1297 target[JOBS] = Json::objectValue; |
|
2667
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
1298 |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
1299 for (JobsIndex::const_iterator it = jobsIndex_.begin(); |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
1300 it != jobsIndex_.end(); ++it) |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
1301 { |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
1302 Json::Value v; |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
1303 if (it->second->Serialize(v)) |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
1304 { |
|
2670
c5646f766b3e
serialize jobs as an object
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2669
diff
changeset
|
1305 target[JOBS][it->first] = v; |
|
2667
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
1306 } |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
1307 } |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
1308 } |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
1309 |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
1310 |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
1311 JobsRegistry::JobsRegistry(IJobUnserializer& unserializer, |
|
2673
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
1312 const Json::Value& s) : |
|
8e0bc055d18c
JobsRegistry::IObserver
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2670
diff
changeset
|
1313 observer_(NULL) |
|
2667
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
1314 { |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
1315 if (SerializationToolbox::ReadString(s, TYPE) != JOBS_REGISTRY || |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
1316 !s.isMember(JOBS) || |
|
2670
c5646f766b3e
serialize jobs as an object
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2669
diff
changeset
|
1317 s[JOBS].type() != Json::objectValue) |
|
2667
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
1318 { |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
1319 throw OrthancException(ErrorCode_BadFileFormat); |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
1320 } |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
1321 |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
1322 maxCompletedJobs_ = SerializationToolbox::ReadUnsignedInteger(s, MAX_COMPLETED_JOBS); |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
1323 |
|
2670
c5646f766b3e
serialize jobs as an object
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2669
diff
changeset
|
1324 Json::Value::Members members = s[JOBS].getMemberNames(); |
|
c5646f766b3e
serialize jobs as an object
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2669
diff
changeset
|
1325 |
|
c5646f766b3e
serialize jobs as an object
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2669
diff
changeset
|
1326 for (Json::Value::Members::const_iterator it = members.begin(); |
|
c5646f766b3e
serialize jobs as an object
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2669
diff
changeset
|
1327 it != members.end(); ++it) |
|
2667
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
1328 { |
|
2670
c5646f766b3e
serialize jobs as an object
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2669
diff
changeset
|
1329 std::auto_ptr<JobHandler> job(new JobHandler(unserializer, s[JOBS][*it], *it)); |
|
2669
eaf10085ffa1
no passwords in public content of jobs
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2668
diff
changeset
|
1330 |
|
2667
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
1331 std::string id; |
|
2669
eaf10085ffa1
no passwords in public content of jobs
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2668
diff
changeset
|
1332 SubmitInternal(id, job.release(), true); |
|
2667
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
1333 } |
|
5fa2f2ce74f0
serialization of JobsRegistry
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2663
diff
changeset
|
1334 } |
| 2569 | 1335 } |