Mercurial > hg > orthanc

comparison OrthancServer/Plugins/Engine/OrthancPlugins.cpp @ 4271:1bd14c900699

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
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