kcenon::pacs::storage::hsm_storage Class Reference

Hierarchical Storage Management for multi-tier DICOM storage. More...

#include <hsm_storage.h>

Inheritance diagram for kcenon::pacs::storage::hsm_storage:

Collaboration diagram for kcenon::pacs::storage::hsm_storage:

Public Member Functions
	hsm_storage (std::unique_ptr< storage_interface > hot_tier, std::unique_ptr< storage_interface > warm_tier, std::unique_ptr< storage_interface > cold_tier, const hsm_storage_config &config={})
	Construct HSM storage with three tier backends.
	~hsm_storage () override=default
	Destructor.
	hsm_storage (const hsm_storage &)=delete
	Non-copyable (contains mutex and unique_ptr)
hsm_storage &	operator= (const hsm_storage &)=delete
	hsm_storage (hsm_storage &&)=delete
	Non-movable (contains mutex)
hsm_storage &	operator= (hsm_storage &&)=delete
auto	store (const core::dicom_dataset &dataset) -> VoidResult override
	Store a DICOM dataset to the hot tier.
auto	retrieve (std::string_view sop_instance_uid) -> Result< core::dicom_dataset > override
	Retrieve a DICOM dataset by SOP Instance UID.
auto	remove (std::string_view sop_instance_uid) -> VoidResult override
	Remove a DICOM dataset from all tiers.
auto	exists (std::string_view sop_instance_uid) const -> bool override
	Check if a DICOM instance exists in any tier.
auto	find (const core::dicom_dataset &query) -> Result< std::vector< core::dicom_dataset > > override
	Find DICOM datasets matching query criteria across all tiers.
auto	get_statistics () const -> storage_statistics override
	Get combined storage statistics from all tiers.
auto	verify_integrity () -> VoidResult override
	Verify storage integrity across all tiers.
auto	get_tier (std::string_view sop_instance_uid) const -> std::optional< storage_tier >
	Get the current tier of an instance.
auto	get_tier_metadata (std::string_view sop_instance_uid) const -> std::optional< tier_metadata >
	Get tier metadata for an instance.
auto	migrate (std::string_view sop_instance_uid, storage_tier target_tier) -> VoidResult
	Manually migrate an instance to a different tier.
auto	get_migration_candidates (storage_tier from_tier, storage_tier to_tier) const -> std::vector< tier_metadata >
	Get instances eligible for migration.
auto	run_migration_cycle () -> migration_result
	Run a single migration cycle.
auto	get_tier_policy () const -> tier_policy
	Get the current tier policy.
void	set_tier_policy (const tier_policy &policy)
	Set the tier policy.
auto	get_hsm_statistics () const -> hsm_statistics
	Get HSM-specific statistics.
auto	get_tier_storage (storage_tier tier) const -> storage_interface *
	Get the storage backend for a specific tier.
Public Member Functions inherited from kcenon::pacs::storage::storage_interface
virtual	~storage_interface ()=default
	Virtual destructor for proper polymorphic destruction.
virtual auto	store_batch (const std::vector< core::dicom_dataset > &datasets) -> VoidResult
	Store multiple DICOM datasets in a single operation.
virtual auto	retrieve_batch (const std::vector< std::string > &sop_instance_uids) -> Result< std::vector< core::dicom_dataset > >
	Retrieve multiple DICOM datasets by their SOP Instance UIDs.

Private Member Functions
auto	find_tier (std::string_view sop_instance_uid) const -> std::optional< storage_tier >
	Find which tier contains an instance.
auto	get_storage (storage_tier tier) const -> storage_interface *
	Get the storage backend for a tier.
void	update_metadata (std::string_view sop_instance_uid, storage_tier tier, const core::dicom_dataset &dataset)
	Update tier metadata after store/retrieve.
void	update_access_time (std::string_view sop_instance_uid)
	Update last access time for an instance.
void	remove_metadata (std::string_view sop_instance_uid)
	Remove tier metadata.
auto	migrate_instance (std::string_view uid, storage_tier from_tier, storage_tier to_tier) -> VoidResult
	Migrate a single instance between tiers.

Private Attributes
std::unique_ptr< storage_interface >	hot_tier_
	Hot tier storage backend.
std::unique_ptr< storage_interface >	warm_tier_
	Warm tier storage backend (may be nullptr)
std::unique_ptr< storage_interface >	cold_tier_
	Cold tier storage backend (may be nullptr)
hsm_storage_config	config_
	HSM configuration.
std::unordered_map< std::string, tier_metadata >	metadata_index_
	Tier metadata index (SOP Instance UID -> metadata)
