Mercurial > hg > orthanc
comparison OrthancServer/Plugins/Engine/OrthancPlugins.cpp @ 4271:1bd14c900699
LogCategory_PLUGINS
author | Sebastien Jodogne <s.jodogne@gmail.com> |
---|---|
date | Tue, 03 Nov 2020 07:15:44 +0100 |
parents | 0ae2ca210077 |
children | cb9aef006229 |
comparison
equal
deleted
inserted
replaced
4270:251a8b07fa37 | 4271:1bd14c900699 |
---|---|
1736 { | 1736 { |
1737 return false; | 1737 return false; |
1738 } | 1738 } |
1739 else | 1739 else |
1740 { | 1740 { |
1741 LOG(INFO) << "Delegating HTTP request to plugin for URI: " << matcher.GetFlatUri(); | 1741 CLOG(INFO, PLUGINS) << "Delegating HTTP request to plugin for URI: " << matcher.GetFlatUri(); |
1742 | 1742 |
1743 OrthancPluginRestCallback handler; | 1743 OrthancPluginRestCallback handler; |
1744 | 1744 |
1745 switch (method) | 1745 switch (method) |
1746 { | 1746 { |
1810 { | 1810 { |
1811 // Callback not found, try to find a chunked callback | 1811 // Callback not found, try to find a chunked callback |
1812 return HandleChunkedGetDelete(output, method, uri, headers, getArguments); | 1812 return HandleChunkedGetDelete(output, method, uri, headers, getArguments); |
1813 } | 1813 } |
1814 | 1814 |
1815 LOG(INFO) << "Delegating HTTP request to plugin for URI: " << matcher.GetFlatUri(); | 1815 CLOG(INFO, PLUGINS) << "Delegating HTTP request to plugin for URI: " << matcher.GetFlatUri(); |
1816 | 1816 |
1817 HttpRequestConverter converter(matcher, method, headers); | 1817 HttpRequestConverter converter(matcher, method, headers); |
1818 converter.SetGetArguments(getArguments); | 1818 converter.SetGetArguments(getArguments); |
1819 converter.GetRequest().body = bodyData; | 1819 converter.GetRequest().body = bodyData; |
1820 converter.GetRequest().bodySize = bodySize; | 1820 converter.GetRequest().bodySize = bodySize; |
2007 bool lock) | 2007 bool lock) |
2008 { | 2008 { |
2009 const _OrthancPluginRestCallback& p = | 2009 const _OrthancPluginRestCallback& p = |
2010 *reinterpret_cast<const _OrthancPluginRestCallback*>(parameters); | 2010 *reinterpret_cast<const _OrthancPluginRestCallback*>(parameters); |
2011 | 2011 |
2012 LOG(INFO) << "Plugin has registered a REST callback " | 2012 CLOG(INFO, PLUGINS) << "Plugin has registered a REST callback " |
2013 << (lock ? "with" : "without") | 2013 << (lock ? "with" : "without") |
2014 << " mutual exclusion on: " | 2014 << " mutual exclusion on: " |
2015 << p.pathRegularExpression; | 2015 << p.pathRegularExpression; |
2016 | 2016 |
2017 pimpl_->restCallbacks_.push_back(new PImpl::RestCallback(p.pathRegularExpression, p.callback, lock)); | 2017 pimpl_->restCallbacks_.push_back(new PImpl::RestCallback(p.pathRegularExpression, p.callback, lock)); |
2018 } | 2018 } |
2019 | 2019 |
2020 | 2020 |
2021 void OrthancPlugins::RegisterChunkedRestCallback(const void* parameters) | 2021 void OrthancPlugins::RegisterChunkedRestCallback(const void* parameters) |
2022 { | 2022 { |
2023 const _OrthancPluginChunkedRestCallback& p = | 2023 const _OrthancPluginChunkedRestCallback& p = |
2024 *reinterpret_cast<const _OrthancPluginChunkedRestCallback*>(parameters); | 2024 *reinterpret_cast<const _OrthancPluginChunkedRestCallback*>(parameters); |
2025 | 2025 |
2026 LOG(INFO) << "Plugin has registered a REST callback for chunked streams on: " | 2026 CLOG(INFO, PLUGINS) << "Plugin has registered a REST callback for chunked streams on: " |
2027 << p.pathRegularExpression; | 2027 << p.pathRegularExpression; |
2028 | 2028 |
2029 pimpl_->chunkedRestCallbacks_.push_back(new PImpl::ChunkedRestCallback(p)); | 2029 pimpl_->chunkedRestCallbacks_.push_back(new PImpl::ChunkedRestCallback(p)); |
2030 } | 2030 } |
2031 | 2031 |
2032 | 2032 |
2033 void OrthancPlugins::RegisterOnStoredInstanceCallback(const void* parameters) | 2033 void OrthancPlugins::RegisterOnStoredInstanceCallback(const void* parameters) |
2034 { | 2034 { |
2035 const _OrthancPluginOnStoredInstanceCallback& p = | 2035 const _OrthancPluginOnStoredInstanceCallback& p = |
2036 *reinterpret_cast<const _OrthancPluginOnStoredInstanceCallback*>(parameters); | 2036 *reinterpret_cast<const _OrthancPluginOnStoredInstanceCallback*>(parameters); |
2037 | 2037 |
2038 LOG(INFO) << "Plugin has registered an OnStoredInstance callback"; | 2038 CLOG(INFO, PLUGINS) << "Plugin has registered an OnStoredInstance callback"; |
2039 pimpl_->onStoredCallbacks_.push_back(p.callback); | 2039 pimpl_->onStoredCallbacks_.push_back(p.callback); |
2040 } | 2040 } |
2041 | 2041 |
2042 | 2042 |
2043 void OrthancPlugins::RegisterOnChangeCallback(const void* parameters) | 2043 void OrthancPlugins::RegisterOnChangeCallback(const void* parameters) |
2044 { | 2044 { |
2045 const _OrthancPluginOnChangeCallback& p = | 2045 const _OrthancPluginOnChangeCallback& p = |
2046 *reinterpret_cast<const _OrthancPluginOnChangeCallback*>(parameters); | 2046 *reinterpret_cast<const _OrthancPluginOnChangeCallback*>(parameters); |
2047 | 2047 |
2048 LOG(INFO) << "Plugin has registered an OnChange callback"; | 2048 CLOG(INFO, PLUGINS) << "Plugin has registered an OnChange callback"; |
2049 pimpl_->onChangeCallbacks_.push_back(p.callback); | 2049 pimpl_->onChangeCallbacks_.push_back(p.callback); |
2050 } | 2050 } |
2051 | 2051 |
2052 | 2052 |
2053 void OrthancPlugins::RegisterWorklistCallback(const void* parameters) | 2053 void OrthancPlugins::RegisterWorklistCallback(const void* parameters) |
2062 throw OrthancException(ErrorCode_Plugin, | 2062 throw OrthancException(ErrorCode_Plugin, |
2063 "Can only register one plugin to handle modality worklists"); | 2063 "Can only register one plugin to handle modality worklists"); |
2064 } | 2064 } |
2065 else | 2065 else |
2066 { | 2066 { |
2067 LOG(INFO) << "Plugin has registered a callback to handle modality worklists"; | 2067 CLOG(INFO, PLUGINS) << "Plugin has registered a callback to handle modality worklists"; |
2068 pimpl_->worklistCallback_ = p.callback; | 2068 pimpl_->worklistCallback_ = p.callback; |
2069 } | 2069 } |
2070 } | 2070 } |
2071 | 2071 |
2072 | 2072 |
2082 throw OrthancException(ErrorCode_Plugin, | 2082 throw OrthancException(ErrorCode_Plugin, |
2083 "Can only register one plugin to handle C-FIND requests"); | 2083 "Can only register one plugin to handle C-FIND requests"); |
2084 } | 2084 } |
2085 else | 2085 else |
2086 { | 2086 { |
2087 LOG(INFO) << "Plugin has registered a callback to handle C-FIND requests"; | 2087 CLOG(INFO, PLUGINS) << "Plugin has registered a callback to handle C-FIND requests"; |
2088 pimpl_->findCallback_ = p.callback; | 2088 pimpl_->findCallback_ = p.callback; |
2089 } | 2089 } |
2090 } | 2090 } |
2091 | 2091 |
2092 | 2092 |
2102 throw OrthancException(ErrorCode_Plugin, | 2102 throw OrthancException(ErrorCode_Plugin, |
2103 "Can only register one plugin to handle C-MOVE requests"); | 2103 "Can only register one plugin to handle C-MOVE requests"); |
2104 } | 2104 } |
2105 else | 2105 else |
2106 { | 2106 { |
2107 LOG(INFO) << "Plugin has registered a callback to handle C-MOVE requests"; | 2107 CLOG(INFO, PLUGINS) << "Plugin has registered a callback to handle C-MOVE requests"; |
2108 pimpl_->moveCallbacks_ = p; | 2108 pimpl_->moveCallbacks_ = p; |
2109 } | 2109 } |
2110 } | 2110 } |
2111 | 2111 |
2112 | 2112 |
2116 *reinterpret_cast<const _OrthancPluginDecodeImageCallback*>(parameters); | 2116 *reinterpret_cast<const _OrthancPluginDecodeImageCallback*>(parameters); |
2117 | 2117 |
2118 boost::unique_lock<boost::shared_mutex> lock(pimpl_->decoderTranscoderMutex_); | 2118 boost::unique_lock<boost::shared_mutex> lock(pimpl_->decoderTranscoderMutex_); |
2119 | 2119 |
2120 pimpl_->decodeImageCallbacks_.push_back(p.callback); | 2120 pimpl_->decodeImageCallbacks_.push_back(p.callback); |
2121 LOG(INFO) << "Plugin has registered a callback to decode DICOM images (" | 2121 CLOG(INFO, PLUGINS) << "Plugin has registered a callback to decode DICOM images (" |
2122 << pimpl_->decodeImageCallbacks_.size() << " decoder(s) now active)"; | 2122 << pimpl_->decodeImageCallbacks_.size() << " decoder(s) now active)"; |
2123 } | 2123 } |
2124 | 2124 |
2125 | 2125 |
2126 void OrthancPlugins::RegisterTranscoderCallback(const void* parameters) | 2126 void OrthancPlugins::RegisterTranscoderCallback(const void* parameters) |
2127 { | 2127 { |
2129 *reinterpret_cast<const _OrthancPluginTranscoderCallback*>(parameters); | 2129 *reinterpret_cast<const _OrthancPluginTranscoderCallback*>(parameters); |
2130 | 2130 |
2131 boost::unique_lock<boost::shared_mutex> lock(pimpl_->decoderTranscoderMutex_); | 2131 boost::unique_lock<boost::shared_mutex> lock(pimpl_->decoderTranscoderMutex_); |
2132 | 2132 |
2133 pimpl_->transcoderCallbacks_.push_back(p.callback); | 2133 pimpl_->transcoderCallbacks_.push_back(p.callback); |
2134 LOG(INFO) << "Plugin has registered a callback to transcode DICOM images (" | 2134 CLOG(INFO, PLUGINS) << "Plugin has registered a callback to transcode DICOM images (" |
2135 << pimpl_->transcoderCallbacks_.size() << " transcoder(s) now active)"; | 2135 << pimpl_->transcoderCallbacks_.size() << " transcoder(s) now active)"; |
2136 } | 2136 } |
2137 | 2137 |
2138 | 2138 |
2139 void OrthancPlugins::RegisterJobsUnserializer(const void* parameters) | 2139 void OrthancPlugins::RegisterJobsUnserializer(const void* parameters) |
2140 { | 2140 { |
2142 *reinterpret_cast<const _OrthancPluginJobsUnserializer*>(parameters); | 2142 *reinterpret_cast<const _OrthancPluginJobsUnserializer*>(parameters); |
2143 | 2143 |
2144 boost::mutex::scoped_lock lock(pimpl_->jobsUnserializersMutex_); | 2144 boost::mutex::scoped_lock lock(pimpl_->jobsUnserializersMutex_); |
2145 | 2145 |
2146 pimpl_->jobsUnserializers_.push_back(p.unserializer); | 2146 pimpl_->jobsUnserializers_.push_back(p.unserializer); |
2147 LOG(INFO) << "Plugin has registered a callback to unserialize jobs (" | 2147 CLOG(INFO, PLUGINS) << "Plugin has registered a callback to unserialize jobs (" |
2148 << pimpl_->jobsUnserializers_.size() << " unserializer(s) now active)"; | 2148 << pimpl_->jobsUnserializers_.size() << " unserializer(s) now active)"; |
2149 } | 2149 } |
2150 | 2150 |
2151 | 2151 |
2152 void OrthancPlugins::RegisterIncomingHttpRequestFilter(const void* parameters) | 2152 void OrthancPlugins::RegisterIncomingHttpRequestFilter(const void* parameters) |
2153 { | 2153 { |
2154 const _OrthancPluginIncomingHttpRequestFilter& p = | 2154 const _OrthancPluginIncomingHttpRequestFilter& p = |
2155 *reinterpret_cast<const _OrthancPluginIncomingHttpRequestFilter*>(parameters); | 2155 *reinterpret_cast<const _OrthancPluginIncomingHttpRequestFilter*>(parameters); |
2156 | 2156 |
2157 LOG(INFO) << "Plugin has registered a callback to filter incoming HTTP requests"; | 2157 CLOG(INFO, PLUGINS) << "Plugin has registered a callback to filter incoming HTTP requests"; |
2158 pimpl_->incomingHttpRequestFilters_.push_back(p.callback); | 2158 pimpl_->incomingHttpRequestFilters_.push_back(p.callback); |
2159 } | 2159 } |
2160 | 2160 |
2161 | 2161 |
2162 void OrthancPlugins::RegisterIncomingHttpRequestFilter2(const void* parameters) | 2162 void OrthancPlugins::RegisterIncomingHttpRequestFilter2(const void* parameters) |
2163 { | 2163 { |
2164 const _OrthancPluginIncomingHttpRequestFilter2& p = | 2164 const _OrthancPluginIncomingHttpRequestFilter2& p = |
2165 *reinterpret_cast<const _OrthancPluginIncomingHttpRequestFilter2*>(parameters); | 2165 *reinterpret_cast<const _OrthancPluginIncomingHttpRequestFilter2*>(parameters); |
2166 | 2166 |
2167 LOG(INFO) << "Plugin has registered a callback to filter incoming HTTP requests"; | 2167 CLOG(INFO, PLUGINS) << "Plugin has registered a callback to filter incoming HTTP requests"; |
2168 pimpl_->incomingHttpRequestFilters2_.push_back(p.callback); | 2168 pimpl_->incomingHttpRequestFilters2_.push_back(p.callback); |
2169 } | 2169 } |
2170 | 2170 |
2171 | 2171 |
2172 void OrthancPlugins::RegisterIncomingDicomInstanceFilter(const void* parameters) | 2172 void OrthancPlugins::RegisterIncomingDicomInstanceFilter(const void* parameters) |
2173 { | 2173 { |
2174 const _OrthancPluginIncomingDicomInstanceFilter& p = | 2174 const _OrthancPluginIncomingDicomInstanceFilter& p = |
2175 *reinterpret_cast<const _OrthancPluginIncomingDicomInstanceFilter*>(parameters); | 2175 *reinterpret_cast<const _OrthancPluginIncomingDicomInstanceFilter*>(parameters); |
2176 | 2176 |
2177 LOG(INFO) << "Plugin has registered a callback to filter incoming DICOM instances"; | 2177 CLOG(INFO, PLUGINS) << "Plugin has registered a callback to filter incoming DICOM instances"; |
2178 pimpl_->incomingDicomInstanceFilters_.push_back(p.callback); | 2178 pimpl_->incomingDicomInstanceFilters_.push_back(p.callback); |
2179 } | 2179 } |
2180 | 2180 |
2181 | 2181 |
2182 void OrthancPlugins::RegisterRefreshMetricsCallback(const void* parameters) | 2182 void OrthancPlugins::RegisterRefreshMetricsCallback(const void* parameters) |
2184 const _OrthancPluginRegisterRefreshMetricsCallback& p = | 2184 const _OrthancPluginRegisterRefreshMetricsCallback& p = |
2185 *reinterpret_cast<const _OrthancPluginRegisterRefreshMetricsCallback*>(parameters); | 2185 *reinterpret_cast<const _OrthancPluginRegisterRefreshMetricsCallback*>(parameters); |
2186 | 2186 |
2187 boost::mutex::scoped_lock lock(pimpl_->refreshMetricsMutex_); | 2187 boost::mutex::scoped_lock lock(pimpl_->refreshMetricsMutex_); |
2188 | 2188 |
2189 LOG(INFO) << "Plugin has registered a callback to refresh its metrics"; | 2189 CLOG(INFO, PLUGINS) << "Plugin has registered a callback to refresh its metrics"; |
2190 pimpl_->refreshMetricsCallbacks_.push_back(p.callback); | 2190 pimpl_->refreshMetricsCallbacks_.push_back(p.callback); |
2191 } | 2191 } |
2192 | 2192 |
2193 | 2193 |
2194 void OrthancPlugins::RegisterStorageCommitmentScpCallback(const void* parameters) | 2194 void OrthancPlugins::RegisterStorageCommitmentScpCallback(const void* parameters) |
2195 { | 2195 { |
2196 const _OrthancPluginRegisterStorageCommitmentScpCallback& p = | 2196 const _OrthancPluginRegisterStorageCommitmentScpCallback& p = |
2197 *reinterpret_cast<const _OrthancPluginRegisterStorageCommitmentScpCallback*>(parameters); | 2197 *reinterpret_cast<const _OrthancPluginRegisterStorageCommitmentScpCallback*>(parameters); |
2198 | 2198 |
2199 boost::mutex::scoped_lock lock(pimpl_->storageCommitmentScpMutex_); | 2199 boost::mutex::scoped_lock lock(pimpl_->storageCommitmentScpMutex_); |
2200 LOG(INFO) << "Plugin has registered a storage commitment callback"; | 2200 CLOG(INFO, PLUGINS) << "Plugin has registered a storage commitment callback"; |
2201 | 2201 |
2202 pimpl_->storageCommitmentScpCallbacks_.push_back(new PImpl::StorageCommitmentScp(p)); | 2202 pimpl_->storageCommitmentScpCallbacks_.push_back(new PImpl::StorageCommitmentScp(p)); |
2203 } | 2203 } |
2204 | 2204 |
2205 | 2205 |
2383 bool afterPlugins) | 2383 bool afterPlugins) |
2384 { | 2384 { |
2385 const _OrthancPluginRestApiGet& p = | 2385 const _OrthancPluginRestApiGet& p = |
2386 *reinterpret_cast<const _OrthancPluginRestApiGet*>(parameters); | 2386 *reinterpret_cast<const _OrthancPluginRestApiGet*>(parameters); |
2387 | 2387 |
2388 LOG(INFO) << "Plugin making REST GET call on URI " << p.uri | 2388 CLOG(INFO, PLUGINS) << "Plugin making REST GET call on URI " << p.uri |
2389 << (afterPlugins ? " (after plugins)" : " (built-in API)"); | 2389 << (afterPlugins ? " (after plugins)" : " (built-in API)"); |
2390 | 2390 |
2391 IHttpHandler* handler; | 2391 IHttpHandler* handler; |
2392 | 2392 |
2393 { | 2393 { |
2394 PImpl::ServerContextLock lock(*pimpl_); | 2394 PImpl::ServerContextLock lock(*pimpl_); |
2412 void OrthancPlugins::RestApiGet2(const void* parameters) | 2412 void OrthancPlugins::RestApiGet2(const void* parameters) |
2413 { | 2413 { |
2414 const _OrthancPluginRestApiGet2& p = | 2414 const _OrthancPluginRestApiGet2& p = |
2415 *reinterpret_cast<const _OrthancPluginRestApiGet2*>(parameters); | 2415 *reinterpret_cast<const _OrthancPluginRestApiGet2*>(parameters); |
2416 | 2416 |
2417 LOG(INFO) << "Plugin making REST GET call on URI " << p.uri | 2417 CLOG(INFO, PLUGINS) << "Plugin making REST GET call on URI " << p.uri |
2418 << (p.afterPlugins ? " (after plugins)" : " (built-in API)"); | 2418 << (p.afterPlugins ? " (after plugins)" : " (built-in API)"); |
2419 | 2419 |
2420 IHttpHandler::Arguments headers; | 2420 IHttpHandler::Arguments headers; |
2421 | 2421 |
2422 for (uint32_t i = 0; i < p.headersCount; i++) | 2422 for (uint32_t i = 0; i < p.headersCount; i++) |
2423 { | 2423 { |
2450 bool afterPlugins) | 2450 bool afterPlugins) |
2451 { | 2451 { |
2452 const _OrthancPluginRestApiPostPut& p = | 2452 const _OrthancPluginRestApiPostPut& p = |
2453 *reinterpret_cast<const _OrthancPluginRestApiPostPut*>(parameters); | 2453 *reinterpret_cast<const _OrthancPluginRestApiPostPut*>(parameters); |
2454 | 2454 |
2455 LOG(INFO) << "Plugin making REST " << EnumerationToString(isPost ? HttpMethod_Post : HttpMethod_Put) | 2455 CLOG(INFO, PLUGINS) << "Plugin making REST " << EnumerationToString(isPost ? HttpMethod_Post : HttpMethod_Put) |
2456 << " call on URI " << p.uri << (afterPlugins ? " (after plugins)" : " (built-in API)"); | 2456 << " call on URI " << p.uri << (afterPlugins ? " (after plugins)" : " (built-in API)"); |
2457 | 2457 |
2458 IHttpHandler* handler; | 2458 IHttpHandler* handler; |
2459 | 2459 |
2460 { | 2460 { |
2461 PImpl::ServerContextLock lock(*pimpl_); | 2461 PImpl::ServerContextLock lock(*pimpl_); |
2480 | 2480 |
2481 void OrthancPlugins::RestApiDelete(const void* parameters, | 2481 void OrthancPlugins::RestApiDelete(const void* parameters, |
2482 bool afterPlugins) | 2482 bool afterPlugins) |
2483 { | 2483 { |
2484 const char* uri = reinterpret_cast<const char*>(parameters); | 2484 const char* uri = reinterpret_cast<const char*>(parameters); |
2485 LOG(INFO) << "Plugin making REST DELETE call on URI " << uri | 2485 CLOG(INFO, PLUGINS) << "Plugin making REST DELETE call on URI " << uri |
2486 << (afterPlugins ? " (after plugins)" : " (built-in API)"); | 2486 << (afterPlugins ? " (after plugins)" : " (built-in API)"); |
2487 | 2487 |
2488 IHttpHandler* handler; | 2488 IHttpHandler* handler; |
2489 | 2489 |
2490 { | 2490 { |
2491 PImpl::ServerContextLock lock(*pimpl_); | 2491 PImpl::ServerContextLock lock(*pimpl_); |
4503 RegisterStorageCommitmentScpCallback(parameters); | 4503 RegisterStorageCommitmentScpCallback(parameters); |
4504 return true; | 4504 return true; |
4505 | 4505 |
4506 case _OrthancPluginService_RegisterStorageArea: | 4506 case _OrthancPluginService_RegisterStorageArea: |
4507 { | 4507 { |
4508 LOG(INFO) << "Plugin has registered a custom storage area"; | 4508 CLOG(INFO, PLUGINS) << "Plugin has registered a custom storage area"; |
4509 const _OrthancPluginRegisterStorageArea& p = | 4509 const _OrthancPluginRegisterStorageArea& p = |
4510 *reinterpret_cast<const _OrthancPluginRegisterStorageArea*>(parameters); | 4510 *reinterpret_cast<const _OrthancPluginRegisterStorageArea*>(parameters); |
4511 | 4511 |
4512 if (pimpl_->storageArea_.get() == NULL) | 4512 if (pimpl_->storageArea_.get() == NULL) |
4513 { | 4513 { |
4554 } | 4554 } |
4555 } | 4555 } |
4556 | 4556 |
4557 case _OrthancPluginService_RegisterDatabaseBackend: | 4557 case _OrthancPluginService_RegisterDatabaseBackend: |
4558 { | 4558 { |
4559 LOG(INFO) << "Plugin has registered a custom database back-end"; | 4559 CLOG(INFO, PLUGINS) << "Plugin has registered a custom database back-end"; |
4560 | 4560 |
4561 const _OrthancPluginRegisterDatabaseBackend& p = | 4561 const _OrthancPluginRegisterDatabaseBackend& p = |
4562 *reinterpret_cast<const _OrthancPluginRegisterDatabaseBackend*>(parameters); | 4562 *reinterpret_cast<const _OrthancPluginRegisterDatabaseBackend*>(parameters); |
4563 | 4563 |
4564 if (pimpl_->database_.get() == NULL) | 4564 if (pimpl_->database_.get() == NULL) |
4576 return true; | 4576 return true; |
4577 } | 4577 } |
4578 | 4578 |
4579 case _OrthancPluginService_RegisterDatabaseBackendV2: | 4579 case _OrthancPluginService_RegisterDatabaseBackendV2: |
4580 { | 4580 { |
4581 LOG(INFO) << "Plugin has registered a custom database back-end"; | 4581 CLOG(INFO, PLUGINS) << "Plugin has registered a custom database back-end"; |
4582 | 4582 |
4583 const _OrthancPluginRegisterDatabaseBackendV2& p = | 4583 const _OrthancPluginRegisterDatabaseBackendV2& p = |
4584 *reinterpret_cast<const _OrthancPluginRegisterDatabaseBackendV2*>(parameters); | 4584 *reinterpret_cast<const _OrthancPluginRegisterDatabaseBackendV2*>(parameters); |
4585 | 4585 |
4586 if (pimpl_->database_.get() == NULL) | 4586 if (pimpl_->database_.get() == NULL) |
4659 | 4659 |
4660 bool OrthancPlugins::InvokeService(SharedLibrary& plugin, | 4660 bool OrthancPlugins::InvokeService(SharedLibrary& plugin, |
4661 _OrthancPluginService service, | 4661 _OrthancPluginService service, |
4662 const void* parameters) | 4662 const void* parameters) |
4663 { | 4663 { |
4664 LOG(TRACE) << "Calling service " << service << " from plugin " << plugin.GetPath(); | 4664 CLOG(TRACE, PLUGINS) << "Calling service " << service << " from plugin " << plugin.GetPath(); |
4665 | 4665 |
4666 if (service == _OrthancPluginService_DatabaseAnswer) | 4666 if (service == _OrthancPluginService_DatabaseAnswer) |
4667 { | 4667 { |
4668 // This case solves a deadlock at (*) reported by James Webster | 4668 // This case solves a deadlock at (*) reported by James Webster |
4669 // on 2015-10-27 that was present in versions of Orthanc <= | 4669 // on 2015-10-27 that was present in versions of Orthanc <= |
5122 { | 5122 { |
5123 return false; | 5123 return false; |
5124 } | 5124 } |
5125 else | 5125 else |
5126 { | 5126 { |
5127 LOG(INFO) << "Delegating chunked HTTP request to plugin for URI: " << matcher.GetFlatUri(); | 5127 CLOG(INFO, PLUGINS) << "Delegating chunked HTTP request to plugin for URI: " << matcher.GetFlatUri(); |
5128 | 5128 |
5129 HttpRequestConverter converter(matcher, method, headers); | 5129 HttpRequestConverter converter(matcher, method, headers); |
5130 converter.GetRequest().body = NULL; | 5130 converter.GetRequest().body = NULL; |
5131 converter.GetRequest().bodySize = 0; | 5131 converter.GetRequest().bodySize = 0; |
5132 | 5132 |