Mercurial > hg > orthanc

comparison OrthancServer/OrthancInitialization.cpp @ 1423:7b7d597a190c

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
The configuration can be splitted into several files stored inside the same folder
author Sebastien Jodogne <s.jodogne@gmail.com>
date Fri, 26 Jun 2015 14:44:10 +0200
parents 52b2070fc8f1
children fe384a9d3b51
comparison
equal deleted inserted replaced
1422:52b2070fc8f1 1423:7b7d597a190c
60 60
61 61
62 namespace Orthanc 62 namespace Orthanc
63 { 63 {
64 static boost::mutex globalMutex_; 64 static boost::mutex globalMutex_;
65 static std::auto_ptr<Json::Value> configuration_; 65 static Json::Value configuration_;
66 static boost::filesystem::path defaultDirectory_; 66 static boost::filesystem::path defaultDirectory_;
67 static std::string configurationAbsolutePath_; 67 static std::string configurationAbsolutePath_;
68 68
69 69
70 static void AddFileToConfiguration(const boost::filesystem::path& path)
71 {
72 LOG(WARNING) << "Reading the configuration from: " << path;
73
74 std::string content;
75 Toolbox::ReadFile(content, path.string());
76
77 Json::Value tmp;
78 Json::Reader reader;
79 if (!reader.parse(content, tmp) ||
80 tmp.type() != Json::objectValue)
81 {
82 LOG(ERROR) << "Bad file format for this configuration file: " << path;
83 throw OrthancException(ErrorCode_BadFileFormat);
84 }
85
86 if (configuration_.size() == 0)
87 {
88 configuration_ = tmp;
89 }
90 else
91 {
92 Json::Value::Members members = tmp.getMemberNames();
93 for (Json::Value::ArrayIndex i = 0; i < members.size(); i++)
94 {
95 if (configuration_.isMember(members[i]))
96 {
97 LOG(ERROR) << "The configuration section \"" << members[i] << "\" is defined in 2 different configuration files";
98 throw OrthancException(ErrorCode_BadFileFormat);
99 }
100 else
101 {
102 configuration_[members[i]] = tmp[members[i]];
103 }
104 }
105 }
106 }
107
108
109 static void ScanFolderForConfiguration(const char* folder)
110 {
111 using namespace boost::filesystem;
112
113 LOG(WARNING) << "Scanning folder \"" << folder << "\" for configuration files";
114
115 directory_iterator end_it; // default construction yields past-the-end
116 for (directory_iterator it(folder);
117 it != end_it;
118 ++it)
119 {
120 if (!is_directory(it->status()))
121 {
122 std::string extension = boost::filesystem::extension(it->path());
123 Toolbox::ToLowerCase(extension);
124
125 if (extension == ".json")
126 {
127 AddFileToConfiguration(it->path().string());
128 }
129 }
130 }
131 }
132
133
70 static void ReadGlobalConfiguration(const char* configurationFile) 134 static void ReadGlobalConfiguration(const char* configurationFile)
71 { 135 {
72 configuration_.reset(new Json::Value); 136 // Prepare the default configuration
73 137 defaultDirectory_ = boost::filesystem::current_path();
74 std::string content; 138 configuration_ = Json::objectValue;
139 configurationAbsolutePath_ = "";
75 140
76 if (configurationFile) 141 if (configurationFile)
77 { 142 {
78 Toolbox::ReadFile(content, configurationFile); 143 if (!boost::filesystem::exists(configurationFile))
79 defaultDirectory_ = boost::filesystem::path(configurationFile).parent_path(); 144 {
80 LOG(WARNING) << "Using the configuration from: " << configurationFile; 145 LOG(ERROR) << "Inexistent path to configuration: " << configurationFile;
81 configurationAbsolutePath_ = boost::filesystem::absolute(configurationFile).string(); 146 return;
147 }
148
149 if (boost::filesystem::is_directory(configurationFile))
150 {
151 defaultDirectory_ = boost::filesystem::path(configurationFile);
152 configurationAbsolutePath_ = boost::filesystem::absolute(configurationFile).parent_path().string();
153 ScanFolderForConfiguration(configurationFile);
154 }
155 else
156 {
157 defaultDirectory_ = boost::filesystem::path(configurationFile).parent_path();
158 configurationAbsolutePath_ = boost::filesystem::absolute(configurationFile).string();
159 AddFileToConfiguration(configurationFile);
160 }
82 } 161 }
83 else 162 else
84 { 163 {
85 #if ORTHANC_STANDALONE == 1 164 #if ORTHANC_STANDALONE == 1
86 // No default path for the standalone configuration 165 // No default path for the standalone configuration
89 168
90 #else 169 #else
91 // In a non-standalone build, we use the 170 // In a non-standalone build, we use the
92 // "Resources/Configuration.json" from the Orthanc source code 171 // "Resources/Configuration.json" from the Orthanc source code
93 172
94 try 173 boost::filesystem::path p = ORTHANC_PATH;
95 { 174 p /= "Resources";
96 boost::filesystem::path p = ORTHANC_PATH; 175 p /= "Configuration.json";
97 p /= "Resources"; 176 configurationAbsolutePath_ = boost::filesystem::absolute(p).string();
98 p /= "Configuration.json"; 177
99 Toolbox::ReadFile(content, p.string()); 178 AddFileToConfiguration(p);
100 LOG(WARNING) << "Using the configuration from: " << p.string();
101 configurationAbsolutePath_ = boost::filesystem::absolute(p).string();
102 }
103 catch (OrthancException&)
104 {
105 // No configuration file found, give up with empty configuration
106 LOG(WARNING) << "Using the default Orthanc configuration";
107 return;
108 }
109 #endif 179 #endif
110 } 180 }
111
112
113 Json::Reader reader;
114 if (!reader.parse(content, *configuration_))
115 {
116 LOG(ERROR) << "Unable to read the configuration file";
117 throw OrthancException(ErrorCode_BadFileFormat);
118 }
119 } 181 }
120 182
121 183
122 static void RegisterUserMetadata() 184 static void RegisterUserMetadata()
123 { 185 {
124 if (configuration_->isMember("UserMetadata")) 186 if (configuration_.isMember("UserMetadata"))
125 { 187 {
126 const Json::Value& parameter = (*configuration_) ["UserMetadata"]; 188 const Json::Value& parameter = configuration_["UserMetadata"];
127 189
128 Json::Value::Members members = parameter.getMemberNames(); 190 Json::Value::Members members = parameter.getMemberNames();
129 for (size_t i = 0; i < members.size(); i++) 191 for (size_t i = 0; i < members.size(); i++)
130 { 192 {
131 std::string info = "\"" + members[i] + "\" = " + parameter[members[i]].toStyledString(); 193 std::string info = "\"" + members[i] + "\" = " + parameter[members[i]].toStyledString();
153 } 215 }
154 216
155 217
156 static void RegisterUserContentType() 218 static void RegisterUserContentType()
157 { 219 {
158 if (configuration_->isMember("UserContentType")) 220 if (configuration_.isMember("UserContentType"))
159 { 221 {
160 const Json::Value& parameter = (*configuration_) ["UserContentType"]; 222 const Json::Value& parameter = configuration_["UserContentType"];
161 223
162 Json::Value::Members members = parameter.getMemberNames(); 224 Json::Value::Members members = parameter.getMemberNames();
163 for (size_t i = 0; i < members.size(); i++) 225 for (size_t i = 0; i < members.size(); i++)
164 { 226 {
165 std::string info = "\"" + members[i] + "\" = " + parameter[members[i]].toStyledString(); 227 std::string info = "\"" + members[i] + "\" = " + parameter[members[i]].toStyledString();
190 void OrthancInitialize(const char* configurationFile) 252 void OrthancInitialize(const char* configurationFile)
191 { 253 {
192 boost::mutex::scoped_lock lock(globalMutex_); 254 boost::mutex::scoped_lock lock(globalMutex_);
193 255
194 InitializeServerEnumerations(); 256 InitializeServerEnumerations();
195 defaultDirectory_ = boost::filesystem::current_path(); 257
258 // Read the user-provided configuration
196 ReadGlobalConfiguration(configurationFile); 259 ReadGlobalConfiguration(configurationFile);
197 260
198 HttpClient::GlobalInitialize(); 261 HttpClient::GlobalInitialize();
199 262
200 RegisterUserMetadata(); 263 RegisterUserMetadata();
217 280
218 void OrthancFinalize() 281 void OrthancFinalize()
219 { 282 {
220 boost::mutex::scoped_lock lock(globalMutex_); 283 boost::mutex::scoped_lock lock(globalMutex_);
221 HttpClient::GlobalFinalize(); 284 HttpClient::GlobalFinalize();
222 configuration_.reset(NULL);
223 285
224 #if ORTHANC_JPEG_LOSSLESS_ENABLED == 1 286 #if ORTHANC_JPEG_LOSSLESS_ENABLED == 1
225 // Unregister JPEG-LS codecs 287 // Unregister JPEG-LS codecs
226 DJLSDecoderRegistration::cleanup(); 288 DJLSDecoderRegistration::cleanup();
227 #endif 289 #endif
237 std::string Configuration::GetGlobalStringParameter(const std::string& parameter, 299 std::string Configuration::GetGlobalStringParameter(const std::string& parameter,
238 const std::string& defaultValue) 300 const std::string& defaultValue)
239 { 301 {
240 boost::mutex::scoped_lock lock(globalMutex_); 302 boost::mutex::scoped_lock lock(globalMutex_);
241 303
242 if (configuration_.get() != NULL && 304 if (configuration_.isMember(parameter))
243 configuration_->isMember(parameter)) 305 {
244 { 306 return configuration_[parameter].asString();
245 return (*configuration_) [parameter].asString();
246 } 307 }
247 else 308 else
248 { 309 {
249 return defaultValue; 310 return defaultValue;
250 } 311 }
254 int Configuration::GetGlobalIntegerParameter(const std::string& parameter, 315 int Configuration::GetGlobalIntegerParameter(const std::string& parameter,
255 int defaultValue) 316 int defaultValue)
256 { 317 {
257 boost::mutex::scoped_lock lock(globalMutex_); 318 boost::mutex::scoped_lock lock(globalMutex_);
258 319
259 if (configuration_.get() != NULL && 320 if (configuration_.isMember(parameter))
260 configuration_->isMember(parameter)) 321 {
261 { 322 return configuration_[parameter].asInt();
262 return (*configuration_) [parameter].asInt();
263 } 323 }
264 else 324 else
265 { 325 {
266 return defaultValue; 326 return defaultValue;
267 } 327 }
271 bool Configuration::GetGlobalBoolParameter(const std::string& parameter, 331 bool Configuration::GetGlobalBoolParameter(const std::string& parameter,
272 bool defaultValue) 332 bool defaultValue)
273 { 333 {
274 boost::mutex::scoped_lock lock(globalMutex_); 334 boost::mutex::scoped_lock lock(globalMutex_);
275 335
276 if (configuration_.get() != NULL && 336 if (configuration_.isMember(parameter))
277 configuration_->isMember(parameter)) 337 {
278 { 338 return configuration_[parameter].asBool();
279 return (*configuration_) [parameter].asBool();
280 } 339 }
281 else 340 else
282 { 341 {
283 return defaultValue; 342 return defaultValue;
284 } 343 }
288 void Configuration::GetDicomModalityUsingSymbolicName(RemoteModalityParameters& modality, 347 void Configuration::GetDicomModalityUsingSymbolicName(RemoteModalityParameters& modality,
289 const std::string& name) 348 const std::string& name)
290 { 349 {
291 boost::mutex::scoped_lock lock(globalMutex_); 350 boost::mutex::scoped_lock lock(globalMutex_);
292 351
293 if (configuration_.get() == NULL) 352 if (!configuration_.isMember("DicomModalities"))
294 {
295 LOG(ERROR) << "The configuration file was not properly loaded";
296 throw OrthancException(ErrorCode_InexistentItem);
297 }
298
299 if (!configuration_->isMember("DicomModalities"))
300 { 353 {
301 LOG(ERROR) << "No modality with symbolic name: " << name; 354 LOG(ERROR) << "No modality with symbolic name: " << name;
302 throw OrthancException(ErrorCode_InexistentItem); 355 throw OrthancException(ErrorCode_InexistentItem);
303 } 356 }
304 357
305 const Json::Value& modalities = (*configuration_) ["DicomModalities"]; 358 const Json::Value& modalities = configuration_["DicomModalities"];
306 if (modalities.type() != Json::objectValue || 359 if (modalities.type() != Json::objectValue ||
307 !modalities.isMember(name)) 360 !modalities.isMember(name))
308 { 361 {
309 LOG(ERROR) << "No modality with symbolic name: " << name; 362 LOG(ERROR) << "No modality with symbolic name: " << name;
310 throw OrthancException(ErrorCode_InexistentItem); 363 throw OrthancException(ErrorCode_InexistentItem);
327 void Configuration::GetOrthancPeer(OrthancPeerParameters& peer, 380 void Configuration::GetOrthancPeer(OrthancPeerParameters& peer,
328 const std::string& name) 381 const std::string& name)
329 { 382 {
330 boost::mutex::scoped_lock lock(globalMutex_); 383 boost::mutex::scoped_lock lock(globalMutex_);
331 384
332 if (configuration_.get() == NULL) 385 if (!configuration_.isMember("OrthancPeers"))
333 {
334 LOG(ERROR) << "The configuration file was not properly loaded";
335 throw OrthancException(ErrorCode_InexistentItem);
336 }
337
338 if (!configuration_->isMember("OrthancPeers"))
339 { 386 {
340 LOG(ERROR) << "No peer with symbolic name: " << name; 387 LOG(ERROR) << "No peer with symbolic name: " << name;
341 throw OrthancException(ErrorCode_InexistentItem); 388 throw OrthancException(ErrorCode_InexistentItem);
342 } 389 }
343 390
344 try 391 try
345 { 392 {
346 const Json::Value& modalities = (*configuration_) ["OrthancPeers"]; 393 const Json::Value& modalities = configuration_["OrthancPeers"];
347 if (modalities.type() != Json::objectValue || 394 if (modalities.type() != Json::objectValue ||
348 !modalities.isMember(name)) 395 !modalities.isMember(name))
349 { 396 {
350 LOG(ERROR) << "No peer with symbolic name: " << name; 397 LOG(ERROR) << "No peer with symbolic name: " << name;
351 throw OrthancException(ErrorCode_InexistentItem); 398 throw OrthancException(ErrorCode_InexistentItem);
368 { 415 {
369 boost::mutex::scoped_lock lock(globalMutex_); 416 boost::mutex::scoped_lock lock(globalMutex_);
370 417
371 target.clear(); 418 target.clear();
372 419
373 if (configuration_.get() == NULL || 420 if (!configuration_.isMember(parameter))
374 !configuration_->isMember(parameter))
375 { 421 {
376 return true; 422 return true;
377 } 423 }
378 424
379 const Json::Value& modalities = (*configuration_) [parameter]; 425 const Json::Value& modalities = configuration_[parameter];
380 if (modalities.type() != Json::objectValue) 426 if (modalities.type() != Json::objectValue)
381 { 427 {
382 LOG(ERROR) << "Bad format of the \"DicomModalities\" configuration section"; 428 LOG(ERROR) << "Bad format of the \"DicomModalities\" configuration section";
383 throw OrthancException(ErrorCode_BadFileFormat); 429 throw OrthancException(ErrorCode_BadFileFormat);
384 } 430 }
429 { 475 {
430 boost::mutex::scoped_lock lock(globalMutex_); 476 boost::mutex::scoped_lock lock(globalMutex_);
431 477
432 httpServer.ClearUsers(); 478 httpServer.ClearUsers();
433 479
434 if (configuration_.get() == NULL || 480 if (!configuration_.isMember("RegisteredUsers"))
435 !configuration_->isMember("RegisteredUsers"))
436 { 481 {
437 return; 482 return;
438 } 483 }
439 484
440 const Json::Value& users = (*configuration_) ["RegisteredUsers"]; 485 const Json::Value& users = configuration_["RegisteredUsers"];
441 if (users.type() != Json::objectValue) 486 if (users.type() != Json::objectValue)
442 { 487 {
443 LOG(ERROR) << "Badly formatted list of users"; 488 LOG(ERROR) << "Badly formatted list of users";
444 throw OrthancException(ErrorCode_BadFileFormat); 489 throw OrthancException(ErrorCode_BadFileFormat);
445 } 490 }
492 { 537 {
493 boost::mutex::scoped_lock lock(globalMutex_); 538 boost::mutex::scoped_lock lock(globalMutex_);
494 539
495 target.clear(); 540 target.clear();
496 541
497 if (configuration_.get() == NULL || 542 if (!configuration_.isMember(key))
498 !configuration_->isMember(key))
499 { 543 {
500 return; 544 return;
501 } 545 }
502 546
503 const Json::Value& lst = (*configuration_) [key]; 547 const Json::Value& lst = configuration_[key];
504 548
505 if (lst.type() != Json::arrayValue) 549 if (lst.type() != Json::arrayValue)
506 { 550 {
507 LOG(ERROR) << "Badly formatted list of strings"; 551 LOG(ERROR) << "Badly formatted list of strings";
508 throw OrthancException(ErrorCode_BadFileFormat); 552 throw OrthancException(ErrorCode_BadFileFormat);
596 void Configuration::UpdateModality(const std::string& symbolicName, 640 void Configuration::UpdateModality(const std::string& symbolicName,
597 const RemoteModalityParameters& modality) 641 const RemoteModalityParameters& modality)
598 { 642 {
599 boost::mutex::scoped_lock lock(globalMutex_); 643 boost::mutex::scoped_lock lock(globalMutex_);
600 644
601 if (configuration_.get() == NULL) 645 if (!configuration_.isMember("DicomModalities"))
602 { 646 {
603 LOG(ERROR) << "The configuration file was not properly loaded"; 647 configuration_["DicomModalities"] = Json::objectValue;
604 throw OrthancException(ErrorCode_InternalError); 648 }
605 } 649
606 650 Json::Value& modalities = configuration_["DicomModalities"];
607 if (!configuration_->isMember("DicomModalities"))
608 {
609 (*configuration_) ["DicomModalities"] = Json::objectValue;
610 }
611
612 Json::Value& modalities = (*configuration_) ["DicomModalities"];
613 if (modalities.type() != Json::objectValue) 651 if (modalities.type() != Json::objectValue)
614 { 652 {
615 LOG(ERROR) << "Bad file format for modality: " << symbolicName; 653 LOG(ERROR) << "Bad file format for modality: " << symbolicName;
616 throw OrthancException(ErrorCode_BadFileFormat); 654 throw OrthancException(ErrorCode_BadFileFormat);
617 } 655 }
626 664
627 void Configuration::RemoveModality(const std::string& symbolicName) 665 void Configuration::RemoveModality(const std::string& symbolicName)
628 { 666 {
629 boost::mutex::scoped_lock lock(globalMutex_); 667 boost::mutex::scoped_lock lock(globalMutex_);
630 668
631 if (configuration_.get() == NULL) 669 if (!configuration_.isMember("DicomModalities"))
632 {
633 LOG(ERROR) << "The configuration file was not properly loaded";
634 throw OrthancException(ErrorCode_InternalError);
635 }
636
637 if (!configuration_->isMember("DicomModalities"))
638 { 670 {
639 LOG(ERROR) << "No modality with symbolic name: " << symbolicName; 671 LOG(ERROR) << "No modality with symbolic name: " << symbolicName;
640 throw OrthancException(ErrorCode_BadFileFormat); 672 throw OrthancException(ErrorCode_BadFileFormat);
641 } 673 }
642 674
643 Json::Value& modalities = (*configuration_) ["DicomModalities"]; 675 Json::Value& modalities = configuration_["DicomModalities"];
644 if (modalities.type() != Json::objectValue) 676 if (modalities.type() != Json::objectValue)
645 { 677 {
646 LOG(ERROR) << "Bad file format for the \"DicomModalities\" configuration section"; 678 LOG(ERROR) << "Bad file format for the \"DicomModalities\" configuration section";
647 throw OrthancException(ErrorCode_BadFileFormat); 679 throw OrthancException(ErrorCode_BadFileFormat);
648 } 680 }
654 void Configuration::UpdatePeer(const std::string& symbolicName, 686 void Configuration::UpdatePeer(const std::string& symbolicName,
655 const OrthancPeerParameters& peer) 687 const OrthancPeerParameters& peer)
656 { 688 {
657 boost::mutex::scoped_lock lock(globalMutex_); 689 boost::mutex::scoped_lock lock(globalMutex_);
658 690
659 if (configuration_.get() == NULL) 691 if (!configuration_.isMember("OrthancPeers"))
660 {
661 LOG(ERROR) << "The configuration file was not properly loaded";
662 throw OrthancException(ErrorCode_InternalError);
663 }
664
665 if (!configuration_->isMember("OrthancPeers"))
666 { 692 {
667 LOG(ERROR) << "No peer with symbolic name: " << symbolicName; 693 LOG(ERROR) << "No peer with symbolic name: " << symbolicName;
668 (*configuration_) ["OrthancPeers"] = Json::objectValue; 694 configuration_["OrthancPeers"] = Json::objectValue;
669 } 695 }
670 696
671 Json::Value& peers = (*configuration_) ["OrthancPeers"]; 697 Json::Value& peers = configuration_["OrthancPeers"];
672 if (peers.type() != Json::objectValue) 698 if (peers.type() != Json::objectValue)
673 { 699 {
674 LOG(ERROR) << "Bad file format for the \"OrthancPeers\" configuration section"; 700 LOG(ERROR) << "Bad file format for the \"OrthancPeers\" configuration section";
675 throw OrthancException(ErrorCode_BadFileFormat); 701 throw OrthancException(ErrorCode_BadFileFormat);
676 } 702 }
685 711
686 void Configuration::RemovePeer(const std::string& symbolicName) 712 void Configuration::RemovePeer(const std::string& symbolicName)
687 { 713 {
688 boost::mutex::scoped_lock lock(globalMutex_); 714 boost::mutex::scoped_lock lock(globalMutex_);
689 715
690 if (configuration_.get() == NULL) 716 if (!configuration_.isMember("OrthancPeers"))
691 {
692 LOG(ERROR) << "The configuration file was not properly loaded";
693 throw OrthancException(ErrorCode_InternalError);
694 }
695
696 if (!configuration_->isMember("OrthancPeers"))
697 { 717 {
698 LOG(ERROR) << "No peer with symbolic name: " << symbolicName; 718 LOG(ERROR) << "No peer with symbolic name: " << symbolicName;
699 throw OrthancException(ErrorCode_BadFileFormat); 719 throw OrthancException(ErrorCode_BadFileFormat);
700 } 720 }
701 721
702 Json::Value& peers = (*configuration_) ["OrthancPeers"]; 722 Json::Value& peers = configuration_["OrthancPeers"];
703 if (peers.type() != Json::objectValue) 723 if (peers.type() != Json::objectValue)
704 { 724 {
705 LOG(ERROR) << "Bad file format for the \"OrthancPeers\" configuration section"; 725 LOG(ERROR) << "Bad file format for the \"OrthancPeers\" configuration section";
706 throw OrthancException(ErrorCode_BadFileFormat); 726 throw OrthancException(ErrorCode_BadFileFormat);
707 } 727 }