std::shared_mutex	mutex_
	Mutex for thread-safe access.

Additional Inherited Members
Protected Member Functions inherited from kcenon::pacs::storage::storage_interface
	storage_interface ()=default
	Protected default constructor for derived classes.
	storage_interface (const storage_interface &)=delete
	Non-copyable.
storage_interface &	operator= (const storage_interface &)=delete
	storage_interface (storage_interface &&)=default
	Movable.
storage_interface &	operator= (storage_interface &&)=default

Detailed Description

Hierarchical Storage Management for multi-tier DICOM storage.

Combines multiple storage backends (hot, warm, cold) into a unified hierarchical storage system. New data is stored in the hot tier by default, and automatically migrates to cooler tiers based on age and access patterns.

The retrieval process is transparent - the caller doesn't need to know which tier contains the data.

Thread Safety:

• All methods are thread-safe
• Concurrent reads are allowed (shared lock)
• Writes and migrations require exclusive lock

Example:

// Create tier backends
auto hot = std::make_unique<file_storage>(hot_config);
auto warm = std::make_unique<file_storage>(warm_config);
auto cold = std::make_unique<s3_storage>(s3_config);
 
// Create HSM storage
hsm_storage_config config;
config.policy.hot_to_warm = std::chrono::days{30};
config.policy.warm_to_cold = std::chrono::days{365};
 
hsm_storage storage{std::move(hot), std::move(warm), std::move(cold), config};
 
// Store (goes to hot tier by default)
storage.store(dataset);
 
// Retrieve (transparently from any tier)
auto result = storage.retrieve("1.2.3.4.5");
 
// Manual migration
storage.migrate("1.2.3.4.5", storage_tier::cold);

Definition at line 87 of file hsm_storage.h.

Constructor & Destructor Documentation

hsm_storage() [1/3]

kcenon::pacs::storage::hsm_storage::hsm_storage	(	std::unique_ptr< storage_interface >	hot_tier,
		std::unique_ptr< storage_interface >	warm_tier,
		std::unique_ptr< storage_interface >	cold_tier,
		const hsm_storage_config &	config = {} )

Construct HSM storage with three tier backends.

Parameters

hot_tier	Storage backend for hot tier (required)
warm_tier	Storage backend for warm tier (optional, can be nullptr)
cold_tier	Storage backend for cold tier (optional, can be nullptr)
config	HSM configuration

Exceptions

std::invalid_argument

if hot_tier is nullptr

Note

At least hot_tier must be provided. If warm_tier is nullptr, migration will skip directly to cold_tier.

Definition at line 40 of file hsm_storage.cpp.

    : hot_tier_(std::move(hot_tier)),
      warm_tier_(std::move(warm_tier)),
      cold_tier_(std::move(cold_tier)),
      config_(config) {
    if (!hot_tier_) {
        throw std::invalid_argument("hot_tier cannot be nullptr");
    }
}

References hot_tier_.

~hsm_storage()

kcenon::pacs::storage::hsm_storage::~hsm_storage ( )

overridedefault

Destructor.

hsm_storage() [2/3]

kcenon::pacs::storage::hsm_storage::hsm_storage ( const hsm_storage & )

delete

Non-copyable (contains mutex and unique_ptr)

hsm_storage() [3/3]

kcenon::pacs::storage::hsm_storage::hsm_storage ( hsm_storage && )

delete

Non-movable (contains mutex)

Member Function Documentation

exists()

auto kcenon::pacs::storage::hsm_storage::exists ( std::string_view sop_instance_uid ) const -> bool

nodiscardoverridevirtual

Check if a DICOM instance exists in any tier.

Parameters

sop_instance_uid

The unique identifier to check

Returns

true if the instance exists in any tier

Implements kcenon::pacs::storage::storage_interface.

Definition at line 137 of file hsm_storage.cpp.

                                                                      {
    std::shared_lock lock(mutex_);
    return metadata_index_.contains(std::string(sop_instance_uid));
}

find()

auto kcenon::pacs::storage::hsm_storage::find ( const core::dicom_dataset & query ) -> Result<std::vector<core::dicom_dataset>>

nodiscardoverridevirtual

Find DICOM datasets matching query criteria across all tiers.

Searches all tiers and combines results.

Parameters

query

The query dataset containing search criteria

Returns

Result containing matching datasets or error information

Implements kcenon::pacs::storage::storage_interface.

