Mercurial > hg > orthanc
annotate OrthancFramework/Sources/JobsEngine/SetOfCommandsJob.cpp @ 4303:44b53a2c0a13
improving detection of ABI compatibility
author | Sebastien Jodogne <s.jodogne@gmail.com> |
---|---|
date | Fri, 06 Nov 2020 15:37:30 +0100 |
parents | b30a8de92ad9 |
children | 50b0c69b653a |
rev | line source |
---|---|
2860 | 1 /** |
2 * Orthanc - A Lightweight, RESTful DICOM Store | |
3 * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics | |
4 * Department, University Hospital of Liege, Belgium | |
3640
94f4a18a79cc
upgrade to year 2020
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3240
diff
changeset
|
5 * Copyright (C) 2017-2020 Osimis S.A., Belgium |
2860 | 6 * |
7 * This program is free software: you can redistribute it and/or | |
4119
bf7b9edf6b81
re-licensing the OrthancFramework to LGPL, in order to license Stone of Orthanc under LGPL
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4044
diff
changeset
|
8 * modify it under the terms of the GNU Lesser General Public License |
bf7b9edf6b81
re-licensing the OrthancFramework to LGPL, in order to license Stone of Orthanc under LGPL
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4044
diff
changeset
|
9 * as published by the Free Software Foundation, either version 3 of |
bf7b9edf6b81
re-licensing the OrthancFramework to LGPL, in order to license Stone of Orthanc under LGPL
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4044
diff
changeset
|
10 * the License, or (at your option) any later version. |
2860 | 11 * |
12 * This program is distributed in the hope that it will be useful, but | |
13 * WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
4119
bf7b9edf6b81
re-licensing the OrthancFramework to LGPL, in order to license Stone of Orthanc under LGPL
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4044
diff
changeset
|
15 * Lesser General Public License for more details. |
2860 | 16 * |
4119
bf7b9edf6b81
re-licensing the OrthancFramework to LGPL, in order to license Stone of Orthanc under LGPL
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4044
diff
changeset
|
17 * You should have received a copy of the GNU Lesser General Public |
bf7b9edf6b81
re-licensing the OrthancFramework to LGPL, in order to license Stone of Orthanc under LGPL
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4044
diff
changeset
|
18 * License along with this program. If not, see |
bf7b9edf6b81
re-licensing the OrthancFramework to LGPL, in order to license Stone of Orthanc under LGPL
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4044
diff
changeset
|
19 * <http://www.gnu.org/licenses/>. |
2860 | 20 **/ |
21 | |
22 | |
23 #include "../PrecompiledHeaders.h" | |
24 #include "SetOfCommandsJob.h" | |
25 | |
26 #include "../Logging.h" | |
27 #include "../OrthancException.h" | |
28 #include "../SerializationToolbox.h" | |
29 | |
30 #include <cassert> | |
2866 | 31 #include <memory> |
2860 | 32 |
33 namespace Orthanc | |
34 { | |
35 SetOfCommandsJob::SetOfCommandsJob() : | |
36 started_(false), | |
37 permissive_(false), | |
38 position_(0) | |
39 { | |
40 } | |
41 | |
42 | |
43 SetOfCommandsJob::~SetOfCommandsJob() | |
44 { | |
45 for (size_t i = 0; i < commands_.size(); i++) | |
46 { | |
47 assert(commands_[i] != NULL); | |
48 delete commands_[i]; | |
49 } | |
50 } | |
51 | |
4300 | 52 size_t SetOfCommandsJob::GetPosition() const |
53 { | |
54 return position_; | |
55 } | |
56 | |
57 void SetOfCommandsJob::SetDescription(const std::string &description) | |
58 { | |
59 description_ = description; | |
60 } | |
61 | |
62 | |
2860 | 63 void SetOfCommandsJob::Reserve(size_t size) |
64 { | |
65 if (started_) | |
66 { | |
67 throw OrthancException(ErrorCode_BadSequenceOfCalls); | |
68 } | |
69 else | |
70 { | |
71 commands_.reserve(size); | |
72 } | |
73 } | |
74 | |
4300 | 75 size_t SetOfCommandsJob::GetCommandsCount() const |
76 { | |
77 return commands_.size(); | |
78 } | |
79 | |
80 | |
2860 | 81 void SetOfCommandsJob::AddCommand(ICommand* command) |
82 { | |
83 if (command == NULL) | |
84 { | |
85 throw OrthancException(ErrorCode_NullPointer); | |
86 } | |
87 else if (started_) | |
88 { | |
89 throw OrthancException(ErrorCode_BadSequenceOfCalls); | |
90 } | |
91 else | |
92 { | |
93 commands_.push_back(command); | |
94 } | |
95 } | |
96 | |
4300 | 97 bool SetOfCommandsJob::IsPermissive() const |
98 { | |
99 return permissive_; | |
100 } | |
101 | |
2860 | 102 |
103 void SetOfCommandsJob::SetPermissive(bool permissive) | |
104 { | |
105 if (started_) | |
106 { | |
107 throw OrthancException(ErrorCode_BadSequenceOfCalls); | |
108 } | |
109 else | |
110 { | |
111 permissive_ = permissive; | |
112 } | |
113 } | |
114 | |
115 | |
116 void SetOfCommandsJob::Reset() | |
117 { | |
118 if (started_) | |
119 { | |
120 position_ = 0; | |
121 } | |
122 else | |
123 { | |
124 throw OrthancException(ErrorCode_BadSequenceOfCalls); | |
125 } | |
126 } | |
127 | |
4300 | 128 void SetOfCommandsJob::Start() |
129 { | |
130 started_ = true; | |
131 } | |
132 | |
133 | |
2860 | 134 float SetOfCommandsJob::GetProgress() |
135 { | |
136 if (commands_.empty()) | |
137 { | |
138 return 1; | |
139 } | |
140 else | |
141 { | |
142 return (static_cast<float>(position_) / | |
143 static_cast<float>(commands_.size())); | |
144 } | |
145 } | |
146 | |
4300 | 147 bool SetOfCommandsJob::IsStarted() const |
148 { | |
149 return started_; | |
150 } | |
151 | |
2860 | 152 |
153 const SetOfCommandsJob::ICommand& SetOfCommandsJob::GetCommand(size_t index) const | |
154 { | |
155 if (index >= commands_.size()) | |
156 { | |
157 throw OrthancException(ErrorCode_ParameterOutOfRange); | |
158 } | |
159 else | |
160 { | |
161 assert(commands_[index] != NULL); | |
162 return *commands_[index]; | |
163 } | |
164 } | |
165 | |
166 | |
3658
2d90dd30858c
providing job ID to the IJob::Step() methods
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
167 JobStepResult SetOfCommandsJob::Step(const std::string& jobId) |
2860 | 168 { |
169 if (!started_) | |
170 { | |
171 throw OrthancException(ErrorCode_InternalError); | |
172 } | |
173 | |
174 if (commands_.empty() && | |
175 position_ == 0) | |
176 { | |
177 // No command to handle: We're done | |
178 position_ = 1; | |
179 return JobStepResult::Success(); | |
180 } | |
181 | |
182 if (position_ >= commands_.size()) | |
183 { | |
184 // Already done | |
185 throw OrthancException(ErrorCode_BadSequenceOfCalls); | |
186 } | |
187 | |
188 try | |
189 { | |
190 // Not at the trailing step: Handle the current command | |
3658
2d90dd30858c
providing job ID to the IJob::Step() methods
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
191 if (!commands_[position_]->Execute(jobId)) |
2860 | 192 { |
193 // Error | |
194 if (!permissive_) | |
195 { | |
3240
e44e0127e553
Fix issue #134 (/patient/modify gives 500, should really be 400)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
196 return JobStepResult::Failure(ErrorCode_InternalError, NULL); |
2860 | 197 } |
198 } | |
199 } | |
200 catch (OrthancException& e) | |
201 { | |
202 if (permissive_) | |
203 { | |
204 LOG(WARNING) << "Ignoring an error in a permissive job: " << e.What(); | |
205 } | |
206 else | |
207 { | |
3240
e44e0127e553
Fix issue #134 (/patient/modify gives 500, should really be 400)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
208 return JobStepResult::Failure(e); |
2860 | 209 } |
210 } | |
211 | |
212 position_ += 1; | |
213 | |
214 if (position_ == commands_.size()) | |
215 { | |
216 // We're done | |
217 return JobStepResult::Success(); | |
218 } | |
219 else | |
220 { | |
221 return JobStepResult::Continue(); | |
222 } | |
223 } | |
224 | |
225 | |
226 | |
227 static const char* KEY_DESCRIPTION = "Description"; | |
228 static const char* KEY_PERMISSIVE = "Permissive"; | |
229 static const char* KEY_POSITION = "Position"; | |
230 static const char* KEY_TYPE = "Type"; | |
231 static const char* KEY_COMMANDS = "Commands"; | |
232 | |
233 | |
234 void SetOfCommandsJob::GetPublicContent(Json::Value& value) | |
235 { | |
236 value[KEY_DESCRIPTION] = GetDescription(); | |
237 } | |
238 | |
239 | |
240 bool SetOfCommandsJob::Serialize(Json::Value& target) | |
241 { | |
242 target = Json::objectValue; | |
243 | |
244 std::string type; | |
245 GetJobType(type); | |
246 target[KEY_TYPE] = type; | |
247 | |
248 target[KEY_PERMISSIVE] = permissive_; | |
249 target[KEY_POSITION] = static_cast<unsigned int>(position_); | |
250 target[KEY_DESCRIPTION] = description_; | |
251 | |
252 target[KEY_COMMANDS] = Json::arrayValue; | |
253 Json::Value& tmp = target[KEY_COMMANDS]; | |
254 | |
255 for (size_t i = 0; i < commands_.size(); i++) | |
256 { | |
257 assert(commands_[i] != NULL); | |
258 | |
259 Json::Value command; | |
260 commands_[i]->Serialize(command); | |
261 tmp.append(command); | |
262 } | |
263 | |
264 return true; | |
265 } | |
266 | |
4300 | 267 bool SetOfCommandsJob::GetOutput(std::string &output, |
268 MimeType &mime, | |
269 const std::string &key) | |
270 { | |
271 return false; | |
272 } | |
273 | |
2860 | 274 |
275 SetOfCommandsJob::SetOfCommandsJob(ICommandUnserializer* unserializer, | |
276 const Json::Value& source) : | |
277 started_(false) | |
278 { | |
3712
2a170a8f1faf
replacing std::auto_ptr by std::unique_ptr
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
279 std::unique_ptr<ICommandUnserializer> raii(unserializer); |
2860 | 280 |
281 permissive_ = SerializationToolbox::ReadBoolean(source, KEY_PERMISSIVE); | |
282 position_ = SerializationToolbox::ReadUnsignedInteger(source, KEY_POSITION); | |
283 description_ = SerializationToolbox::ReadString(source, KEY_DESCRIPTION); | |
284 | |
285 if (!source.isMember(KEY_COMMANDS) || | |
286 source[KEY_COMMANDS].type() != Json::arrayValue) | |
287 { | |
288 throw OrthancException(ErrorCode_BadFileFormat); | |
289 } | |
290 else | |
291 { | |
292 const Json::Value& tmp = source[KEY_COMMANDS]; | |
293 commands_.resize(tmp.size()); | |
294 | |
295 for (Json::Value::ArrayIndex i = 0; i < tmp.size(); i++) | |
296 { | |
297 try | |
298 { | |
299 commands_[i] = unserializer->Unserialize(tmp[i]); | |
300 } | |
301 catch (OrthancException&) | |
302 { | |
303 } | |
304 | |
305 if (commands_[i] == NULL) | |
306 { | |
307 for (size_t j = 0; j < i; j++) | |
308 { | |
309 delete commands_[j]; | |
310 } | |
311 | |
312 throw OrthancException(ErrorCode_BadFileFormat); | |
313 } | |
314 } | |
315 } | |
316 | |
317 if (commands_.empty()) | |
318 { | |
319 if (position_ > 1) | |
320 { | |
321 throw OrthancException(ErrorCode_BadFileFormat); | |
322 } | |
323 } | |
324 else if (position_ > commands_.size()) | |
325 { | |
326 throw OrthancException(ErrorCode_BadFileFormat); | |
327 } | |
328 } | |
329 } |