Mercurial > hg > orthanc
comparison OrthancServer/main.cpp @ 1364:111e23bb4904 query-retrieve
integration mainline->query-retrieve
author | Sebastien Jodogne <s.jodogne@gmail.com> |
---|---|
date | Thu, 21 May 2015 16:58:30 +0200 |
parents | c2c28dd17e87 b7351ecb79b4 |
children | a3559b66fba7 |
comparison
equal
deleted
inserted
replaced
953:f894be6e7cc1 | 1364:111e23bb4904 |
---|---|
1 /** | 1 /** |
2 * Orthanc - A Lightweight, RESTful DICOM Store | 2 * Orthanc - A Lightweight, RESTful DICOM Store |
3 * Copyright (C) 2012-2014 Medical Physics Department, CHU of Liege, | 3 * Copyright (C) 2012-2015 Sebastien Jodogne, Medical Physics |
4 * Belgium | 4 * Department, University Hospital of Liege, Belgium |
5 * | 5 * |
6 * This program is free software: you can redistribute it and/or | 6 * This program is free software: you can redistribute it and/or |
7 * modify it under the terms of the GNU General Public License as | 7 * modify it under the terms of the GNU General Public License as |
8 * published by the Free Software Foundation, either version 3 of the | 8 * published by the Free Software Foundation, either version 3 of the |
9 * License, or (at your option) any later version. | 9 * License, or (at your option) any later version. |
35 | 35 |
36 #include <fstream> | 36 #include <fstream> |
37 #include <glog/logging.h> | 37 #include <glog/logging.h> |
38 #include <boost/algorithm/string/predicate.hpp> | 38 #include <boost/algorithm/string/predicate.hpp> |
39 | 39 |
40 #include "../Core/Uuid.h" | |
40 #include "../Core/HttpServer/EmbeddedResourceHttpHandler.h" | 41 #include "../Core/HttpServer/EmbeddedResourceHttpHandler.h" |
41 #include "../Core/HttpServer/FilesystemHttpHandler.h" | 42 #include "../Core/HttpServer/FilesystemHttpHandler.h" |
42 #include "../Core/Lua/LuaFunctionCall.h" | 43 #include "../Core/Lua/LuaFunctionCall.h" |
43 #include "../Core/DicomFormat/DicomArray.h" | 44 #include "../Core/DicomFormat/DicomArray.h" |
44 #include "DicomProtocol/DicomServer.h" | 45 #include "DicomProtocol/DicomServer.h" |
46 #include "OrthancInitialization.h" | 47 #include "OrthancInitialization.h" |
47 #include "ServerContext.h" | 48 #include "ServerContext.h" |
48 #include "OrthancFindRequestHandler.h" | 49 #include "OrthancFindRequestHandler.h" |
49 #include "OrthancMoveRequestHandler.h" | 50 #include "OrthancMoveRequestHandler.h" |
50 #include "ServerToolbox.h" | 51 #include "ServerToolbox.h" |
52 #include "../Plugins/Engine/PluginsManager.h" | |
53 #include "../Plugins/Engine/OrthancPlugins.h" | |
51 | 54 |
52 using namespace Orthanc; | 55 using namespace Orthanc; |
53 | 56 |
57 | |
58 #define ENABLE_PLUGINS 1 | |
54 | 59 |
55 | 60 |
56 class OrthancStoreRequestHandler : public IStoreRequestHandler | 61 class OrthancStoreRequestHandler : public IStoreRequestHandler |
57 { | 62 { |
58 private: | 63 private: |
65 } | 70 } |
66 | 71 |
67 virtual void Handle(const std::string& dicomFile, | 72 virtual void Handle(const std::string& dicomFile, |
68 const DicomMap& dicomSummary, | 73 const DicomMap& dicomSummary, |
69 const Json::Value& dicomJson, | 74 const Json::Value& dicomJson, |
70 const std::string& remoteAet) | 75 const std::string& remoteAet, |
76 const std::string& calledAet) | |
71 { | 77 { |
72 if (dicomFile.size() > 0) | 78 if (dicomFile.size() > 0) |
73 { | 79 { |
74 server_.Store(&dicomFile[0], dicomFile.size(), dicomSummary, dicomJson, remoteAet); | 80 DicomInstanceToStore toStore; |
81 toStore.SetBuffer(dicomFile); | |
82 toStore.SetSummary(dicomSummary); | |
83 toStore.SetJson(dicomJson); | |
84 toStore.SetRemoteAet(remoteAet); | |
85 toStore.SetCalledAet(calledAet); | |
86 | |
87 std::string id; | |
88 server_.Store(id, toStore); | |
75 } | 89 } |
76 } | 90 } |
77 }; | 91 }; |
78 | 92 |
79 | 93 |
137 }; | 151 }; |
138 | 152 |
139 | 153 |
140 class OrthancApplicationEntityFilter : public IApplicationEntityFilter | 154 class OrthancApplicationEntityFilter : public IApplicationEntityFilter |
141 { | 155 { |
156 private: | |
157 ServerContext& context_; | |
158 | |
142 public: | 159 public: |
160 OrthancApplicationEntityFilter(ServerContext& context) : context_(context) | |
161 { | |
162 } | |
163 | |
143 virtual bool IsAllowedConnection(const std::string& /*callingIp*/, | 164 virtual bool IsAllowedConnection(const std::string& /*callingIp*/, |
144 const std::string& /*callingAet*/) | 165 const std::string& /*callingAet*/) |
145 { | 166 { |
146 return true; | 167 return true; |
147 } | 168 } |
163 } | 184 } |
164 else | 185 else |
165 { | 186 { |
166 return true; | 187 return true; |
167 } | 188 } |
189 } | |
190 | |
191 virtual bool IsAllowedTransferSyntax(const std::string& callingIp, | |
192 const std::string& callingAet, | |
193 TransferSyntax syntax) | |
194 { | |
195 std::string configuration; | |
196 | |
197 switch (syntax) | |
198 { | |
199 case TransferSyntax_Deflated: | |
200 configuration = "DeflatedTransferSyntaxAccepted"; | |
201 break; | |
202 | |
203 case TransferSyntax_Jpeg: | |
204 configuration = "JpegTransferSyntaxAccepted"; | |
205 break; | |
206 | |
207 case TransferSyntax_Jpeg2000: | |
208 configuration = "Jpeg2000TransferSyntaxAccepted"; | |
209 break; | |
210 | |
211 case TransferSyntax_JpegLossless: | |
212 configuration = "JpegLosslessTransferSyntaxAccepted"; | |
213 break; | |
214 | |
215 case TransferSyntax_Jpip: | |
216 configuration = "JpipTransferSyntaxAccepted"; | |
217 break; | |
218 | |
219 case TransferSyntax_Mpeg2: | |
220 configuration = "Mpeg2TransferSyntaxAccepted"; | |
221 break; | |
222 | |
223 case TransferSyntax_Rle: | |
224 configuration = "RleTransferSyntaxAccepted"; | |
225 break; | |
226 | |
227 default: | |
228 throw OrthancException(ErrorCode_ParameterOutOfRange); | |
229 } | |
230 | |
231 { | |
232 std::string lua = "Is" + configuration; | |
233 | |
234 ServerContext::LuaContextLocker locker(context_); | |
235 | |
236 if (locker.GetLua().IsExistingFunction(lua.c_str())) | |
237 { | |
238 LuaFunctionCall call(locker.GetLua(), lua.c_str()); | |
239 call.PushString(callingAet); | |
240 call.PushString(callingIp); | |
241 return call.ExecutePredicate(); | |
242 } | |
243 } | |
244 | |
245 return Configuration::GetGlobalBoolParameter(configuration, true); | |
168 } | 246 } |
169 }; | 247 }; |
170 | 248 |
171 | 249 |
172 class MyIncomingHttpRequestFilter : public IIncomingHttpRequestFilter | 250 class MyIncomingHttpRequestFilter : public IIncomingHttpRequestFilter |
184 const char* ip, | 262 const char* ip, |
185 const char* username) const | 263 const char* username) const |
186 { | 264 { |
187 static const char* HTTP_FILTER = "IncomingHttpRequestFilter"; | 265 static const char* HTTP_FILTER = "IncomingHttpRequestFilter"; |
188 | 266 |
267 ServerContext::LuaContextLocker locker(context_); | |
268 | |
189 // Test if the instance must be filtered out | 269 // Test if the instance must be filtered out |
190 if (context_.GetLuaContext().IsExistingFunction(HTTP_FILTER)) | 270 if (locker.GetLua().IsExistingFunction(HTTP_FILTER)) |
191 { | 271 { |
192 LuaFunctionCall call(context_.GetLuaContext(), HTTP_FILTER); | 272 LuaFunctionCall call(locker.GetLua(), HTTP_FILTER); |
193 | 273 |
194 switch (method) | 274 switch (method) |
195 { | 275 { |
196 case HttpMethod_Get: | 276 case HttpMethod_Get: |
197 call.PushString("GET"); | 277 call.PushString("GET"); |
227 return true; | 307 return true; |
228 } | 308 } |
229 }; | 309 }; |
230 | 310 |
231 | 311 |
232 void PrintHelp(char* path) | 312 static void PrintHelp(char* path) |
233 { | 313 { |
234 std::cout | 314 std::cout |
235 << "Usage: " << path << " [OPTION]... [CONFIGURATION]" << std::endl | 315 << "Usage: " << path << " [OPTION]... [CONFIGURATION]" << std::endl |
236 << "Orthanc, lightweight, RESTful DICOM server for healthcare and medical research." << std::endl | 316 << "Orthanc, lightweight, RESTful DICOM server for healthcare and medical research." << std::endl |
237 << std::endl | 317 << std::endl |
254 << " -1 if error (have a look at the logs)." << std::endl | 334 << " -1 if error (have a look at the logs)." << std::endl |
255 << std::endl; | 335 << std::endl; |
256 } | 336 } |
257 | 337 |
258 | 338 |
259 void PrintVersion(char* path) | 339 static void PrintVersion(char* path) |
260 { | 340 { |
261 std::cout | 341 std::cout |
262 << path << " " << ORTHANC_VERSION << std::endl | 342 << path << " " << ORTHANC_VERSION << std::endl |
263 << "Copyright (C) 2012-2014 Medical Physics Department, CHU of Liege (Belgium) " << std::endl | 343 << "Copyright (C) 2012-2015 Sebastien Jodogne, Medical Physics Department, University Hospital of Liege (Belgium)" << std::endl |
264 << "Licensing GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>, with OpenSSL exception." << std::endl | 344 << "Licensing GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>, with OpenSSL exception." << std::endl |
265 << "This is free software: you are free to change and redistribute it." << std::endl | 345 << "This is free software: you are free to change and redistribute it." << std::endl |
266 << "There is NO WARRANTY, to the extent permitted by law." << std::endl | 346 << "There is NO WARRANTY, to the extent permitted by law." << std::endl |
267 << std::endl | 347 << std::endl |
268 << "Written by Sebastien Jodogne <s.jodogne@gmail.com>" << std::endl; | 348 << "Written by Sebastien Jodogne <s.jodogne@gmail.com>" << std::endl; |
269 } | 349 } |
270 | 350 |
271 | 351 |
352 | |
353 static void LoadLuaScripts(ServerContext& context) | |
354 { | |
355 std::list<std::string> luaScripts; | |
356 Configuration::GetGlobalListOfStringsParameter(luaScripts, "LuaScripts"); | |
357 for (std::list<std::string>::const_iterator | |
358 it = luaScripts.begin(); it != luaScripts.end(); ++it) | |
359 { | |
360 std::string path = Configuration::InterpretStringParameterAsPath(*it); | |
361 LOG(WARNING) << "Installing the Lua scripts from: " << path; | |
362 std::string script; | |
363 Toolbox::ReadFile(script, path); | |
364 | |
365 ServerContext::LuaContextLocker locker(context); | |
366 locker.GetLua().Execute(script); | |
367 } | |
368 } | |
369 | |
370 | |
371 static void LoadPlugins(PluginsManager& pluginsManager) | |
372 { | |
373 std::list<std::string> plugins; | |
374 Configuration::GetGlobalListOfStringsParameter(plugins, "Plugins"); | |
375 for (std::list<std::string>::const_iterator | |
376 it = plugins.begin(); it != plugins.end(); ++it) | |
377 { | |
378 std::string path = Configuration::InterpretStringParameterAsPath(*it); | |
379 LOG(WARNING) << "Loading plugin(s) from: " << path; | |
380 pluginsManager.RegisterPlugin(path); | |
381 } | |
382 } | |
383 | |
384 | |
385 | |
386 static bool StartOrthanc(int argc, char *argv[]) | |
387 { | |
388 #if ENABLE_PLUGINS == 1 | |
389 OrthancPlugins orthancPlugins; | |
390 orthancPlugins.SetCommandLineArguments(argc, argv); | |
391 PluginsManager pluginsManager; | |
392 pluginsManager.RegisterServiceProvider(orthancPlugins); | |
393 LoadPlugins(pluginsManager); | |
394 #endif | |
395 | |
396 // "storage" and "database" must be declared BEFORE "ServerContext | |
397 // context", to avoid mess in the invokation order of the destructors. | |
398 std::auto_ptr<IDatabaseWrapper> database; | |
399 std::auto_ptr<IStorageArea> storage; | |
400 std::auto_ptr<ServerContext> context; | |
401 | |
402 if (orthancPlugins.HasDatabase()) | |
403 { | |
404 context.reset(new ServerContext(orthancPlugins.GetDatabase())); | |
405 } | |
406 else | |
407 { | |
408 database.reset(Configuration::CreateDatabaseWrapper()); | |
409 context.reset(new ServerContext(*database)); | |
410 } | |
411 | |
412 context->SetCompressionEnabled(Configuration::GetGlobalBoolParameter("StorageCompression", false)); | |
413 context->SetStoreMD5ForAttachments(Configuration::GetGlobalBoolParameter("StoreMD5ForAttachments", true)); | |
414 | |
415 LoadLuaScripts(*context); | |
416 | |
417 try | |
418 { | |
419 context->GetIndex().SetMaximumPatientCount(Configuration::GetGlobalIntegerParameter("MaximumPatientCount", 0)); | |
420 } | |
421 catch (...) | |
422 { | |
423 context->GetIndex().SetMaximumPatientCount(0); | |
424 } | |
425 | |
426 try | |
427 { | |
428 uint64_t size = Configuration::GetGlobalIntegerParameter("MaximumStorageSize", 0); | |
429 context->GetIndex().SetMaximumStorageSize(size * 1024 * 1024); | |
430 } | |
431 catch (...) | |
432 { | |
433 context->GetIndex().SetMaximumStorageSize(0); | |
434 } | |
435 | |
436 MyDicomServerFactory serverFactory(*context); | |
437 bool isReset = false; | |
438 | |
439 { | |
440 // DICOM server | |
441 DicomServer dicomServer; | |
442 OrthancApplicationEntityFilter dicomFilter(*context); | |
443 dicomServer.SetCalledApplicationEntityTitleCheck(Configuration::GetGlobalBoolParameter("DicomCheckCalledAet", false)); | |
444 dicomServer.SetStoreRequestHandlerFactory(serverFactory); | |
445 dicomServer.SetMoveRequestHandlerFactory(serverFactory); | |
446 dicomServer.SetFindRequestHandlerFactory(serverFactory); | |
447 dicomServer.SetPortNumber(Configuration::GetGlobalIntegerParameter("DicomPort", 4242)); | |
448 dicomServer.SetApplicationEntityTitle(Configuration::GetGlobalStringParameter("DicomAet", "ORTHANC")); | |
449 dicomServer.SetApplicationEntityFilter(dicomFilter); | |
450 | |
451 // HTTP server | |
452 MyIncomingHttpRequestFilter httpFilter(*context); | |
453 MongooseServer httpServer; | |
454 httpServer.SetPortNumber(Configuration::GetGlobalIntegerParameter("HttpPort", 8042)); | |
455 httpServer.SetRemoteAccessAllowed(Configuration::GetGlobalBoolParameter("RemoteAccessAllowed", false)); | |
456 httpServer.SetKeepAliveEnabled(Configuration::GetGlobalBoolParameter("KeepAlive", false)); | |
457 httpServer.SetIncomingHttpRequestFilter(httpFilter); | |
458 | |
459 httpServer.SetAuthenticationEnabled(Configuration::GetGlobalBoolParameter("AuthenticationEnabled", false)); | |
460 Configuration::SetupRegisteredUsers(httpServer); | |
461 | |
462 if (Configuration::GetGlobalBoolParameter("SslEnabled", false)) | |
463 { | |
464 std::string certificate = Configuration::InterpretStringParameterAsPath( | |
465 Configuration::GetGlobalStringParameter("SslCertificate", "certificate.pem")); | |
466 httpServer.SetSslEnabled(true); | |
467 httpServer.SetSslCertificate(certificate.c_str()); | |
468 } | |
469 else | |
470 { | |
471 httpServer.SetSslEnabled(false); | |
472 } | |
473 | |
474 OrthancRestApi restApi(*context); | |
475 | |
476 #if ORTHANC_STANDALONE == 1 | |
477 EmbeddedResourceHttpHandler staticResources("/app", EmbeddedResources::ORTHANC_EXPLORER); | |
478 #else | |
479 FilesystemHttpHandler staticResources("/app", ORTHANC_PATH "/OrthancExplorer"); | |
480 #endif | |
481 | |
482 #if ENABLE_PLUGINS == 1 | |
483 orthancPlugins.SetServerContext(*context); | |
484 httpServer.RegisterHandler(orthancPlugins); | |
485 context->SetOrthancPlugins(pluginsManager, orthancPlugins); | |
486 #endif | |
487 | |
488 httpServer.RegisterHandler(staticResources); | |
489 httpServer.RegisterHandler(restApi); | |
490 | |
491 | |
492 #if ENABLE_PLUGINS == 1 | |
493 // Prepare the storage area | |
494 if (orthancPlugins.HasStorageArea()) | |
495 { | |
496 LOG(WARNING) << "Using a custom storage area from plugins"; | |
497 storage.reset(orthancPlugins.GetStorageArea()); | |
498 } | |
499 else | |
500 #endif | |
501 { | |
502 storage.reset(Configuration::CreateStorageArea()); | |
503 } | |
504 | |
505 context->SetStorageArea(*storage); | |
506 | |
507 | |
508 // GO !!! Start the requested servers | |
509 if (Configuration::GetGlobalBoolParameter("HttpServerEnabled", true)) | |
510 { | |
511 #if ENABLE_PLUGINS == 1 | |
512 orthancPlugins.SetOrthancRestApi(restApi); | |
513 #endif | |
514 | |
515 httpServer.Start(); | |
516 LOG(WARNING) << "HTTP server listening on port: " << httpServer.GetPortNumber(); | |
517 } | |
518 else | |
519 { | |
520 LOG(WARNING) << "The HTTP server is disabled"; | |
521 } | |
522 | |
523 if (Configuration::GetGlobalBoolParameter("DicomServerEnabled", true)) | |
524 { | |
525 dicomServer.Start(); | |
526 LOG(WARNING) << "DICOM server listening on port: " << dicomServer.GetPortNumber(); | |
527 } | |
528 else | |
529 { | |
530 LOG(WARNING) << "The DICOM server is disabled"; | |
531 } | |
532 | |
533 LOG(WARNING) << "Orthanc has started"; | |
534 Toolbox::ServerBarrier(restApi.ResetRequestReceivedFlag()); | |
535 isReset = restApi.ResetRequestReceivedFlag(); | |
536 | |
537 if (isReset) | |
538 { | |
539 LOG(WARNING) << "Reset request received, restarting Orthanc"; | |
540 } | |
541 | |
542 // We're done | |
543 LOG(WARNING) << "Orthanc is stopping"; | |
544 | |
545 #if ENABLE_PLUGINS == 1 | |
546 context->ResetOrthancPlugins(); | |
547 orthancPlugins.Stop(); | |
548 orthancPlugins.ResetOrthancRestApi(); | |
549 LOG(WARNING) << " Plugins have stopped"; | |
550 #endif | |
551 | |
552 dicomServer.Stop(); | |
553 LOG(WARNING) << " DICOM server has stopped"; | |
554 | |
555 httpServer.Stop(); | |
556 LOG(WARNING) << " HTTP server has stopped"; | |
557 } | |
558 | |
559 serverFactory.Done(); | |
560 | |
561 return isReset; | |
562 } | |
563 | |
564 | |
565 | |
566 | |
272 int main(int argc, char* argv[]) | 567 int main(int argc, char* argv[]) |
273 { | 568 { |
274 // Initialize Google's logging library. | 569 // Initialize Google's logging library. |
275 FLAGS_logtostderr = true; | 570 FLAGS_logtostderr = true; |
276 FLAGS_minloglevel = 1; | 571 FLAGS_minloglevel = 1; |
325 } | 620 } |
326 } | 621 } |
327 | 622 |
328 google::InitGoogleLogging("Orthanc"); | 623 google::InitGoogleLogging("Orthanc"); |
329 | 624 |
625 const char* configurationFile = NULL; | |
626 for (int i = 1; i < argc; i++) | |
627 { | |
628 // Use the first argument that does not start with a "-" as | |
629 // the configuration file | |
630 if (argv[i][0] != '-') | |
631 { | |
632 configurationFile = argv[i]; | |
633 } | |
634 } | |
635 | |
636 LOG(WARNING) << "Orthanc version: " << ORTHANC_VERSION; | |
637 | |
330 int status = 0; | 638 int status = 0; |
331 try | 639 try |
332 { | 640 { |
333 bool isInitialized = false; | 641 if (1) |
334 if (argc >= 2) | 642 { |
335 { | 643 DicomUserConnection c; |
336 for (int i = 1; i < argc; i++) | 644 c.SetLocalApplicationEntityTitle("ORTHANC"); |
645 c.SetRemoteApplicationEntityTitle("ORTHANC"); | |
646 c.SetRemoteHost("localhost"); | |
647 c.SetRemotePort(4343); | |
648 c.Open(); | |
649 | |
650 DicomMap m; // Delphine | |
651 m.SetValue(DICOM_TAG_PATIENT_ID, "5423962"); | |
652 m.SetValue(DICOM_TAG_STUDY_INSTANCE_UID, "1.2.840.113845.11.1000000001951524609.20121203131451.1457891"); | |
653 m.SetValue(DICOM_TAG_SERIES_INSTANCE_UID, "1.2.840.113619.2.278.3.262930758.589.1354512768.115"); | |
654 m.SetValue(DICOM_TAG_SOP_INSTANCE_UID, "1.3.12.2.1107.5.2.33.37097.2012041613043195815872177"); | |
655 | |
656 DicomFindAnswers fnd; | |
657 c.FindInstance(fnd, m); | |
658 //c.FindSeries(fnd, m); | |
659 | |
660 printf("ok %d\n", fnd.GetSize()); | |
661 } | |
662 | |
663 | |
664 for (;;) | |
665 { | |
666 OrthancInitialize(configurationFile); | |
667 | |
668 bool reset = StartOrthanc(argc, argv); | |
669 if (reset) | |
337 { | 670 { |
338 // Use the first argument that does not start with a "-" as | 671 OrthancFinalize(); |
339 // the configuration file | |
340 if (argv[i][0] != '-') | |
341 { | |
342 OrthancInitialize(argv[i]); | |
343 isInitialized = true; | |
344 } | |
345 } | |
346 } | |
347 | |
348 if (!isInitialized) | |
349 { | |
350 OrthancInitialize(); | |
351 } | |
352 | |
353 std::string storageDirectoryStr = Configuration::GetGlobalStringParameter("StorageDirectory", "OrthancStorage"); | |
354 boost::filesystem::path storageDirectory = Configuration::InterpretStringParameterAsPath(storageDirectoryStr); | |
355 boost::filesystem::path indexDirectory = Configuration::InterpretStringParameterAsPath( | |
356 Configuration::GetGlobalStringParameter("IndexDirectory", storageDirectoryStr)); | |
357 ServerContext context(storageDirectory, indexDirectory); | |
358 | |
359 LOG(WARNING) << "Storage directory: " << storageDirectory; | |
360 LOG(WARNING) << "Index directory: " << indexDirectory; | |
361 | |
362 context.SetCompressionEnabled(Configuration::GetGlobalBoolParameter("StorageCompression", false)); | |
363 context.SetStoreMD5ForAttachments(Configuration::GetGlobalBoolParameter("StoreMD5ForAttachments", true)); | |
364 | |
365 std::list<std::string> luaScripts; | |
366 Configuration::GetGlobalListOfStringsParameter(luaScripts, "LuaScripts"); | |
367 for (std::list<std::string>::const_iterator | |
368 it = luaScripts.begin(); it != luaScripts.end(); ++it) | |
369 { | |
370 std::string path = Configuration::InterpretStringParameterAsPath(*it); | |
371 LOG(WARNING) << "Installing the Lua scripts from: " << path; | |
372 std::string script; | |
373 Toolbox::ReadFile(script, path); | |
374 context.GetLuaContext().Execute(script); | |
375 } | |
376 | |
377 | |
378 try | |
379 { | |
380 context.GetIndex().SetMaximumPatientCount(Configuration::GetGlobalIntegerParameter("MaximumPatientCount", 0)); | |
381 } | |
382 catch (...) | |
383 { | |
384 context.GetIndex().SetMaximumPatientCount(0); | |
385 } | |
386 | |
387 try | |
388 { | |
389 uint64_t size = Configuration::GetGlobalIntegerParameter("MaximumStorageSize", 0); | |
390 context.GetIndex().SetMaximumStorageSize(size * 1024 * 1024); | |
391 } | |
392 catch (...) | |
393 { | |
394 context.GetIndex().SetMaximumStorageSize(0); | |
395 } | |
396 | |
397 MyDicomServerFactory serverFactory(context); | |
398 | |
399 { | |
400 // DICOM server | |
401 DicomServer dicomServer; | |
402 OrthancApplicationEntityFilter dicomFilter; | |
403 dicomServer.SetCalledApplicationEntityTitleCheck(Configuration::GetGlobalBoolParameter("DicomCheckCalledAet", false)); | |
404 dicomServer.SetStoreRequestHandlerFactory(serverFactory); | |
405 dicomServer.SetMoveRequestHandlerFactory(serverFactory); | |
406 dicomServer.SetFindRequestHandlerFactory(serverFactory); | |
407 dicomServer.SetPortNumber(Configuration::GetGlobalIntegerParameter("DicomPort", 4242)); | |
408 dicomServer.SetApplicationEntityTitle(Configuration::GetGlobalStringParameter("DicomAet", "ORTHANC")); | |
409 dicomServer.SetApplicationEntityFilter(dicomFilter); | |
410 | |
411 // HTTP server | |
412 MyIncomingHttpRequestFilter httpFilter(context); | |
413 MongooseServer httpServer; | |
414 httpServer.SetPortNumber(Configuration::GetGlobalIntegerParameter("HttpPort", 8042)); | |
415 httpServer.SetRemoteAccessAllowed(Configuration::GetGlobalBoolParameter("RemoteAccessAllowed", false)); | |
416 httpServer.SetIncomingHttpRequestFilter(httpFilter); | |
417 | |
418 httpServer.SetAuthenticationEnabled(Configuration::GetGlobalBoolParameter("AuthenticationEnabled", false)); | |
419 Configuration::SetupRegisteredUsers(httpServer); | |
420 | |
421 if (Configuration::GetGlobalBoolParameter("SslEnabled", false)) | |
422 { | |
423 std::string certificate = Configuration::InterpretStringParameterAsPath( | |
424 Configuration::GetGlobalStringParameter("SslCertificate", "certificate.pem")); | |
425 httpServer.SetSslEnabled(true); | |
426 httpServer.SetSslCertificate(certificate.c_str()); | |
427 } | 672 } |
428 else | 673 else |
429 { | 674 { |
430 httpServer.SetSslEnabled(false); | 675 break; |
431 } | 676 } |
432 | 677 } |
433 #if ORTHANC_STANDALONE == 1 | 678 } |
434 httpServer.RegisterHandler(new EmbeddedResourceHttpHandler("/app", EmbeddedResources::ORTHANC_EXPLORER)); | 679 catch (const OrthancException& e) |
435 #else | 680 { |
436 httpServer.RegisterHandler(new FilesystemHttpHandler("/app", ORTHANC_PATH "/OrthancExplorer")); | 681 LOG(ERROR) << "Uncaught exception, stopping now: [" << e.What() << "]"; |
437 #endif | |
438 | |
439 httpServer.RegisterHandler(new OrthancRestApi(context)); | |
440 | |
441 // GO !!! Start the requested servers | |
442 if (Configuration::GetGlobalBoolParameter("HttpServerEnabled", true)) | |
443 { | |
444 httpServer.Start(); | |
445 LOG(WARNING) << "HTTP server listening on port: " << httpServer.GetPortNumber(); | |
446 } | |
447 else | |
448 { | |
449 LOG(WARNING) << "The HTTP server is disabled"; | |
450 } | |
451 | |
452 if (Configuration::GetGlobalBoolParameter("DicomServerEnabled", true)) | |
453 { | |
454 dicomServer.Start(); | |
455 LOG(WARNING) << "DICOM server listening on port: " << dicomServer.GetPortNumber(); | |
456 } | |
457 else | |
458 { | |
459 LOG(WARNING) << "The DICOM server is disabled"; | |
460 } | |
461 | |
462 | |
463 { | |
464 DicomUserConnection c; | |
465 c.SetLocalApplicationEntityTitle("ORTHANC"); | |
466 c.SetDistantApplicationEntityTitle("ORTHANC"); | |
467 c.SetDistantHost("localhost"); | |
468 c.SetDistantPort(4343); | |
469 c.Open(); | |
470 | |
471 DicomMap m; // Delphine | |
472 m.SetValue(DICOM_TAG_PATIENT_ID, "5423962"); | |
473 m.SetValue(DICOM_TAG_STUDY_INSTANCE_UID, "1.2.840.113845.11.1000000001951524609.20121203131451.1457891"); | |
474 m.SetValue(DICOM_TAG_SERIES_INSTANCE_UID, "1.2.840.113619.2.278.3.262930758.589.1354512768.115"); | |
475 m.SetValue(DICOM_TAG_SOP_INSTANCE_UID, "1.3.12.2.1107.5.2.33.37097.2012041613043195815872177"); | |
476 | |
477 DicomFindAnswers fnd; | |
478 c.FindInstance(fnd, m); | |
479 //c.FindSeries(fnd, m); | |
480 | |
481 printf("ok %d\n", fnd.GetSize()); | |
482 } | |
483 | |
484 | |
485 LOG(WARNING) << "Orthanc has started"; | |
486 Toolbox::ServerBarrier(); | |
487 | |
488 // We're done | |
489 LOG(WARNING) << "Orthanc is stopping"; | |
490 } | |
491 | |
492 serverFactory.Done(); | |
493 } | |
494 catch (OrthancException& e) | |
495 { | |
496 LOG(ERROR) << "EXCEPTION [" << e.What() << "]"; | |
497 status = -1; | 682 status = -1; |
498 } | 683 } |
684 catch (const std::exception& e) | |
685 { | |
686 LOG(ERROR) << "Uncaught exception, stopping now: [" << e.what() << "]"; | |
687 status = -1; | |
688 } | |
689 catch (const std::string& s) | |
690 { | |
691 LOG(ERROR) << "Uncaught exception, stopping now: [" << s << "]"; | |
692 status = -1; | |
693 } | |
499 catch (...) | 694 catch (...) |
500 { | 695 { |
501 LOG(ERROR) << "NATIVE EXCEPTION"; | 696 LOG(ERROR) << "Native exception, stopping now. Check your plugins, if any."; |
502 status = -1; | 697 status = -1; |
503 } | 698 } |
504 | 699 |
505 OrthancFinalize(); | 700 OrthancFinalize(); |
506 | 701 |