Definition at line 142 of file hsm_storage.cpp.

                                            {
    std::vector<core::dicom_dataset> combined_results;
 
    // Search all tiers and combine results
    std::vector<storage_interface*> tiers = {hot_tier_.get(), warm_tier_.get(),
                                              cold_tier_.get()};
 
    for (auto* tier : tiers) {
        if (tier == nullptr) {
            continue;
        }
 
        auto result = tier->find(query);
        if (result.is_ok()) {
            auto& datasets = result.value();
            combined_results.insert(combined_results.end(), datasets.begin(),
                                    datasets.end());
        }
    }
 
    return combined_results;
}

find_tier()

auto kcenon::pacs::storage::hsm_storage::find_tier ( std::string_view sop_instance_uid ) const -> std::optional<storage_tier>

nodiscardprivate

Find which tier contains an instance.

Parameters

sop_instance_uid

The SOP Instance UID

Returns

The tier containing the instance, or nullopt if not found

Definition at line 474 of file hsm_storage.cpp.

                                 {
    std::shared_lock lock(mutex_);
    auto it = metadata_index_.find(std::string(sop_instance_uid));
    if (it != metadata_index_.end()) {
        return it->second.current_tier;
    }
 
    // Fallback: search each tier directly
    lock.unlock();
 
    if (hot_tier_ && hot_tier_->exists(sop_instance_uid)) {
        return storage_tier::hot;
    }
    if (warm_tier_ && warm_tier_->exists(sop_instance_uid)) {
        return storage_tier::warm;
    }
    if (cold_tier_ && cold_tier_->exists(sop_instance_uid)) {
        return storage_tier::cold;
    }
 
    return std::nullopt;
}

References kcenon::pacs::storage::cold, kcenon::pacs::storage::hot, and kcenon::pacs::storage::warm.

get_hsm_statistics()

auto kcenon::pacs::storage::hsm_storage::get_hsm_statistics ( ) const -> hsm_statistics

nodiscard

Get HSM-specific statistics.

Returns

Statistics broken down by tier

Definition at line 411 of file hsm_storage.cpp.

                                                             {
    hsm_statistics stats;
 
    std::shared_lock lock(mutex_);
 
    std::set<std::string> hot_studies, hot_series;
    std::set<std::string> warm_studies, warm_series;
    std::set<std::string> cold_studies, cold_series;
 
    for (const auto& [uid, meta] : metadata_index_) {
        switch (meta.current_tier) {
            case storage_tier::hot:
                stats.hot.instance_count++;
                stats.hot.total_bytes += meta.size_bytes;
                if (!meta.study_instance_uid.empty()) {
                    hot_studies.insert(meta.study_instance_uid);
                }
                if (!meta.series_instance_uid.empty()) {
                    hot_series.insert(meta.series_instance_uid);
                }
                break;
            case storage_tier::warm:
                stats.warm.instance_count++;
                stats.warm.total_bytes += meta.size_bytes;
                if (!meta.study_instance_uid.empty()) {
                    warm_studies.insert(meta.study_instance_uid);
                }
                if (!meta.series_instance_uid.empty()) {
                    warm_series.insert(meta.series_instance_uid);
                }
                break;
            case storage_tier::cold:
                stats.cold.instance_count++;
                stats.cold.total_bytes += meta.size_bytes;
                if (!meta.study_instance_uid.empty()) {
                    cold_studies.insert(meta.study_instance_uid);
                }
                if (!meta.series_instance_uid.empty()) {
                    cold_series.insert(meta.series_instance_uid);
                }
                break;
        }
    }
 
    stats.hot.study_count = hot_studies.size();
    stats.hot.series_count = hot_series.size();
    stats.warm.study_count = warm_studies.size();
    stats.warm.series_count = warm_series.size();
    stats.cold.study_count = cold_studies.size();
    stats.cold.series_count = cold_series.size();
 
    return stats;
}

References kcenon::pacs::storage::hsm_statistics::cold, kcenon::pacs::storage::cold, kcenon::pacs::storage::hsm_statistics::hot, kcenon::pacs::storage::hot, kcenon::pacs::storage::tier_statistics::instance_count, metadata_index_, mutex_, kcenon::pacs::storage::tier_statistics::series_count, kcenon::pacs::storage::tier_statistics::study_count, kcenon::pacs::storage::tier_statistics::total_bytes, uid, kcenon::pacs::storage::hsm_statistics::warm, and kcenon::pacs::storage::warm.

get_migration_candidates()

auto kcenon::pacs::storage::hsm_storage::get_migration_candidates ( storage_tier from_tier, storage_tier to_tier ) const -> std::vector<tier_metadata>

