orthanc: Plugins/Engine/OrthancPlugins.cpp comparison

comparison Plugins/Engine/OrthancPlugins.cpp @ 3393:2cd0369a156f

support of chunked answers in HttpClient and in SDK

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Thu, 06 Jun 2019 16:12:55 +0200
parents	ad434967a68c
children	0ce9b4f5fdf5

comparison

equal deleted inserted replaced

-:ad434967a68c
+:2cd0369a156f
 #if !defined(DCMTK_VERSION_NUMBER)
 #  error The macro DCMTK_VERSION_NUMBER must be defined
 #endif
-#include "../../Core/ChunkedBuffer.h"
 #include "../../Core/Compression/GzipCompressor.h"
 #include "../../Core/Compression/ZlibCompressor.h"
 #include "../../Core/DicomFormat/DicomArray.h"
 #include "../../Core/DicomParsing/DicomWebJsonVisitor.h"
 #include "../../Core/DicomParsing/FromDcmtkBridge.h"
 }
 }
 public:
 DicomWebBinaryFormatter(const _OrthancPluginEncodeDicomWeb& parameters) :
 callback_(parameters.callback)
 {
 }
 virtual DicomWebJsonVisitor::BinaryMode Format(std::string& bulkDataUri,
 const std::vector<DicomTag>& parentTags,
 std::auto_ptr<std::string>  errorDetails_;
 bool                        logDetails_;
 public:
 PluginHttpOutput(HttpOutput& output) :
 output_(output),
 logDetails_(false)
 {
 }
 HttpOutput& GetOutput()
 {
 boost::mutex::scoped_lock  lock_;
 ServerContext* context_;
 public:
 ServerContextLock(PImpl& that) :
 lock_(that.contextMutex_),
 context_(that.context_)
 {
 if (context_ == NULL)
 {
 throw OrthancException(ErrorCode_DatabaseNotInitialized);
 }
 }
 };
-class OrthancPlugins::HttpRequestBody : public HttpClient::IRequestChunkedBody
+class OrthancPlugins::StreamingHttpRequest : public HttpClient::IRequestBody
 {
 private:
-const _OrthancPluginHttpClientChunkedBody&  params_;
+const _OrthancPluginStreamingHttpClient&  params_;
-PluginsErrorDictionary&                     errorDictionary_;
+PluginsErrorDictionary&                   errorDictionary_;
 public:
-HttpRequestBody(const _OrthancPluginHttpClientChunkedBody& params,
+StreamingHttpRequest(const _OrthancPluginStreamingHttpClient& params,
 PluginsErrorDictionary&  errorDictionary) :
 params_(params),
 errorDictionary_(errorDictionary)
 {
 }
 virtual bool ReadNextChunk(std::string& chunk)
 {
-if (params_.requestBodyIsDone(params_.requestBody))
+if (params_.requestIsDone(params_.request))
 {
 return false;
 }
 else
 {
-size_t size = params_.requestBodyChunkSize(params_.requestBody);
+size_t size = params_.requestChunkSize(params_.request);
 chunk.resize(size);
 if (size != 0)
 {
-const void* data = params_.requestBodyChunkData(params_.requestBody);
+const void* data = params_.requestChunkData(params_.request);
 memcpy(&chunk[0], data, size);
 }
-OrthancPluginErrorCode error = params_.requestBodyNext(params_.requestBody);
+OrthancPluginErrorCode error = params_.requestNext(params_.request);
 if (error != OrthancPluginErrorCode_Success)
 {
 errorDictionary_.LogError(error, true);
 throw OrthancException(static_cast<ErrorCode>(error));
 }
 else
 {
 return true;
 }
+}
+}
+};
+class OrthancPlugins::StreamingHttpAnswer : public HttpClient::IAnswer
+{
+private:
+const _OrthancPluginStreamingHttpClient&  params_;
+PluginsErrorDictionary&                   errorDictionary_;
+public:
+StreamingHttpAnswer(const _OrthancPluginStreamingHttpClient& params,
+PluginsErrorDictionary&  errorDictionary) :
+params_(params),
+errorDictionary_(errorDictionary)
+{
+}
+virtual void AddHeader(const std::string& key,
+const std::string& value)
+{
+OrthancPluginErrorCode error = params_.answerAddHeader(params_.answer, key.c_str(), value.c_str());
+if (error != OrthancPluginErrorCode_Success)
+{
+errorDictionary_.LogError(error, true);
+throw OrthancException(static_cast<ErrorCode>(error));
+}
+}
+virtual void AddChunk(const void* data,
+size_t size)
+{
+OrthancPluginErrorCode error = params_.answerAddChunk(params_.answer, data, size);
+if (error != OrthancPluginErrorCode_Success)
+{
+errorDictionary_.LogError(error, true);
+throw OrthancException(static_cast<ErrorCode>(error));
 }
 }
 };
 CopyToMemoryBuffer(*p.target, compressed.size() > 0 ? compressed.c_str() : NULL, compressed.size());
 }
-static void RunHttpClient(HttpClient& client,
+static void SetupHttpClient(HttpClient& client,
 const _OrthancPluginCallHttpClient2& parameters)
 {
 client.SetUrl(parameters.url);
 client.SetConvertHeadersToLowerCase(false);
 if (parameters.timeout != 0)
 break;
 default:
 throw OrthancException(ErrorCode_ParameterOutOfRange);
 }
+}
+static void ExecuteHttpClientWithoutStream(uint16_t& httpStatus,
+OrthancPluginMemoryBuffer* answerBody,
+OrthancPluginMemoryBuffer* answerHeaders,
+HttpClient& client)
+{
+if (answerBody == NULL)
+{
+throw OrthancException(ErrorCode_NullPointer);
+}
 std::string body;
 HttpClient::HttpHeaders headers;
 bool success = client.Apply(body, headers);
 // The HTTP request has succeeded
-*parameters.httpStatus = static_cast<uint16_t>(client.GetLastStatus());
+httpStatus = static_cast<uint16_t>(client.GetLastStatus());
 if (!success)
 {
 HttpClient::ThrowException(client.GetLastStatus());
 }
 // Copy the HTTP headers of the answer, if the plugin requested them
-if (parameters.answerHeaders != NULL)
+if (answerHeaders != NULL)
 {
 Json::Value json = Json::objectValue;
 for (HttpClient::HttpHeaders::const_iterator
 it = headers.begin(); it != headers.end(); ++it)
 {
 json[it->first] = it->second;
 }
 std::string s = json.toStyledString();
-CopyToMemoryBuffer(*parameters.answerHeaders, s);
+CopyToMemoryBuffer(*answerHeaders, s);
 }
 // Copy the body of the answer if it makes sense
-if (parameters.method != OrthancPluginHttpMethod_Delete)
+if (client.GetMethod() != HttpMethod_Delete)
 {
-CopyToMemoryBuffer(*parameters.answerBody, body);
+CopyToMemoryBuffer(*answerBody, body);
 }
 }
 void OrthancPlugins::CallHttpClient(const void* parameters)
 {
 const _OrthancPluginCallHttpClient& p = *reinterpret_cast<const _OrthancPluginCallHttpClient*>(parameters);
-_OrthancPluginCallHttpClient2 converted;
-memset(&converted, 0, sizeof(converted));
-uint16_t httpStatus;
-converted.answerBody = p.target;
-converted.answerHeaders = NULL;
-converted.httpStatus = &httpStatus;
-converted.method = p.method;
-converted.url = p.url;
-converted.headersCount = 0;
-converted.headersKeys = NULL;
-converted.headersValues = NULL;
-converted.body = p.body;
-converted.bodySize = p.bodySize;
-converted.username = p.username;
-converted.password = p.password;
-converted.timeout = 0;  // Use default timeout
-converted.certificateFile = NULL;
-converted.certificateKeyFile = NULL;
-converted.certificateKeyPassword = NULL;
-converted.pkcs11 = false;
 HttpClient client;
-RunHttpClient(client, converted);
+{
+_OrthancPluginCallHttpClient2 converted;
+memset(&converted, 0, sizeof(converted));
+converted.answerBody = NULL;
+converted.answerHeaders = NULL;
+converted.httpStatus = NULL;
+converted.method = p.method;
+converted.url = p.url;
+converted.headersCount = 0;
+converted.headersKeys = NULL;
+converted.headersValues = NULL;
+converted.body = p.body;
+converted.bodySize = p.bodySize;
+converted.username = p.username;
+converted.password = p.password;
+converted.timeout = 0;  // Use default timeout
+converted.certificateFile = NULL;
+converted.certificateKeyFile = NULL;
+converted.certificateKeyPassword = NULL;
+converted.pkcs11 = false;
+SetupHttpClient(client, converted);
+}
+uint16_t status;
+ExecuteHttpClientWithoutStream(status, p.target, NULL, client);
 }
 void OrthancPlugins::CallHttpClient2(const void* parameters)
 {
 const _OrthancPluginCallHttpClient2& p = *reinterpret_cast<const _OrthancPluginCallHttpClient2*>(parameters);
+if (p.httpStatus == NULL)
+{
+throw OrthancException(ErrorCode_NullPointer);
+}
 HttpClient client;
 if (p.method == OrthancPluginHttpMethod_Post ||
 p.method == OrthancPluginHttpMethod_Put)
 {
 client.GetBody().assign(p.body, p.bodySize);
 }
-RunHttpClient(client, p);
+SetupHttpClient(client, p);
-}
+ExecuteHttpClientWithoutStream(*p.httpStatus, p.answerBody, p.answerHeaders, client);
+}
-void OrthancPlugins::HttpClientChunkedBody(const void* parameters)
-{
+void OrthancPlugins::StreamingHttpClient(const void* parameters)
-const _OrthancPluginHttpClientChunkedBody& p =
+{
-*reinterpret_cast<const _OrthancPluginHttpClientChunkedBody*>(parameters);
+const _OrthancPluginStreamingHttpClient& p =
+*reinterpret_cast<const _OrthancPluginStreamingHttpClient*>(parameters);
+if (p.httpStatus == NULL)
+{
+throw OrthancException(ErrorCode_NullPointer);
+}
+HttpClient client;
+{
+_OrthancPluginCallHttpClient2 converted;
+memset(&converted, 0, sizeof(converted));
+converted.answerBody = NULL;
+converted.answerHeaders = NULL;
+converted.httpStatus = NULL;
+converted.method = p.method;
+converted.url = p.url;
+converted.headersCount = p.headersCount;
+converted.headersKeys = p.headersKeys;
+converted.headersValues = p.headersValues;
+converted.body = NULL;
+converted.bodySize = 0;
+converted.username = p.username;
+converted.password = p.password;
+converted.timeout = p.timeout;
+converted.certificateFile = p.certificateFile;
+converted.certificateKeyFile = p.certificateKeyFile;
+converted.certificateKeyPassword = p.certificateKeyPassword;
+converted.pkcs11 = p.pkcs11;
+SetupHttpClient(client, converted);
+}
-if (p.method != OrthancPluginHttpMethod_Post &&
+StreamingHttpRequest body(p, pimpl_->dictionary_);
-p.method != OrthancPluginHttpMethod_Put)
-{
-throw OrthancException(ErrorCode_ParameterOutOfRange,
-"This plugin service is only allowed for PUT and POST HTTP requests");
-}
-HttpRequestBody body(p, pimpl_->dictionary_);
-HttpClient client;
 client.SetBody(body);
-_OrthancPluginCallHttpClient2 converted;
+StreamingHttpAnswer answer(p, pimpl_->dictionary_);
-memset(&converted, 0, sizeof(converted));
+bool success = client.Apply(answer);
-converted.answerBody = p.answerBody;
-converted.answerHeaders = p.answerHeaders;
+*p.httpStatus = static_cast<uint16_t>(client.GetLastStatus());
-converted.httpStatus = p.httpStatus;
-converted.method = p.method;
+if (!success)
-converted.url = p.url;
+{
-converted.headersCount = p.headersCount;
+HttpClient::ThrowException(client.GetLastStatus());
-converted.headersKeys = p.headersKeys;
+}
-converted.headersValues = p.headersValues;
-converted.body = NULL;
-converted.bodySize = 0;
-converted.username = p.username;
-converted.password = p.password;
-converted.timeout = p.timeout;
-converted.certificateFile = p.certificateFile;
-converted.certificateKeyFile = p.certificateKeyFile;
-converted.certificateKeyPassword = p.certificateKeyPassword;
-converted.pkcs11 = p.pkcs11;
-RunHttpClient(client, converted);
 }
 void OrthancPlugins::CallPeerApi(const void* parameters)
 {
 case _OrthancPluginService_CallHttpClient2:
 CallHttpClient2(parameters);
 return true;
-case _OrthancPluginService_HttpClientChunkedBody:
+case _OrthancPluginService_StreamingHttpClient:
-HttpClientChunkedBody(parameters);
+StreamingHttpClient(parameters);
 return true;
 case _OrthancPluginService_ConvertPixelFormat:
 ConvertPixelFormat(parameters);
 return true;

Mercurial > hg > orthanc

comparison Plugins/Engine/OrthancPlugins.cpp @ 3393:2cd0369a156f