hsm_types.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2021-2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <chrono>
#include <cstddef>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
namespace kcenon::pacs::storage {
 
enum class storage_tier {
    hot,
 
    warm,
 
    cold
};
 
[[nodiscard]] constexpr auto to_string(storage_tier tier) noexcept
    -> std::string_view {
    switch (tier) {
        case storage_tier::hot:
            return "hot";
        case storage_tier::warm:
            return "warm";
        case storage_tier::cold:
            return "cold";
    }
    return "unknown";
}
 
[[nodiscard]] constexpr auto storage_tier_from_string(std::string_view str)
    -> std::optional<storage_tier> {
    if (str == "hot") {
        return storage_tier::hot;
    }
    if (str == "warm") {
        return storage_tier::warm;
    }
    if (str == "cold") {
        return storage_tier::cold;
    }
    return std::nullopt;
}
 
struct tier_policy {
    std::chrono::days hot_to_warm{30};
 
    std::chrono::days warm_to_cold{365};
 
    bool auto_migrate{true};
 
    std::size_t min_migration_size{0};
 
    std::size_t max_instances_per_cycle{100};
 
    std::size_t max_bytes_per_cycle{10ULL * 1024 * 1024 * 1024};
 
    [[nodiscard]] auto operator==(const tier_policy& other) const noexcept
        -> bool = default;
};
 
struct tier_metadata {
    std::string sop_instance_uid;
 
    storage_tier current_tier{storage_tier::hot};
 
    std::chrono::system_clock::time_point stored_at{
        std::chrono::system_clock::now()};
 
    std::optional<std::chrono::system_clock::time_point> last_accessed;
 
    std::size_t size_bytes{0};
 
    std::string study_instance_uid;
 
    std::string series_instance_uid;
 
    [[nodiscard]] auto age() const -> std::chrono::system_clock::duration {
        return std::chrono::system_clock::now() - stored_at;
    }
 
    [[nodiscard]] auto time_since_access() const
        -> std::chrono::system_clock::duration {
        if (last_accessed.has_value()) {
            return std::chrono::system_clock::now() - *last_accessed;
        }
        return age();
    }
 
    [[nodiscard]] auto should_migrate(const tier_policy& policy,
                                       storage_tier target_tier) const -> bool {
        // Can only migrate to a "colder" tier
        if (target_tier <= current_tier) {
            return false;
        }
 
        // Check size threshold
        if (size_bytes < policy.min_migration_size) {
            return false;
        }
 
        auto time_inactive = time_since_access();
 
        // Check if instance has been inactive long enough
        if (current_tier == storage_tier::hot &&
            target_tier == storage_tier::warm) {
            return time_inactive >= policy.hot_to_warm;
        }
 
        if (current_tier == storage_tier::warm &&
            target_tier == storage_tier::cold) {
            return time_inactive >= policy.warm_to_cold;
        }
 
        // Hot directly to cold (must meet both thresholds)
        if (current_tier == storage_tier::hot &&
            target_tier == storage_tier::cold) {
            return time_inactive >= (policy.hot_to_warm + policy.warm_to_cold);
        }
 
        return false;
    }
};
 
struct migration_result {
    std::size_t instances_migrated{0};
 
    std::size_t bytes_migrated{0};
 
    std::chrono::milliseconds duration{0};
 
    std::vector<std::string> failed_uids;
 
    std::size_t instances_skipped{0};
 
    [[nodiscard]] auto is_success() const noexcept -> bool {
        return failed_uids.empty();
    }
 
    [[nodiscard]] auto total_processed() const noexcept -> std::size_t {
        return instances_migrated + failed_uids.size() + instances_skipped;
    }
};
 
struct tier_statistics {
    std::size_t instance_count{0};
 
    std::size_t total_bytes{0};
 
    std::size_t study_count{0};
 
    std::size_t series_count{0};
};
 
struct hsm_statistics {
    tier_statistics hot;
 
    tier_statistics warm;
 
    tier_statistics cold;
 
    [[nodiscard]] auto total_instances() const noexcept -> std::size_t {
        return hot.instance_count + warm.instance_count + cold.instance_count;
    }
 
    [[nodiscard]] auto total_bytes() const noexcept -> std::size_t {
        return hot.total_bytes + warm.total_bytes + cold.total_bytes;
    }
};
 
}  // namespace kcenon::pacs::storage