nodiscard

Get instances eligible for migration.

Returns instances that should be migrated based on the tier policy.

Parameters

from_tier	Source tier to check
to_tier	Target tier

Returns

Vector of tier metadata for eligible instances

Definition at line 290 of file hsm_storage.cpp.

                                {
    std::vector<tier_metadata> candidates;
 
    std::shared_lock lock(mutex_);
    for (const auto& [uid, meta] : metadata_index_) {
        if (meta.current_tier == from_tier &&
            meta.should_migrate(config_.policy, to_tier)) {
            candidates.push_back(meta);
        }
    }
 
    // Sort by age (oldest first)
    std::sort(candidates.begin(), candidates.end(),
              [](const tier_metadata& a, const tier_metadata& b) {
                  return a.stored_at < b.stored_at;
              });
 
    return candidates;
}

References uid.

get_statistics()

auto kcenon::pacs::storage::hsm_storage::get_statistics ( ) const -> storage_statistics

nodiscardoverridevirtual

Get combined storage statistics from all tiers.

Returns

Storage statistics aggregated from all tiers

Implements kcenon::pacs::storage::storage_interface.

Definition at line 166 of file hsm_storage.cpp.

                                                             {
    storage_statistics stats;
 
    std::shared_lock lock(mutex_);
 
    // Aggregate from all tiers
    std::vector<storage_interface*> tiers = {hot_tier_.get(), warm_tier_.get(),
                                              cold_tier_.get()};
 
    std::set<std::string> studies;
    std::set<std::string> series;
    std::set<std::string> patients;
 
    for (auto* tier : tiers) {
        if (tier == nullptr) {
            continue;
        }
 
        auto tier_stats = tier->get_statistics();
        stats.total_instances += tier_stats.total_instances;
        stats.total_bytes += tier_stats.total_bytes;
    }
 
    // Count unique studies/series from metadata
    for (const auto& [uid, meta] : metadata_index_) {
        if (!meta.study_instance_uid.empty()) {
            studies.insert(meta.study_instance_uid);
        }
        if (!meta.series_instance_uid.empty()) {
            series.insert(meta.series_instance_uid);
        }
    }
 
    stats.studies_count = studies.size();
    stats.series_count = series.size();
 
    return stats;
}

References cold_tier_, hot_tier_, metadata_index_, mutex_, kcenon::pacs::storage::storage_statistics::series_count, kcenon::pacs::storage::storage_statistics::studies_count, kcenon::pacs::storage::storage_statistics::total_bytes, kcenon::pacs::storage::storage_statistics::total_instances, uid, and warm_tier_.

get_storage()

auto kcenon::pacs::storage::hsm_storage::get_storage ( storage_tier tier ) const -> storage_interface*

nodiscardprivate

Get the storage backend for a tier.

Parameters

tier

The tier

Returns

Pointer to the storage backend

Definition at line 498 of file hsm_storage.cpp.

                                                                           {
    switch (tier) {
        case storage_tier::hot:
            return hot_tier_.get();
        case storage_tier::warm:
            return warm_tier_.get();
        case storage_tier::cold:
            return cold_tier_.get();
    }
    return nullptr;
}

References kcenon::pacs::storage::cold, kcenon::pacs::storage::hot, and kcenon::pacs::storage::warm.

get_tier()

auto kcenon::pacs::storage::hsm_storage::get_tier ( std::string_view sop_instance_uid ) const -> std::optional<storage_tier>

nodiscard

Get the current tier of an instance.

Parameters

sop_instance_uid

The SOP Instance UID

Returns

The storage tier, or nullopt if not found

Definition at line 250 of file hsm_storage.cpp.

                                 {
    std::shared_lock lock(mutex_);
    auto it = metadata_index_.find(std::string(sop_instance_uid));
    if (it == metadata_index_.end()) {
        return std::nullopt;
    }
    return it->second.current_tier;
}

get_tier_metadata()

auto kcenon::pacs::storage::hsm_storage::get_tier_metadata ( std::string_view sop_instance_uid ) const -> std::optional<tier_metadata>

nodiscard

Get tier metadata for an instance.

Parameters

sop_instance_uid

The SOP Instance UID

Returns

Tier metadata, or nullopt if not found

Definition at line 260 of file hsm_storage.cpp.

                                  {
    std::shared_lock lock(mutex_);
    auto it = metadata_index_.find(std::string(sop_instance_uid));
    if (it == metadata_index_.end()) {
        return std::nullopt;
    }
    return it->second;
}

