#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

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.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/hsm_storage.h.

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.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/hsm_storage.h.

◆ 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.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/hsm_storage.h.

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.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/hsm_storage.h.

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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/hsm_storage.h.

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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/hsm_storage.h.

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::cold, kcenon::pacs::storage::hot, metadata_index_, mutex_, uid, 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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/hsm_storage.h.

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.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/hsm_storage.h.

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_, 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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/hsm_storage.h.

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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/hsm_storage.h.

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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/hsm_storage.h.

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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/hsm_storage.h.

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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/hsm_storage.h.

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.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/hsm_storage.h.

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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/hsm_storage.h.

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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/hsm_storage.h.

◆ 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.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/hsm_storage.h.

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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/hsm_storage.h.

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.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/hsm_storage.h.

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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/hsm_storage.h.

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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/hsm_storage.h.

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.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/hsm_storage.h.

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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/hsm_storage.h.

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)

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/hsm_storage.h.

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.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/hsm_storage.h.

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();
}