Mercurial > hg > orthanc-transfers
annotate Plugin/Plugin.cpp @ 77:1e396fb509ca default
updated copyright, as Orthanc Team now replaces Osimis
author | Sebastien Jodogne <s.jodogne@gmail.com> |
---|---|
date | Thu, 30 May 2024 22:44:10 +0200 |
parents | 3f43bfbea00e |
children |
rev | line source |
---|---|
0 | 1 /** |
2 * Transfers accelerator plugin for Orthanc | |
77
1e396fb509ca
updated copyright, as Orthanc Team now replaces Osimis
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
70
diff
changeset
|
3 * Copyright (C) 2018-2023 Osimis S.A., Belgium |
1e396fb509ca
updated copyright, as Orthanc Team now replaces Osimis
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
70
diff
changeset
|
4 * Copyright (C) 2024-2024 Orthanc Team SRL, Belgium |
1e396fb509ca
updated copyright, as Orthanc Team now replaces Osimis
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
70
diff
changeset
|
5 * Copyright (C) 2021-2024 Sebastien Jodogne, ICTEAM UCLouvain, Belgium |
0 | 6 * |
7 * This program is free software: you can redistribute it and/or | |
8 * modify it under the terms of the GNU Affero General Public License | |
9 * as published by the Free Software Foundation, either version 3 of | |
10 * the License, or (at your option) any later version. | |
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 | |
15 * Affero General Public License for more details. | |
16 * | |
17 * You should have received a copy of the GNU Affero General Public License | |
18 * along with this program. If not, see <http://www.gnu.org/licenses/>. | |
19 **/ | |
20 | |
21 #include "PluginContext.h" | |
22 #include "../Framework/HttpQueries/DetectTransferPlugin.h" | |
23 #include "../Framework/PullMode/PullJob.h" | |
24 #include "../Framework/PushMode/PushJob.h" | |
25 #include "../Framework/TransferScheduler.h" | |
26 | |
27 #include <EmbeddedResources.h> | |
28 | |
25
dfc43678aecb
replacing deprecated std::auto_ptr by std::unique_ptr
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
21
diff
changeset
|
29 #include <Compatibility.h> // For std::unique_ptr |
20 | 30 #include <ChunkedBuffer.h> |
31 #include <Compression/GzipCompressor.h> | |
32 #include <Logging.h> | |
31
cfeda58d0c8e
remove calls to deprecated classes of JsonCpp
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
29
diff
changeset
|
33 #include <Toolbox.h> |
0 | 34 |
35 | |
36 static bool DisplayPerformanceWarning() | |
37 { | |
38 (void) DisplayPerformanceWarning; // Disable warning about unused function | |
39 LOG(WARNING) << "Performance warning in transfers accelerator: " | |
40 << "Non-release build, runtime debug assertions are turned on"; | |
41 return true; | |
42 } | |
43 | |
44 | |
45 static size_t ReadSizeArgument(const OrthancPluginHttpRequest* request, | |
46 uint32_t index) | |
47 { | |
48 std::string value(request->getValues[index]); | |
49 | |
50 try | |
51 { | |
52 int tmp = boost::lexical_cast<int>(value); | |
53 if (tmp >= 0) | |
54 { | |
55 return static_cast<size_t>(tmp); | |
56 } | |
57 } | |
58 catch (boost::bad_lexical_cast&) | |
59 { | |
60 } | |
61 | |
62 LOG(ERROR) << "The \"" << request->getKeys[index] | |
63 << "\" GET argument must be a positive integer: " << value; | |
64 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadParameterType); | |
65 } | |
66 | |
67 | |
68 void ServeChunks(OrthancPluginRestOutput* output, | |
69 const char* url, | |
70 const OrthancPluginHttpRequest* request) | |
71 { | |
72 OrthancPlugins::PluginContext& context = OrthancPlugins::PluginContext::GetInstance(); | |
73 | |
74 if (request->method != OrthancPluginHttpMethod_Get) | |
75 { | |
8
4c3437217518
fix for compatibility with simplified OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5
diff
changeset
|
76 OrthancPluginSendMethodNotAllowed(OrthancPlugins::GetGlobalContext(), output, "GET"); |
0 | 77 return; |
78 } | |
79 | |
80 assert(request->groupsCount == 1); | |
81 | |
82 std::vector<std::string> instances; | |
83 Orthanc::Toolbox::TokenizeString(instances, std::string(request->groups[0]), '.'); | |
84 | |
85 size_t offset = 0; | |
86 size_t requestedSize = 0; | |
87 OrthancPlugins::BucketCompression compression = OrthancPlugins::BucketCompression_None; | |
88 | |
89 for (uint32_t i = 0; i < request->getCount; i++) | |
90 { | |
91 std::string key(request->getKeys[i]); | |
92 | |
93 if (key == "offset") | |
94 { | |
95 offset = ReadSizeArgument(request, i); | |
96 } | |
97 else if (key == "size") | |
98 { | |
99 requestedSize = ReadSizeArgument(request, i); | |
100 } | |
101 else if (key == "compression") | |
102 { | |
103 compression = OrthancPlugins::StringToBucketCompression(request->getValues[i]); | |
104 } | |
105 else | |
106 { | |
107 LOG(INFO) << "Ignored GET argument: " << key; | |
108 } | |
109 } | |
110 | |
111 | |
112 // Limit the number of clients | |
113 Orthanc::Semaphore::Locker lock(context.GetSemaphore()); | |
114 | |
115 Orthanc::ChunkedBuffer buffer; | |
116 | |
117 for (size_t i = 0; i < instances.size() && (requestedSize == 0 || | |
118 buffer.GetNumBytes() < requestedSize); i++) | |
119 { | |
120 size_t instanceSize; | |
121 std::string md5; // Ignored | |
122 context.GetCache().GetInstanceInfo(instanceSize, md5, instances[i]); | |
123 | |
124 if (offset >= instanceSize) | |
125 { | |
126 offset -= instanceSize; | |
127 } | |
128 else | |
129 { | |
130 size_t toRead; | |
131 | |
132 if (requestedSize == 0) | |
133 { | |
134 toRead = instanceSize - offset; | |
135 } | |
136 else | |
137 { | |
138 toRead = requestedSize - buffer.GetNumBytes(); | |
139 | |
140 if (toRead > instanceSize - offset) | |
141 { | |
142 toRead = instanceSize - offset; | |
143 } | |
144 } | |
145 | |
146 std::string chunk; | |
147 std::string md5; // Ignored | |
148 context.GetCache().GetChunk(chunk, md5, instances[i], offset, toRead); | |
149 | |
150 buffer.AddChunk(chunk); | |
151 offset = 0; | |
152 | |
153 assert(requestedSize == 0 || | |
154 buffer.GetNumBytes() <= requestedSize); | |
155 } | |
156 } | |
157 | |
158 std::string chunk; | |
159 buffer.Flatten(chunk); | |
160 | |
161 | |
162 switch (compression) | |
163 { | |
164 case OrthancPlugins::BucketCompression_None: | |
165 { | |
8
4c3437217518
fix for compatibility with simplified OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5
diff
changeset
|
166 OrthancPluginAnswerBuffer(OrthancPlugins::GetGlobalContext(), output, chunk.c_str(), |
0 | 167 chunk.size(), "application/octet-stream"); |
168 break; | |
169 } | |
170 | |
171 case OrthancPlugins::BucketCompression_Gzip: | |
172 { | |
173 std::string compressed; | |
174 Orthanc::GzipCompressor gzip; | |
175 //gzip.SetCompressionLevel(9); | |
176 Orthanc::IBufferCompressor::Compress(compressed, gzip, chunk); | |
8
4c3437217518
fix for compatibility with simplified OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5
diff
changeset
|
177 OrthancPluginAnswerBuffer(OrthancPlugins::GetGlobalContext(), output, compressed.c_str(), |
0 | 178 compressed.size(), "application/gzip"); |
179 break; | |
180 } | |
181 | |
182 default: | |
183 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); | |
184 } | |
185 } | |
186 | |
187 | |
188 | |
189 static bool ParsePostBody(Json::Value& body, | |
190 OrthancPluginRestOutput* output, | |
191 const OrthancPluginHttpRequest* request) | |
192 { | |
193 if (request->method != OrthancPluginHttpMethod_Post) | |
194 { | |
8
4c3437217518
fix for compatibility with simplified OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5
diff
changeset
|
195 OrthancPluginSendMethodNotAllowed(OrthancPlugins::GetGlobalContext(), output, "POST"); |
0 | 196 return false; |
197 } | |
31
cfeda58d0c8e
remove calls to deprecated classes of JsonCpp
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
29
diff
changeset
|
198 else if (Orthanc::Toolbox::ReadJson(body, request->body, request->bodySize)) |
0 | 199 { |
200 return true; | |
201 } | |
202 else | |
203 { | |
204 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat); | |
205 } | |
206 } | |
207 | |
208 | |
209 void LookupInstances(OrthancPluginRestOutput* output, | |
210 const char* url, | |
211 const OrthancPluginHttpRequest* request) | |
212 { | |
213 OrthancPlugins::PluginContext& context = OrthancPlugins::PluginContext::GetInstance(); | |
214 | |
215 Json::Value resources; | |
216 if (!ParsePostBody(resources, output, request)) | |
217 { | |
218 return; | |
219 } | |
220 | |
221 OrthancPlugins::TransferScheduler scheduler; | |
222 scheduler.ParseListOfResources(context.GetCache(), resources); | |
223 | |
224 Json::Value answer = Json::objectValue; | |
225 answer[KEY_INSTANCES] = Json::arrayValue; | |
226 answer[KEY_ORIGINATOR_UUID] = context.GetPluginUuid(); | |
227 answer["CountInstances"] = static_cast<uint32_t>(scheduler.GetInstancesCount()); | |
228 answer["TotalSize"] = boost::lexical_cast<std::string>(scheduler.GetTotalSize()); | |
229 answer["TotalSizeMB"] = OrthancPlugins::ConvertToMegabytes(scheduler.GetTotalSize()); | |
230 | |
231 std::vector<OrthancPlugins::DicomInstanceInfo> instances; | |
232 scheduler.ListInstances(instances); | |
233 | |
234 for (size_t i = 0; i < instances.size(); i++) | |
235 { | |
236 Json::Value instance; | |
237 instances[i].Serialize(instance); | |
238 answer[KEY_INSTANCES].append(instance); | |
239 } | |
240 | |
31
cfeda58d0c8e
remove calls to deprecated classes of JsonCpp
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
29
diff
changeset
|
241 std::string s; |
cfeda58d0c8e
remove calls to deprecated classes of JsonCpp
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
29
diff
changeset
|
242 Orthanc::Toolbox::WriteFastJson(s, answer); |
8
4c3437217518
fix for compatibility with simplified OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5
diff
changeset
|
243 OrthancPluginAnswerBuffer(OrthancPlugins::GetGlobalContext(), output, s.c_str(), s.size(), "application/json"); |
0 | 244 } |
245 | |
246 | |
247 | |
248 static void SubmitJob(OrthancPluginRestOutput* output, | |
249 OrthancPlugins::OrthancJob* job, | |
250 int priority) | |
251 { | |
8
4c3437217518
fix for compatibility with simplified OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5
diff
changeset
|
252 std::string id = OrthancPlugins::OrthancJob::Submit(job, priority); |
0 | 253 |
254 Json::Value result = Json::objectValue; | |
255 result[KEY_ID] = id; | |
256 result[KEY_PATH] = std::string(URI_JOBS) + "/" + id; | |
257 | |
258 std::string s = result.toStyledString(); | |
8
4c3437217518
fix for compatibility with simplified OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5
diff
changeset
|
259 OrthancPluginAnswerBuffer(OrthancPlugins::GetGlobalContext(), output, s.c_str(), s.size(), "application/json"); |
0 | 260 } |
261 | |
262 | |
263 | |
264 void SchedulePull(OrthancPluginRestOutput* output, | |
265 const char* url, | |
266 const OrthancPluginHttpRequest* request) | |
267 { | |
268 OrthancPlugins::PluginContext& context = OrthancPlugins::PluginContext::GetInstance(); | |
269 | |
270 Json::Value body; | |
271 if (!ParsePostBody(body, output, request)) | |
272 { | |
273 return; | |
274 } | |
275 | |
276 OrthancPlugins::TransferQuery query(body); | |
277 | |
10
c9e28e31262e
new option: MaxHttpRetries
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
9
diff
changeset
|
278 SubmitJob(output, new OrthancPlugins::PullJob(query, context.GetThreadsCount(), |
c9e28e31262e
new option: MaxHttpRetries
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
9
diff
changeset
|
279 context.GetTargetBucketSize(), |
c9e28e31262e
new option: MaxHttpRetries
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
9
diff
changeset
|
280 context.GetMaxHttpRetries()), |
0 | 281 query.GetPriority()); |
282 } | |
283 | |
284 | |
285 | |
286 void CreatePush(OrthancPluginRestOutput* output, | |
287 const char* url, | |
288 const OrthancPluginHttpRequest* request) | |
289 { | |
290 OrthancPlugins::PluginContext& context = OrthancPlugins::PluginContext::GetInstance(); | |
291 | |
292 Json::Value query; | |
293 if (!ParsePostBody(query, output, request)) | |
294 { | |
295 return; | |
296 } | |
297 | |
298 if (query.type() != Json::objectValue || | |
299 !query.isMember(KEY_BUCKETS) || | |
300 !query.isMember(KEY_COMPRESSION) || | |
301 !query.isMember(KEY_INSTANCES) || | |
302 query[KEY_BUCKETS].type() != Json::arrayValue || | |
303 query[KEY_COMPRESSION].type() != Json::stringValue || | |
304 query[KEY_INSTANCES].type() != Json::arrayValue) | |
305 { | |
306 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat); | |
307 } | |
308 | |
309 std::vector<OrthancPlugins::DicomInstanceInfo> instances; | |
310 instances.reserve(query[KEY_INSTANCES].size()); | |
311 | |
312 for (Json::Value::ArrayIndex i = 0; i < query[KEY_INSTANCES].size(); i++) | |
313 { | |
314 OrthancPlugins::DicomInstanceInfo instance(query[KEY_INSTANCES][i]); | |
315 instances.push_back(instance); | |
316 } | |
317 | |
318 std::vector<OrthancPlugins::TransferBucket> buckets; | |
319 buckets.reserve(query[KEY_BUCKETS].size()); | |
320 | |
321 for (Json::Value::ArrayIndex i = 0; i < query[KEY_BUCKETS].size(); i++) | |
322 { | |
323 OrthancPlugins::TransferBucket bucket(query[KEY_BUCKETS][i]); | |
324 buckets.push_back(bucket); | |
325 } | |
326 | |
327 OrthancPlugins::BucketCompression compression = | |
328 OrthancPlugins::StringToBucketCompression(query[KEY_COMPRESSION].asString()); | |
329 | |
330 std::string id = context.GetActivePushTransactions().CreateTransaction | |
331 (instances, buckets, compression); | |
332 | |
333 Json::Value result = Json::objectValue; | |
334 result[KEY_ID] = id; | |
335 result[KEY_PATH] = std::string(URI_PUSH) + "/" + id; | |
336 | |
337 std::string s = result.toStyledString(); | |
8
4c3437217518
fix for compatibility with simplified OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5
diff
changeset
|
338 OrthancPluginAnswerBuffer(OrthancPlugins::GetGlobalContext(), output, s.c_str(), s.size(), "application/json"); |
0 | 339 } |
340 | |
341 | |
342 void StorePush(OrthancPluginRestOutput* output, | |
343 const char* url, | |
344 const OrthancPluginHttpRequest* request) | |
345 { | |
346 OrthancPlugins::PluginContext& context = OrthancPlugins::PluginContext::GetInstance(); | |
347 | |
348 if (request->method != OrthancPluginHttpMethod_Put) | |
349 { | |
8
4c3437217518
fix for compatibility with simplified OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5
diff
changeset
|
350 OrthancPluginSendMethodNotAllowed(OrthancPlugins::GetGlobalContext(), output, "PUT"); |
0 | 351 return; |
352 } | |
353 | |
354 assert(request->groupsCount == 2); | |
355 std::string transaction(request->groups[0]); | |
356 std::string chunk(request->groups[1]); | |
357 | |
358 size_t chunkIndex; | |
359 | |
360 try | |
361 { | |
362 chunkIndex = boost::lexical_cast<size_t>(chunk); | |
363 } | |
364 catch (boost::bad_lexical_cast&) | |
365 { | |
366 throw Orthanc::OrthancException(Orthanc::ErrorCode_UnknownResource); | |
367 } | |
368 | |
369 context.GetActivePushTransactions().Store | |
8
4c3437217518
fix for compatibility with simplified OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5
diff
changeset
|
370 (transaction, chunkIndex, request->body, request->bodySize); |
0 | 371 |
372 std::string s = "{}"; | |
8
4c3437217518
fix for compatibility with simplified OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5
diff
changeset
|
373 OrthancPluginAnswerBuffer(OrthancPlugins::GetGlobalContext(), output, s.c_str(), s.size(), "application/json"); |
0 | 374 } |
375 | |
376 | |
377 void CommitPush(OrthancPluginRestOutput* output, | |
378 const char* url, | |
379 const OrthancPluginHttpRequest* request) | |
380 { | |
381 OrthancPlugins::PluginContext& context = OrthancPlugins::PluginContext::GetInstance(); | |
382 | |
383 if (request->method != OrthancPluginHttpMethod_Post) | |
384 { | |
8
4c3437217518
fix for compatibility with simplified OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5
diff
changeset
|
385 OrthancPluginSendMethodNotAllowed(OrthancPlugins::GetGlobalContext(), output, "POST"); |
0 | 386 return; |
387 } | |
388 | |
389 assert(request->groupsCount == 1); | |
390 std::string transaction(request->groups[0]); | |
391 | |
8
4c3437217518
fix for compatibility with simplified OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5
diff
changeset
|
392 context.GetActivePushTransactions().Commit(transaction); |
0 | 393 |
394 std::string s = "{}"; | |
8
4c3437217518
fix for compatibility with simplified OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5
diff
changeset
|
395 OrthancPluginAnswerBuffer(OrthancPlugins::GetGlobalContext(), output, s.c_str(), s.size(), "application/json"); |
0 | 396 } |
397 | |
398 | |
399 void DiscardPush(OrthancPluginRestOutput* output, | |
400 const char* url, | |
401 const OrthancPluginHttpRequest* request) | |
402 { | |
403 OrthancPlugins::PluginContext& context = OrthancPlugins::PluginContext::GetInstance(); | |
404 | |
405 if (request->method != OrthancPluginHttpMethod_Delete) | |
406 { | |
8
4c3437217518
fix for compatibility with simplified OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5
diff
changeset
|
407 OrthancPluginSendMethodNotAllowed(OrthancPlugins::GetGlobalContext(), output, "DELETE"); |
0 | 408 return; |
409 } | |
410 | |
411 assert(request->groupsCount == 1); | |
412 std::string transaction(request->groups[0]); | |
413 | |
414 context. | |
415 GetActivePushTransactions().Discard(transaction); | |
416 | |
417 std::string s = "{}"; | |
8
4c3437217518
fix for compatibility with simplified OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5
diff
changeset
|
418 OrthancPluginAnswerBuffer(OrthancPlugins::GetGlobalContext(), output, s.c_str(), s.size(), "application/json"); |
0 | 419 } |
420 | |
421 | |
422 | |
423 void ScheduleSend(OrthancPluginRestOutput* output, | |
424 const char* url, | |
425 const OrthancPluginHttpRequest* request) | |
426 { | |
427 OrthancPlugins::PluginContext& context = OrthancPlugins::PluginContext::GetInstance(); | |
428 | |
429 Json::Value body; | |
430 if (!ParsePostBody(body, output, request)) | |
431 { | |
432 return; | |
433 } | |
434 | |
435 OrthancPlugins::TransferQuery query(body); | |
436 | |
8
4c3437217518
fix for compatibility with simplified OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5
diff
changeset
|
437 OrthancPlugins::OrthancPeers peers; |
5
5e6de82bb10f
use of user properties instead of BidirectionalPeers option
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4
diff
changeset
|
438 |
0 | 439 std::string remoteSelf; // For pull mode |
5
5e6de82bb10f
use of user properties instead of BidirectionalPeers option
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4
diff
changeset
|
440 bool pullMode = peers.LookupUserProperty(remoteSelf, query.GetPeer(), KEY_REMOTE_SELF); |
0 | 441 |
442 LOG(INFO) << "Sending resources to peer \"" << query.GetPeer() << "\" using " | |
443 << (pullMode ? "pull" : "push") << " mode"; | |
444 | |
445 if (pullMode) | |
446 { | |
447 Json::Value lookup = Json::objectValue; | |
448 lookup[KEY_RESOURCES] = query.GetResources(); | |
449 lookup[KEY_COMPRESSION] = OrthancPlugins::EnumerationToString(query.GetCompression()); | |
450 lookup[KEY_ORIGINATOR_UUID] = context.GetPluginUuid(); | |
451 lookup[KEY_PEER] = remoteSelf; | |
452 | |
31
cfeda58d0c8e
remove calls to deprecated classes of JsonCpp
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
29
diff
changeset
|
453 std::string s; |
cfeda58d0c8e
remove calls to deprecated classes of JsonCpp
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
29
diff
changeset
|
454 Orthanc::Toolbox::WriteFastJson(s, lookup); |
0 | 455 |
456 Json::Value answer; | |
44
f4e828607f02
Added 'SenderTransferID' option that is added as an HTTP header in outgoing requests in PushMode
Alain Mazy <am@osimis.io>
parents:
33
diff
changeset
|
457 std::map<std::string, std::string> headers; |
f4e828607f02
Added 'SenderTransferID' option that is added as an HTTP header in outgoing requests in PushMode
Alain Mazy <am@osimis.io>
parents:
33
diff
changeset
|
458 query.GetHttpHeaders(headers); |
f4e828607f02
Added 'SenderTransferID' option that is added as an HTTP header in outgoing requests in PushMode
Alain Mazy <am@osimis.io>
parents:
33
diff
changeset
|
459 |
f4e828607f02
Added 'SenderTransferID' option that is added as an HTTP header in outgoing requests in PushMode
Alain Mazy <am@osimis.io>
parents:
33
diff
changeset
|
460 if (DoPostPeer(answer, peers, query.GetPeer(), URI_PULL, s, context.GetMaxHttpRetries(), headers) && |
0 | 461 answer.type() == Json::objectValue && |
462 answer.isMember(KEY_ID) && | |
463 answer.isMember(KEY_PATH) && | |
464 answer[KEY_ID].type() == Json::stringValue && | |
465 answer[KEY_PATH].type() == Json::stringValue) | |
466 { | |
467 const std::string url = peers.GetPeerUrl(query.GetPeer()); | |
468 | |
469 Json::Value result = Json::objectValue; | |
470 result[KEY_PEER] = query.GetPeer(); | |
471 result[KEY_REMOTE_JOB] = answer[KEY_ID].asString(); | |
472 result[KEY_URL] = url + answer[KEY_PATH].asString(); | |
473 | |
474 std::string s = result.toStyledString(); | |
8
4c3437217518
fix for compatibility with simplified OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5
diff
changeset
|
475 OrthancPluginAnswerBuffer(OrthancPlugins::GetGlobalContext(), output, s.c_str(), s.size(), "application/json"); |
0 | 476 } |
477 else | |
478 { | |
479 LOG(ERROR) << "Cannot trigger send DICOM instances using pull mode to peer: " << query.GetPeer() | |
480 << " (check out remote logs, and that transfer plugin is installed)"; | |
481 throw Orthanc::OrthancException(Orthanc::ErrorCode_NetworkProtocol); | |
482 } | |
483 } | |
484 else | |
485 { | |
8
4c3437217518
fix for compatibility with simplified OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5
diff
changeset
|
486 SubmitJob(output, new OrthancPlugins::PushJob(query, context.GetCache(), |
10
c9e28e31262e
new option: MaxHttpRetries
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
9
diff
changeset
|
487 context.GetThreadsCount(), |
c9e28e31262e
new option: MaxHttpRetries
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
9
diff
changeset
|
488 context.GetTargetBucketSize(), |
c9e28e31262e
new option: MaxHttpRetries
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
9
diff
changeset
|
489 context.GetMaxHttpRetries()), |
0 | 490 query.GetPriority()); |
491 } | |
492 } | |
493 | |
494 | |
495 OrthancPluginJob* Unserializer(const char* jobType, | |
496 const char* serialized) | |
497 { | |
498 OrthancPlugins::PluginContext& context = OrthancPlugins::PluginContext::GetInstance(); | |
499 | |
500 if (jobType == NULL || | |
501 serialized == NULL) | |
502 { | |
503 return NULL; | |
504 } | |
505 | |
506 std::string type(jobType); | |
507 | |
508 if (type != JOB_TYPE_PULL && | |
509 type != JOB_TYPE_PUSH) | |
510 { | |
511 return NULL; | |
512 } | |
513 | |
514 try | |
515 { | |
516 std::string tmp(serialized); | |
517 | |
518 Json::Value source; | |
31
cfeda58d0c8e
remove calls to deprecated classes of JsonCpp
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
29
diff
changeset
|
519 if (Orthanc::Toolbox::ReadJson(source, tmp)) |
0 | 520 { |
521 OrthancPlugins::TransferQuery query(source); | |
522 | |
25
dfc43678aecb
replacing deprecated std::auto_ptr by std::unique_ptr
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
21
diff
changeset
|
523 std::unique_ptr<OrthancPlugins::OrthancJob> job; |
0 | 524 |
525 if (type == JOB_TYPE_PULL) | |
526 { | |
8
4c3437217518
fix for compatibility with simplified OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5
diff
changeset
|
527 job.reset(new OrthancPlugins::PullJob(query, |
0 | 528 context.GetThreadsCount(), |
10
c9e28e31262e
new option: MaxHttpRetries
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
9
diff
changeset
|
529 context.GetTargetBucketSize(), |
c9e28e31262e
new option: MaxHttpRetries
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
9
diff
changeset
|
530 context.GetMaxHttpRetries())); |
0 | 531 } |
532 else if (type == JOB_TYPE_PUSH) | |
533 { | |
8
4c3437217518
fix for compatibility with simplified OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5
diff
changeset
|
534 job.reset(new OrthancPlugins::PushJob(query, |
0 | 535 context.GetCache(), |
536 context.GetThreadsCount(), | |
10
c9e28e31262e
new option: MaxHttpRetries
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
9
diff
changeset
|
537 context.GetTargetBucketSize(), |
c9e28e31262e
new option: MaxHttpRetries
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
9
diff
changeset
|
538 context.GetMaxHttpRetries())); |
0 | 539 } |
540 | |
541 if (job.get() == NULL) | |
542 { | |
543 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); | |
544 } | |
545 else | |
546 { | |
8
4c3437217518
fix for compatibility with simplified OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5
diff
changeset
|
547 return OrthancPlugins::OrthancJob::Create(job.release()); |
0 | 548 } |
549 } | |
550 else | |
551 { | |
552 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat); | |
553 } | |
554 } | |
555 catch (Orthanc::OrthancException& e) | |
556 { | |
557 LOG(ERROR) << "Error while unserializing a job from the transfers accelerator plugin: " | |
558 << e.What(); | |
559 return NULL; | |
560 } | |
561 catch (...) | |
562 { | |
563 LOG(ERROR) << "Error while unserializing a job from the transfers accelerator plugin"; | |
564 return NULL; | |
565 } | |
566 } | |
567 | |
568 | |
569 | |
570 void ServePeers(OrthancPluginRestOutput* output, | |
571 const char* url, | |
572 const OrthancPluginHttpRequest* request) | |
573 { | |
574 OrthancPlugins::PluginContext& context = OrthancPlugins::PluginContext::GetInstance(); | |
575 | |
576 if (request->method != OrthancPluginHttpMethod_Get) | |
577 { | |
8
4c3437217518
fix for compatibility with simplified OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5
diff
changeset
|
578 OrthancPluginSendMethodNotAllowed(OrthancPlugins::GetGlobalContext(), output, "GET"); |
0 | 579 return; |
580 } | |
581 | |
5
5e6de82bb10f
use of user properties instead of BidirectionalPeers option
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4
diff
changeset
|
582 OrthancPlugins::DetectTransferPlugin::Result detection; |
0 | 583 OrthancPlugins::DetectTransferPlugin::Apply |
55
b09adb6aa199
new PeerConnectivityTimeout configuration
Alain Mazy <am@osimis.io>
parents:
44
diff
changeset
|
584 (detection, context.GetThreadsCount(), context.GetPeerConnectivityTimeout()); |
4
1ed03945c057
showing unavailable peers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
585 |
1ed03945c057
showing unavailable peers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
586 Json::Value result = Json::objectValue; |
1ed03945c057
showing unavailable peers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
587 |
8
4c3437217518
fix for compatibility with simplified OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5
diff
changeset
|
588 OrthancPlugins::OrthancPeers peers; |
5
5e6de82bb10f
use of user properties instead of BidirectionalPeers option
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4
diff
changeset
|
589 |
5e6de82bb10f
use of user properties instead of BidirectionalPeers option
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4
diff
changeset
|
590 for (OrthancPlugins::DetectTransferPlugin::Result::const_iterator |
5e6de82bb10f
use of user properties instead of BidirectionalPeers option
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4
diff
changeset
|
591 it = detection.begin(); it != detection.end(); ++it) |
4
1ed03945c057
showing unavailable peers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
592 { |
5
5e6de82bb10f
use of user properties instead of BidirectionalPeers option
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4
diff
changeset
|
593 if (it->second) |
4
1ed03945c057
showing unavailable peers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
594 { |
5
5e6de82bb10f
use of user properties instead of BidirectionalPeers option
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4
diff
changeset
|
595 std::string remoteSelf; |
0 | 596 |
5
5e6de82bb10f
use of user properties instead of BidirectionalPeers option
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4
diff
changeset
|
597 if (peers.LookupUserProperty(remoteSelf, it->first, KEY_REMOTE_SELF)) |
5e6de82bb10f
use of user properties instead of BidirectionalPeers option
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4
diff
changeset
|
598 { |
5e6de82bb10f
use of user properties instead of BidirectionalPeers option
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4
diff
changeset
|
599 result[it->first] = "bidirectional"; |
4
1ed03945c057
showing unavailable peers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
600 } |
5
5e6de82bb10f
use of user properties instead of BidirectionalPeers option
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4
diff
changeset
|
601 else |
5e6de82bb10f
use of user properties instead of BidirectionalPeers option
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4
diff
changeset
|
602 { |
5e6de82bb10f
use of user properties instead of BidirectionalPeers option
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4
diff
changeset
|
603 result[it->first] = "installed"; |
5e6de82bb10f
use of user properties instead of BidirectionalPeers option
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4
diff
changeset
|
604 } |
5e6de82bb10f
use of user properties instead of BidirectionalPeers option
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4
diff
changeset
|
605 } |
5e6de82bb10f
use of user properties instead of BidirectionalPeers option
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4
diff
changeset
|
606 else |
5e6de82bb10f
use of user properties instead of BidirectionalPeers option
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4
diff
changeset
|
607 { |
5e6de82bb10f
use of user properties instead of BidirectionalPeers option
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4
diff
changeset
|
608 result[it->first] = "disabled"; |
4
1ed03945c057
showing unavailable peers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
0
diff
changeset
|
609 } |
0 | 610 } |
611 | |
612 std::string s = result.toStyledString(); | |
8
4c3437217518
fix for compatibility with simplified OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5
diff
changeset
|
613 OrthancPluginAnswerBuffer(OrthancPlugins::GetGlobalContext(), output, s.c_str(), s.size(), "application/json"); |
0 | 614 } |
615 | |
616 | |
617 | |
618 extern "C" | |
619 { | |
620 ORTHANC_PLUGINS_API int32_t OrthancPluginInitialize(OrthancPluginContext* context) | |
621 { | |
29
a0af5a8182a8
sync, removed old patch for Orthanc framework 1.5.6
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
25
diff
changeset
|
622 #if ORTHANC_FRAMEWORK_VERSION_IS_ABOVE(1, 7, 2) |
20 | 623 Orthanc::Logging::InitializePluginContext(context); |
21
7c8dfa752242
improved Orthanc::Logging::Initialize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
20
diff
changeset
|
624 #else |
7c8dfa752242
improved Orthanc::Logging::Initialize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
20
diff
changeset
|
625 Orthanc::Logging::Initialize(context); |
7c8dfa752242
improved Orthanc::Logging::Initialize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
20
diff
changeset
|
626 #endif |
7c8dfa752242
improved Orthanc::Logging::Initialize()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
20
diff
changeset
|
627 |
0 | 628 assert(DisplayPerformanceWarning()); |
629 | |
8
4c3437217518
fix for compatibility with simplified OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5
diff
changeset
|
630 OrthancPlugins::SetGlobalContext(context); |
4c3437217518
fix for compatibility with simplified OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5
diff
changeset
|
631 |
0 | 632 /* Check the version of the Orthanc core */ |
633 if (OrthancPluginCheckVersion(context) == 0) | |
634 { | |
635 LOG(ERROR) << "Your version of Orthanc (" | |
636 << context->orthancVersion << ") must be above " | |
637 << ORTHANC_PLUGINS_MINIMAL_MAJOR_NUMBER << "." | |
638 << ORTHANC_PLUGINS_MINIMAL_MINOR_NUMBER << "." | |
639 << ORTHANC_PLUGINS_MINIMAL_REVISION_NUMBER | |
640 << " to run this plugin"; | |
641 return -1; | |
642 } | |
643 | |
70
3f43bfbea00e
fix deprecated calls
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
55
diff
changeset
|
644 OrthancPlugins::SetDescription(PLUGIN_NAME, "Accelerates transfers and provides " |
3f43bfbea00e
fix deprecated calls
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
55
diff
changeset
|
645 "storage commitment between Orthanc peers"); |
0 | 646 |
647 try | |
648 { | |
649 size_t threadsCount = 4; | |
650 size_t targetBucketSize = 4096; // In KB | |
651 size_t maxPushTransactions = 4; | |
652 size_t memoryCacheSize = 512; // In MB | |
10
c9e28e31262e
new option: MaxHttpRetries
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
9
diff
changeset
|
653 unsigned int maxHttpRetries = 0; |
55
b09adb6aa199
new PeerConnectivityTimeout configuration
Alain Mazy <am@osimis.io>
parents:
44
diff
changeset
|
654 unsigned int peerConnectivityTimeout = 2; |
0 | 655 |
656 { | |
8
4c3437217518
fix for compatibility with simplified OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5
diff
changeset
|
657 OrthancPlugins::OrthancConfiguration config; |
0 | 658 |
659 if (config.IsSection(KEY_PLUGIN_CONFIGURATION)) | |
660 { | |
661 OrthancPlugins::OrthancConfiguration plugin; | |
662 config.GetSection(plugin, KEY_PLUGIN_CONFIGURATION); | |
663 | |
664 threadsCount = plugin.GetUnsignedIntegerValue("Threads", threadsCount); | |
665 targetBucketSize = plugin.GetUnsignedIntegerValue("BucketSize", targetBucketSize); | |
666 memoryCacheSize = plugin.GetUnsignedIntegerValue("CacheSize", memoryCacheSize); | |
10
c9e28e31262e
new option: MaxHttpRetries
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
9
diff
changeset
|
667 maxPushTransactions = plugin.GetUnsignedIntegerValue("MaxPushTransactions", maxPushTransactions); |
c9e28e31262e
new option: MaxHttpRetries
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
9
diff
changeset
|
668 maxHttpRetries = plugin.GetUnsignedIntegerValue("MaxHttpRetries", maxHttpRetries); |
55
b09adb6aa199
new PeerConnectivityTimeout configuration
Alain Mazy <am@osimis.io>
parents:
44
diff
changeset
|
669 peerConnectivityTimeout = plugin.GetUnsignedIntegerValue("PeerConnectivityTimeout", peerConnectivityTimeout); |
0 | 670 } |
671 } | |
672 | |
10
c9e28e31262e
new option: MaxHttpRetries
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
9
diff
changeset
|
673 OrthancPlugins::PluginContext::Initialize(threadsCount, targetBucketSize * KB, maxPushTransactions, |
55
b09adb6aa199
new PeerConnectivityTimeout configuration
Alain Mazy <am@osimis.io>
parents:
44
diff
changeset
|
674 memoryCacheSize * MB, maxHttpRetries, peerConnectivityTimeout); |
0 | 675 |
676 OrthancPlugins::RegisterRestCallback<ServeChunks> | |
8
4c3437217518
fix for compatibility with simplified OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5
diff
changeset
|
677 (std::string(URI_CHUNKS) + "/([.0-9a-f-]+)", true); |
0 | 678 |
679 OrthancPlugins::RegisterRestCallback<LookupInstances> | |
8
4c3437217518
fix for compatibility with simplified OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5
diff
changeset
|
680 (URI_LOOKUP, true); |
0 | 681 |
682 OrthancPlugins::RegisterRestCallback<SchedulePull> | |
8
4c3437217518
fix for compatibility with simplified OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5
diff
changeset
|
683 (URI_PULL, true); |
0 | 684 |
685 OrthancPlugins::RegisterRestCallback<ScheduleSend> | |
8
4c3437217518
fix for compatibility with simplified OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5
diff
changeset
|
686 (URI_SEND, true); |
0 | 687 |
688 OrthancPlugins::RegisterRestCallback<ServePeers> | |
8
4c3437217518
fix for compatibility with simplified OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5
diff
changeset
|
689 (URI_PEERS, true); |
0 | 690 |
691 if (maxPushTransactions != 0) | |
692 { | |
693 // If no push transaction is allowed, their URIs are disabled | |
694 OrthancPlugins::RegisterRestCallback<CreatePush> | |
8
4c3437217518
fix for compatibility with simplified OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5
diff
changeset
|
695 (URI_PUSH, true); |
0 | 696 |
697 OrthancPlugins::RegisterRestCallback<StorePush> | |
8
4c3437217518
fix for compatibility with simplified OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5
diff
changeset
|
698 (std::string(URI_PUSH) + "/([.0-9a-f-]+)/([0-9]+)", true); |
0 | 699 |
700 OrthancPlugins::RegisterRestCallback<CommitPush> | |
8
4c3437217518
fix for compatibility with simplified OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5
diff
changeset
|
701 (std::string(URI_PUSH) + "/([.0-9a-f-]+)/commit", true); |
0 | 702 |
703 OrthancPlugins::RegisterRestCallback<DiscardPush> | |
8
4c3437217518
fix for compatibility with simplified OrthancPluginCppWrapper
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
5
diff
changeset
|
704 (std::string(URI_PUSH) + "/([.0-9a-f-]+)", true); |
0 | 705 } |
706 | |
707 OrthancPluginRegisterJobsUnserializer(context, Unserializer); | |
708 | |
709 /* Extend the default Orthanc Explorer with custom JavaScript */ | |
710 std::string explorer; | |
711 Orthanc::EmbeddedResources::GetFileResource | |
712 (explorer, Orthanc::EmbeddedResources::ORTHANC_EXPLORER); | |
70
3f43bfbea00e
fix deprecated calls
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
55
diff
changeset
|
713 OrthancPlugins::ExtendOrthancExplorer(PLUGIN_NAME, explorer); |
0 | 714 } |
715 catch (Orthanc::OrthancException& e) | |
716 { | |
717 LOG(ERROR) << "Cannot initialize transfers accelerator plugin: " << e.What(); | |
718 return -1; | |
719 } | |
720 | |
721 return 0; | |
722 } | |
723 | |
724 | |
725 ORTHANC_PLUGINS_API void OrthancPluginFinalize() | |
726 { | |
727 LOG(WARNING) << "Transfers accelerator plugin is finalizing"; | |
728 | |
729 try | |
730 { | |
731 OrthancPlugins::PluginContext::Finalize(); | |
732 } | |
733 catch (Orthanc::OrthancException& e) | |
734 { | |
735 LOG(ERROR) << "Error while finalizing the transfers accelerator plugin: " << e.What(); | |
736 } | |
737 } | |
738 | |
739 | |
740 ORTHANC_PLUGINS_API const char* OrthancPluginGetName() | |
741 { | |
742 return PLUGIN_NAME; | |
743 } | |
744 | |
745 | |
746 ORTHANC_PLUGINS_API const char* OrthancPluginGetVersion() | |
747 { | |
748 return ORTHANC_PLUGIN_VERSION; | |
749 } | |
750 } |