get_tier_policy()

auto kcenon::pacs::storage::hsm_storage::get_tier_policy ( ) const -> tier_policy

nodiscard

Get the current tier policy.

Returns

The current tier policy

Definition at line 401 of file hsm_storage.cpp.

                                                       {
    std::shared_lock lock(mutex_);
    return config_.policy;
}

References config_, mutex_, and kcenon::pacs::storage::hsm_storage_config::policy.

get_tier_storage()

auto kcenon::pacs::storage::hsm_storage::get_tier_storage ( storage_tier tier ) const -> storage_interface*

nodiscard

Get the storage backend for a specific tier.

Parameters

tier	The tier to get

Returns

Pointer to the storage backend, or nullptr if tier not configured

Definition at line 465 of file hsm_storage.cpp.

                          {
    return get_storage(tier);
}

migrate()

auto kcenon::pacs::storage::hsm_storage::migrate ( std::string_view sop_instance_uid, storage_tier target_tier ) -> VoidResult

nodiscard

Manually migrate an instance to a different tier.

Parameters

sop_instance_uid	The SOP Instance UID to migrate
target_tier	The target tier

Returns

VoidResult Success or error information

Note

Migration to a "hotter" tier (e.g., cold to hot) is allowed for restoring frequently accessed archived data.

Definition at line 270 of file hsm_storage.cpp.

                                                                  {
    // Find current tier
    auto current_tier_opt = find_tier(sop_instance_uid);
    if (!current_tier_opt.has_value()) {
        return make_error<std::monostate>(
            kInstanceNotFound,
            "Instance not found: " + std::string(sop_instance_uid),
            "hsm_storage");
    }
 
    auto current_tier = *current_tier_opt;
    if (current_tier == target_tier) {
        // Already in target tier
        return ok();
    }
 
    return migrate_instance(sop_instance_uid, current_tier, target_tier);
}

migrate_instance()

auto kcenon::pacs::storage::hsm_storage::migrate_instance ( std::string_view uid, storage_tier from_tier, storage_tier to_tier ) -> VoidResult

nodiscardprivate

Migrate a single instance between tiers.

Parameters

uid	The SOP Instance UID
from_tier	Source tier
to_tier	Target tier

Returns

VoidResult Success or error information

Definition at line 542 of file hsm_storage.cpp.

                                                                        {
    auto* source = get_storage(from_tier);
    auto* target = get_storage(to_tier);
 
    if (source == nullptr) {
        return make_error<std::monostate>(
            kTierNotAvailable,
            "Source tier not available: " + std::string(to_string(from_tier)),
            "hsm_storage");
    }
    if (target == nullptr) {
        return make_error<std::monostate>(
            kTierNotAvailable,
            "Target tier not available: " + std::string(to_string(to_tier)),
            "hsm_storage");
    }
 
    // Retrieve from source
    auto retrieve_result = source->retrieve(uid);
    if (!retrieve_result.is_ok()) {
        return make_error<std::monostate>(
            kMigrationFailed,
            "Failed to retrieve from source: " +
                std::string(retrieve_result.error().message),
            "hsm_storage");
    }
 
    auto& dataset = retrieve_result.value();
 
    // Store to target
    auto store_result = target->store(dataset);
    if (!store_result.is_ok()) {
        return make_error<std::monostate>(
            kMigrationFailed,
            "Failed to store to target: " +
                std::string(store_result.error().message),
            "hsm_storage");
    }
 
    // Verify if configured
    if (config_.verify_after_migration) {
        if (!target->exists(uid)) {
            return make_error<std::monostate>(
                kMigrationFailed,
                "Verification failed: instance not found in target tier",
                "hsm_storage");
        }
    }
 
    // Remove from source if configured
    if (config_.delete_after_migration) {
        auto remove_result = source->remove(uid);
        // Ignore remove failure - the instance is already in target tier
        (void)remove_result;
    }
 
    // Update metadata
    {
        std::unique_lock lock(mutex_);
        auto it = metadata_index_.find(std::string(uid));
        if (it != metadata_index_.end()) {
            it->second.current_tier = to_tier;
        }
    }
 
    return ok();
}

References kcenon::pacs::storage::to_string(), and uid.

Here is the call graph for this function:

operator=() [1/2]

hsm_storage & kcenon::pacs::storage::hsm_storage::operator= ( const hsm_storage & )

delete

operator=() [2/2]

hsm_storage & kcenon::pacs::storage::hsm_storage::operator= ( hsm_storage && )

delete

remove()

