orthanc: OrthancServer/Sources/ServerIndex.cpp comparison

comparison OrthancServer/Sources/ServerIndex.cpp @ 5603:b2a97dfd719f

monitoring of stable resources now also considers the resource type

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Wed, 08 May 2024 10:29:35 +0200
parents	4dd50c4b985a
children	f7adfb22e20e

comparison

equal deleted inserted replaced

-:3487684fd331
+:b2a97dfd719f
 {
 return false;
 }
 };
-virtual void MarkAsUnstable(int64_t id,
+virtual void MarkAsUnstable(ResourceType type,
-Orthanc::ResourceType type,
+int64_t id,
 const std::string& publicId) ORTHANC_OVERRIDE
 {
-context_.GetIndex().MarkAsUnstable(id, type, publicId);
+context_.GetIndex().MarkAsUnstable(type, id, publicId);
 }
-virtual bool IsUnstableResource(int64_t id) ORTHANC_OVERRIDE
+virtual bool IsUnstableResource(ResourceType type,
-{
+int64_t id) ORTHANC_OVERRIDE
-return context_.GetIndex().IsUnstableResource(id);
+{
+return context_.GetIndex().IsUnstableResource(type, id);
 }
 virtual void Commit() ORTHANC_OVERRIDE
 {
 // We can remove the files once the SQLite transaction has
 class ServerIndex::UnstableResourcePayload
 {
 private:
-ResourceType type_;
 std::string publicId_;
 boost::posix_time::ptime time_;
 public:
-UnstableResourcePayload() : type_(ResourceType_Instance)
+UnstableResourcePayload()
 {
 }
-UnstableResourcePayload(Orthanc::ResourceType type,
+explicit UnstableResourcePayload(const std::string& publicId) :
-const std::string& publicId) :
-type_(type),
 publicId_(publicId),
 time_(boost::posix_time::second_clock::local_time())
 {
 }
 unsigned int GetAge() const
 {
 return (boost::posix_time::second_clock::local_time() - time_).total_seconds();
-}
-ResourceType GetResourceType() const
-{
-return type_;
 }
 const std::string& GetPublicId() const
 {
 return publicId_;
 LOG(INFO) << "Stopping the database flushing thread";
 }
-bool ServerIndex::IsUnstableResource(int64_t id)
+bool ServerIndex::IsUnstableResource(ResourceType type,
+int64_t id)
 {
 boost::mutex::scoped_lock lock(monitoringMutex_);
-return unstableResources_.Contains(id);
+return unstableResources_.Contains(std::make_pair(type, id));
 }
 ServerIndex::ServerIndex(ServerContext& context,
 IDatabaseWrapper& db,
 // Check for stable resources each few seconds
 boost::this_thread::sleep(boost::posix_time::milliseconds(threadSleepGranularityMilliseconds));
 for (;;)
 {
-UnstableResourcePayload stableResource;
+UnstableResourcePayload stablePayload;
+ResourceType stableLevel;
 int64_t stableId;
 {
 boost::mutex::scoped_lock lock(that->monitoringMutex_);
 if (!that->unstableResources_.IsEmpty() &&
 that->unstableResources_.GetOldestPayload().GetAge() > static_cast<unsigned int>(stableAge))
 {
 // This DICOM resource has not received any new instance for
 // some time. It can be considered as stable.
-stableId = that->unstableResources_.RemoveOldest(stableResource);
+std::pair<ResourceType, int64_t> stableResource = that->unstableResources_.RemoveOldest(stablePayload);
-//LOG(TRACE) << "Stable resource: " << EnumerationToString(stableResource.GetResourceType()) << " " << stableId;
+stableLevel = stableResource.first;
+stableId = stableResource.second;
+//LOG(TRACE) << "Stable resource: " << EnumerationToString(stablePayload.GetResourceType()) << " " << stableId;
 }
 else
 {
 // No more stable DICOM resource, leave the internal loop
 break;
 * "monitoringMutex_", as this could lead to deadlocks in
 * other threads (typically, if "Store()" is being running in
 * another thread, which leads to calls to "MarkAsUnstable()",
 * which leads to two lockings of "monitoringMutex_").
 **/
-switch (stableResource.GetResourceType())
+switch (stableLevel)
 {
 case ResourceType_Patient:
-that->LogChange(stableId, ChangeType_StablePatient, stableResource.GetPublicId(), ResourceType_Patient);
+that->LogChange(stableId, ChangeType_StablePatient, stablePayload.GetPublicId(), ResourceType_Patient);
 break;
 case ResourceType_Study:
-that->LogChange(stableId, ChangeType_StableStudy, stableResource.GetPublicId(), ResourceType_Study);
+that->LogChange(stableId, ChangeType_StableStudy, stablePayload.GetPublicId(), ResourceType_Study);
 break;
 case ResourceType_Series:
-that->LogChange(stableId, ChangeType_StableSeries, stableResource.GetPublicId(), ResourceType_Series);
+that->LogChange(stableId, ChangeType_StableSeries, stablePayload.GetPublicId(), ResourceType_Series);
 break;
 default:
 throw OrthancException(ErrorCode_InternalError);
 }
 LOG(INFO) << "Closing the monitor thread for stable resources";
 }
-void ServerIndex::MarkAsUnstable(int64_t id,
+void ServerIndex::MarkAsUnstable(ResourceType type,
-Orthanc::ResourceType type,
+int64_t id,
 const std::string& publicId)
 {
-assert(type == Orthanc::ResourceType_Patient ||
+assert(type == ResourceType_Patient ||
-type == Orthanc::ResourceType_Study ||
+type == ResourceType_Study ||
-type == Orthanc::ResourceType_Series);
+type == ResourceType_Series);
 {
 boost::mutex::scoped_lock lock(monitoringMutex_);
-UnstableResourcePayload payload(type, publicId);
+UnstableResourcePayload payload(publicId);
-unstableResources_.AddOrMakeMostRecent(id, payload);
+unstableResources_.AddOrMakeMostRecent(std::make_pair(type, id), payload);
 //LOG(INFO) << "Unstable resource: " << EnumerationToString(type) << " " << id;
 }
 }

Mercurial > hg > orthanc

comparison OrthancServer/Sources/ServerIndex.cpp @ 5603:b2a97dfd719f