orthanc: Plugins/Engine/OrthancPlugins.cpp comparison

comparison Plugins/Engine/OrthancPlugins.cpp @ 3662:d8371b4302ff storage-commitment

OrthancPluginRegisterStorageCommitmentScpCallback()

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Tue, 11 Feb 2020 19:59:53 +0100
parents	94f4a18a79cc
children	85acfcc15829

comparison

equal deleted inserted replaced

-:25117919a36b
+:d8371b4302ff
 return parameters_;
 }
 };
+class StorageCommitmentScp : public IStorageCommitmentFactory
+{
+private:
+class Handler : public IStorageCommitmentFactory::ILookupHandler
+{
+private:
+_OrthancPluginRegisterStorageCommitmentScpCallback  parameters_;
+void*    handler_;
+public:
+Handler(_OrthancPluginRegisterStorageCommitmentScpCallback  parameters,
+void* handler) :
+parameters_(parameters)
+{
+if (handler == NULL)
+{
+throw OrthancException(ErrorCode_NullPointer);
+}
+}
+virtual ~Handler()
+{
+assert(handler_ != NULL);
+parameters_.destructor(handler_);
+handler_ = NULL;
+}
+virtual StorageCommitmentFailureReason Lookup(const std::string& sopClassUid,
+const std::string& sopInstanceUid)
+{
+assert(handler_ != NULL);
+OrthancPluginStorageCommitmentFailureReason reason =
+OrthancPluginStorageCommitmentFailureReason_Success;
+OrthancPluginErrorCode error = parameters_.lookup(
+&reason, handler_, sopClassUid.c_str(), sopInstanceUid.c_str());
+if (error == OrthancPluginErrorCode_Success)
+{
+return Plugins::Convert(reason);
+}
+else
+{
+throw OrthancException(static_cast<ErrorCode>(error));
+}
+}
+};
+_OrthancPluginRegisterStorageCommitmentScpCallback  parameters_;
+public:
+StorageCommitmentScp(_OrthancPluginRegisterStorageCommitmentScpCallback parameters) :
+parameters_(parameters)
+{
+}
+virtual ILookupHandler* CreateStorageCommitment(
+const std::string& jobId,
+const std::string& transactionUid,
+const std::vector<std::string>& sopClassUids,
+const std::vector<std::string>& sopInstanceUids,
+const std::string& remoteAet,
+const std::string& calledAet) ORTHANC_OVERRIDE
+{
+const size_t n = sopClassUids.size();
+if (sopInstanceUids.size() != n)
+{
+throw OrthancException(ErrorCode_ParameterOutOfRange);
+}
+std::vector<const char*> a, b;
+a.resize(n);
+b.resize(n);
+for (size_t i = 0; i < n; i++)
+{
+a[i] = sopClassUids[i].c_str();
+b[i] = sopInstanceUids[i].c_str();
+}
+void* handler = parameters_.factory(jobId.c_str(), transactionUid.c_str(),
+a.empty() ? NULL : &a[0], b.empty() ? NULL : &b[0],
+static_cast<uint32_t>(n),
+remoteAet.c_str(), calledAet.c_str());
+if (handler == NULL)
+{
+return NULL;
+}
+else
+{
+return new Handler(parameters_, handler);
+}
+}
+};
 class ServerContextLock
 {
 private:
 boost::mutex::scoped_lock  lock_;
 ServerContext* context_;
 typedef std::list<OrthancPluginIncomingHttpRequestFilter>  IncomingHttpRequestFilters;
 typedef std::list<OrthancPluginIncomingHttpRequestFilter2>  IncomingHttpRequestFilters2;
 typedef std::list<OrthancPluginDecodeImageCallback>  DecodeImageCallbacks;
 typedef std::list<OrthancPluginJobsUnserializer>  JobsUnserializers;
 typedef std::list<OrthancPluginRefreshMetricsCallback>  RefreshMetricsCallbacks;
+typedef std::list<StorageCommitmentScp*>  StorageCommitmentScpCallbacks;
 typedef std::map<Property, std::string>  Properties;
 PluginsManager manager_;
 RestCallbacks restCallbacks_;
 JobsUnserializers  jobsUnserializers_;
 _OrthancPluginMoveCallback moveCallbacks_;
 IncomingHttpRequestFilters  incomingHttpRequestFilters_;
 IncomingHttpRequestFilters2 incomingHttpRequestFilters2_;
 RefreshMetricsCallbacks refreshMetricsCallbacks_;
+StorageCommitmentScpCallbacks storageCommitmentScpCallbacks_;
 std::auto_ptr<StorageAreaFactory>  storageArea_;
 boost::recursive_mutex restCallbackMutex_;
 boost::recursive_mutex storedCallbackMutex_;
 boost::recursive_mutex changeCallbackMutex_;
 boost::mutex findCallbackMutex_;
 boost::mutex worklistCallbackMutex_;
 boost::mutex decodeImageCallbackMutex_;
 boost::mutex jobsUnserializersMutex_;
 boost::mutex refreshMetricsMutex_;
+boost::mutex storageCommitmentScpMutex_;
 boost::recursive_mutex invokeServiceMutex_;
 Properties properties_;
 int argc_;
 char** argv_;
 sizeof(int32_t) != sizeof(OrthancPluginInstanceOrigin) ||
 sizeof(int32_t) != sizeof(OrthancPluginJobStepStatus) ||
 sizeof(int32_t) != sizeof(OrthancPluginConstraintType) ||
 sizeof(int32_t) != sizeof(OrthancPluginMetricsType) ||
 sizeof(int32_t) != sizeof(OrthancPluginDicomWebBinaryMode) ||
+sizeof(int32_t) != sizeof(OrthancPluginStorageCommitmentFailureReason) ||
 static_cast<int>(OrthancPluginDicomToJsonFlags_IncludeBinary) != static_cast<int>(DicomToJsonFlags_IncludeBinary) ||
 static_cast<int>(OrthancPluginDicomToJsonFlags_IncludePrivateTags) != static_cast<int>(DicomToJsonFlags_IncludePrivateTags) ||
 static_cast<int>(OrthancPluginDicomToJsonFlags_IncludeUnknownTags) != static_cast<int>(DicomToJsonFlags_IncludeUnknownTags) ||
 static_cast<int>(OrthancPluginDicomToJsonFlags_IncludePixelData) != static_cast<int>(DicomToJsonFlags_IncludePixelData) ||
 static_cast<int>(OrthancPluginDicomToJsonFlags_ConvertBinaryToNull) != static_cast<int>(DicomToJsonFlags_ConvertBinaryToNull) ||
 for (PImpl::ChunkedRestCallbacks::iterator it = pimpl_->chunkedRestCallbacks_.begin();
 it != pimpl_->chunkedRestCallbacks_.end(); ++it)
 {
 delete *it;
 }
+for (PImpl::StorageCommitmentScpCallbacks::iterator
+it = pimpl_->storageCommitmentScpCallbacks_.begin();
+it != pimpl_->storageCommitmentScpCallbacks_.end(); ++it)
+{
+delete *it;
+}
 }
 static void ArgumentsToPlugin(std::vector<const char*>& keys,
 std::vector<const char*>& values,
 boost::mutex::scoped_lock lock(pimpl_->refreshMetricsMutex_);
 LOG(INFO) << "Plugin has registered a callback to refresh its metrics";
 pimpl_->refreshMetricsCallbacks_.push_back(p.callback);
+}
+void OrthancPlugins::RegisterStorageCommitmentScpCallback(const void* parameters)
+{
+const _OrthancPluginRegisterStorageCommitmentScpCallback& p =
+*reinterpret_cast<const _OrthancPluginRegisterStorageCommitmentScpCallback*>(parameters);
+boost::mutex::scoped_lock lock(pimpl_->storageCommitmentScpMutex_);
+LOG(INFO) << "Plugin has registered a storage commitment callback";
+pimpl_->storageCommitmentScpCallbacks_.push_back(new PImpl::StorageCommitmentScp(p));
 }
 void OrthancPlugins::AnswerBuffer(const void* parameters)
 {
 case _OrthancPluginService_RegisterRefreshMetricsCallback:
 RegisterRefreshMetricsCallback(parameters);
 return true;
+case _OrthancPluginService_RegisterStorageCommitmentScpCallback:
+RegisterStorageCommitmentScpCallback(parameters);
+return true;
 case _OrthancPluginService_RegisterStorageArea:
 {
 LOG(INFO) << "Plugin has registered a custom storage area";
 const _OrthancPluginRegisterStorageArea& p =
 *reinterpret_cast<const _OrthancPluginRegisterStorageArea*>(parameters);
 return true;
 }
 }
 }
 }
+IStorageCommitmentFactory::ILookupHandler* OrthancPlugins::CreateStorageCommitment(
+const std::string& jobId,
+const std::string& transactionUid,
+const std::vector<std::string>& sopClassUids,
+const std::vector<std::string>& sopInstanceUids,
+const std::string& remoteAet,
+const std::string& calledAet)
+{
+boost::mutex::scoped_lock lock(pimpl_->storageCommitmentScpMutex_);
+for (PImpl::StorageCommitmentScpCallbacks::iterator
+it = pimpl_->storageCommitmentScpCallbacks_.begin();
+it != pimpl_->storageCommitmentScpCallbacks_.end(); ++it)
+{
+assert(*it != NULL);
+IStorageCommitmentFactory::ILookupHandler* handler = (*it)->CreateStorageCommitment
+(jobId, transactionUid, sopClassUids, sopInstanceUids, remoteAet, calledAet);
+if (handler != NULL)
+{
+return handler;
+}
+}
+return NULL;
+}
 }

Mercurial > hg > orthanc

comparison Plugins/Engine/OrthancPlugins.cpp @ 3662:d8371b4302ff storage-commitment