auto kcenon::pacs::storage::hsm_storage::remove ( std::string_view sop_instance_uid ) -> VoidResult

nodiscardoverridevirtual

Remove a DICOM dataset from all tiers.

Removes the instance from whichever tier contains it.

Parameters

sop_instance_uid

The unique identifier for the instance to remove

Returns

VoidResult Success or error information

Implements kcenon::pacs::storage::storage_interface.

Definition at line 110 of file hsm_storage.cpp.

                                                                      {
    // Find which tier contains the instance
    auto tier = find_tier(sop_instance_uid);
    if (!tier.has_value()) {
        // Not found is not an error for remove
        return ok();
    }
 
    // Remove from the tier
    auto* storage = get_storage(*tier);
    if (storage == nullptr) {
        return make_error<std::monostate>(
            kTierNotAvailable, "Tier storage not available", "hsm_storage");
    }
 
    auto result = storage->remove(sop_instance_uid);
    if (!result.is_ok()) {
        return result;
    }
 
    // Remove metadata
    std::unique_lock lock(mutex_);
    remove_metadata(sop_instance_uid);
 
    return ok();
}

remove_metadata()

void kcenon::pacs::storage::hsm_storage::remove_metadata ( std::string_view sop_instance_uid )

private

Remove tier metadata.

Parameters

sop_instance_uid

The SOP Instance UID

Definition at line 538 of file hsm_storage.cpp.

                                                                 {
    metadata_index_.erase(std::string(sop_instance_uid));
}

References metadata_index_.

retrieve()

auto kcenon::pacs::storage::hsm_storage::retrieve ( std::string_view sop_instance_uid ) -> Result<core::dicom_dataset>

nodiscardoverridevirtual

Retrieve a DICOM dataset by SOP Instance UID.

Searches all tiers for the instance, starting from hot tier. If track_access_time is enabled, updates the last access timestamp.

Parameters

sop_instance_uid

The unique identifier for the instance

Returns

Result containing the dataset or error information

Implements kcenon::pacs::storage::storage_interface.

Definition at line 78 of file hsm_storage.cpp.

                                 {
    // Find which tier contains the instance
    auto tier = find_tier(sop_instance_uid);
    if (!tier.has_value()) {
        return make_error<core::dicom_dataset>(
            kInstanceNotFound,
            "Instance not found: " + std::string(sop_instance_uid),
            "hsm_storage");
    }
 
    // Retrieve from the tier
    auto* storage = get_storage(*tier);
    if (storage == nullptr) {
        return make_error<core::dicom_dataset>(
            kTierNotAvailable, "Tier storage not available", "hsm_storage");
    }
 
    auto result = storage->retrieve(sop_instance_uid);
    if (!result.is_ok()) {
        return result;
    }
 
    // Update access time if tracking is enabled
    if (config_.track_access_time) {
        std::unique_lock lock(mutex_);
        update_access_time(sop_instance_uid);
    }
 
    return result;
}

run_migration_cycle()

auto kcenon::pacs::storage::hsm_storage::run_migration_cycle ( ) -> migration_result

nodiscard

Run a single migration cycle.

Migrates eligible instances according to the tier policy.

Returns

Migration result with statistics

Definition at line 312 of file hsm_storage.cpp.

                                                          {
    migration_result result;
    auto start_time = std::chrono::steady_clock::now();
 
    // Hot to warm migration
    if (warm_tier_) {
        auto candidates =
            get_migration_candidates(storage_tier::hot, storage_tier::warm);
 
        for (const auto& meta : candidates) {
            if (result.instances_migrated >=
                config_.policy.max_instances_per_cycle) {
                break;
            }
            if (result.bytes_migrated >= config_.policy.max_bytes_per_cycle) {
                break;
            }
 
            auto migrate_result = migrate_instance(
                meta.sop_instance_uid, storage_tier::hot, storage_tier::warm);
 
            if (migrate_result.is_ok()) {
                result.instances_migrated++;
                result.bytes_migrated += meta.size_bytes;
            } else {
                result.failed_uids.push_back(meta.sop_instance_uid);
            }
        }
    }
 
    // Warm to cold migration
    if (cold_tier_) {
        auto candidates =
            get_migration_candidates(storage_tier::warm, storage_tier::cold);
 
        for (const auto& meta : candidates) {
            if (result.instances_migrated >=
                config_.policy.max_instances_per_cycle) {
                break;
            }
            if (result.bytes_migrated >= config_.policy.max_bytes_per_cycle) {
                break;
            }
 
            auto migrate_result = migrate_instance(
                meta.sop_instance_uid, storage_tier::warm, storage_tier::cold);
 
            if (migrate_result.is_ok()) {
                result.instances_migrated++;
                result.bytes_migrated += meta.size_bytes;
            } else {
                result.failed_uids.push_back(meta.sop_instance_uid);
            }
        }
    }
 
    // Also check hot to cold (if warm tier is skipped)
    if (!warm_tier_ && cold_tier_) {
        auto candidates =
            get_migration_candidates(storage_tier::hot, storage_tier::cold);
 
        for (const auto& meta : candidates) {
            if (result.instances_migrated >=
                config_.policy.max_instances_per_cycle) {
                break;
            }
            if (result.bytes_migrated >= config_.policy.max_bytes_per_cycle) {
                break;
            }
 
            auto migrate_result = migrate_instance(
                meta.sop_instance_uid, storage_tier::hot, storage_tier::cold);
 
            if (migrate_result.is_ok()) {
                result.instances_migrated++;
                result.bytes_migrated += meta.size_bytes;
            } else {
                result.failed_uids.push_back(meta.sop_instance_uid);
            }
        }
    }
 
    auto end_time = std::chrono::steady_clock::now();
    result.duration = std::chrono::duration_cast<std::chrono::milliseconds>(
        end_time - start_time);
 
    return result;
}

References kcenon::pacs::storage::migration_result::bytes_migrated, kcenon::pacs::storage::cold, kcenon::pacs::storage::migration_result::duration, kcenon::pacs::storage::migration_result::failed_uids, kcenon::pacs::storage::hot, kcenon::pacs::storage::migration_result::instances_migrated, and kcenon::pacs::storage::warm.

set_tier_policy()

void kcenon::pacs::storage::hsm_storage::set_tier_policy

(

const tier_policy &

policy

)

Set the tier policy.

Parameters

policy

The new tier policy

Definition at line 406 of file hsm_storage.cpp.

                                                           {
    std::unique_lock lock(mutex_);
    config_.policy = policy;
}

References config_, mutex_, and kcenon::pacs::storage::hsm_storage_config::policy.

store()

auto kcenon::pacs::storage::hsm_storage::store ( const core::dicom_dataset & dataset ) -> VoidResult

nodiscardoverridevirtual

Store a DICOM dataset to the hot tier.

New data is always stored in the hot tier. Migration to cooler tiers happens based on the configured tier policy.

Parameters

dataset

The DICOM dataset to store

Returns

VoidResult Success or error information

Implements kcenon::pacs::storage::storage_interface.

Definition at line 57 of file hsm_storage.cpp.

                                                                      {
    // Extract SOP Instance UID for metadata tracking
    auto sop_uid = dataset.get_string(core::tags::sop_instance_uid);
    if (sop_uid.empty()) {
        return make_error<std::monostate>(
            kInvalidConfiguration, "Missing SOP Instance UID", "hsm_storage");
    }
 
    // Store in hot tier
    auto result = hot_tier_->store(dataset);
    if (!result.is_ok()) {
        return result;
    }
 
    // Update metadata
    std::unique_lock lock(mutex_);
    update_metadata(sop_uid, storage_tier::hot, dataset);
 
    return ok();
}

References kcenon::pacs::storage::hot, and kcenon::pacs::core::tags::sop_instance_uid.

update_access_time()

void kcenon::pacs::storage::hsm_storage::update_access_time ( std::string_view sop_instance_uid )

private

Update last access time for an instance.

Parameters

sop_instance_uid

The SOP Instance UID

Definition at line 531 of file hsm_storage.cpp.

                                                                    {
    auto it = metadata_index_.find(std::string(sop_instance_uid));
    if (it != metadata_index_.end()) {
        it->second.last_accessed = std::chrono::system_clock::now();
    }
}

References metadata_index_.

update_metadata()

void kcenon::pacs::storage::hsm_storage::update_metadata ( std::string_view sop_instance_uid, storage_tier tier, const core::dicom_dataset & dataset )

private

Update tier metadata after store/retrieve.

Parameters

sop_instance_uid	The SOP Instance UID
tier	The tier where the instance is stored
dataset	The dataset (for extracting metadata)

Definition at line 510 of file hsm_storage.cpp.

                                                                     {
    std::string uid(sop_instance_uid);
 
    tier_metadata meta;
    meta.sop_instance_uid = uid;
    meta.current_tier = tier;
    meta.stored_at = std::chrono::system_clock::now();
    meta.study_instance_uid =
        dataset.get_string(core::tags::study_instance_uid);
    meta.series_instance_uid =
        dataset.get_string(core::tags::series_instance_uid);
 
    // Try to get size from dataset (if available)
    // For now, estimate based on pixel data if present
    meta.size_bytes = 0;  // Will be updated by storage backend
 
    metadata_index_[uid] = std::move(meta);
}

References kcenon::pacs::storage::tier_metadata::current_tier, kcenon::pacs::core::dicom_dataset::get_string(), metadata_index_, kcenon::pacs::core::tags::series_instance_uid, kcenon::pacs::storage::tier_metadata::series_instance_uid, kcenon::pacs::storage::tier_metadata::size_bytes, kcenon::pacs::storage::tier_metadata::sop_instance_uid, kcenon::pacs::storage::tier_metadata::stored_at, kcenon::pacs::core::tags::study_instance_uid, kcenon::pacs::storage::tier_metadata::study_instance_uid, and uid.

Here is the call graph for this function:

verify_integrity()

auto kcenon::pacs::storage::hsm_storage::verify_integrity ( ) -> VoidResult

nodiscardoverridevirtual

Verify storage integrity across all tiers.

Verifies each tier's integrity and checks tier metadata consistency.

Returns

VoidResult Success if integrity is verified, error otherwise

Implements kcenon::pacs::storage::storage_interface.

Definition at line 205 of file hsm_storage.cpp.

                                                 {
    // Verify each tier
    std::vector<std::pair<storage_tier, storage_interface*>> tiers = {
        {storage_tier::hot, hot_tier_.get()},
        {storage_tier::warm, warm_tier_.get()},
        {storage_tier::cold, cold_tier_.get()}};
 
    for (const auto& [tier, storage] : tiers) {
        if (storage == nullptr) {
            continue;
        }
 
        auto result = storage->verify_integrity();
        if (!result.is_ok()) {
            return make_error<std::monostate>(
                kIntegrityError,
                "Integrity check failed for " + std::string(to_string(tier)) +
                    " tier: " + std::string(result.error().message),
                "hsm_storage");
        }
    }
 
    // Verify metadata consistency
    std::shared_lock lock(mutex_);
    for (const auto& [uid, meta] : metadata_index_) {
        auto* storage = get_storage(meta.current_tier);
        if (storage == nullptr) {
            continue;
        }
 
        if (!storage->exists(uid)) {
            return make_error<std::monostate>(
                kIntegrityError,
                "Metadata references non-existent instance: " + uid,
                "hsm_storage");
        }
    }
 
    return ok();
}

References kcenon::pacs::storage::cold, kcenon::pacs::storage::hot, kcenon::pacs::storage::to_string(), uid, and kcenon::pacs::storage::warm.

Here is the call graph for this function:

Member Data Documentation

cold_tier_

std::unique_ptr<storage_interface> kcenon::pacs::storage::hsm_storage::cold_tier_

private

Cold tier storage backend (may be nullptr)

Definition at line 350 of file hsm_storage.h.

Referenced by get_statistics().

config_

hsm_storage_config kcenon::pacs::storage::hsm_storage::config_

private

HSM configuration.

Definition at line 353 of file hsm_storage.h.

Referenced by get_tier_policy(), and set_tier_policy().

hot_tier_

std::unique_ptr<storage_interface> kcenon::pacs::storage::hsm_storage::hot_tier_

private

Hot tier storage backend.

Definition at line 344 of file hsm_storage.h.

Referenced by get_statistics(), and hsm_storage().

metadata_index_

std::unordered_map<std::string, tier_metadata> kcenon::pacs::storage::hsm_storage::metadata_index_

private

Tier metadata index (SOP Instance UID -> metadata)

Definition at line 356 of file hsm_storage.h.

Referenced by get_hsm_statistics(), get_statistics(), remove_metadata(), update_access_time(), and update_metadata().

mutex_

std::shared_mutex kcenon::pacs::storage::hsm_storage::mutex_

mutableprivate

Mutex for thread-safe access.

Definition at line 359 of file hsm_storage.h.

Referenced by get_hsm_statistics(), get_statistics(), get_tier_policy(), and set_tier_policy().

warm_tier_

std::unique_ptr<storage_interface> kcenon::pacs::storage::hsm_storage::warm_tier_

private

Warm tier storage backend (may be nullptr)

Definition at line 347 of file hsm_storage.h.

Referenced by get_statistics().

---

The documentation for this class was generated from the following files:

• include/kcenon/pacs/storage/hsm_storage.h
• src/storage/hsm_storage.cpp