task_scheduler_config.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 <cstdint>
#include <functional>
#include <map>
#include <optional>
#include <set>
#include <string>
#include <variant>
#include <vector>
 
namespace kcenon::pacs::workflow {
 
// =============================================================================
// Schedule Expression Types
// =============================================================================
 
struct interval_schedule {
    std::chrono::seconds interval{3600};  // Default: 1 hour
 
    std::optional<std::chrono::system_clock::time_point> start_at;
};
 
struct cron_schedule {
    std::string minute{"*"};
 
    std::string hour{"*"};
 
    std::string day_of_month{"*"};
 
    std::string month{"*"};
 
    std::string day_of_week{"*"};
 
    [[nodiscard]] static auto every_minutes(int n) -> cron_schedule {
        cron_schedule s;
        s.minute = "*/" + std::to_string(n);
        return s;
    }
 
    [[nodiscard]] static auto every_hours(int n) -> cron_schedule {
        cron_schedule s;
        s.minute = "0";
        s.hour = "*/" + std::to_string(n);
        return s;
    }
 
    [[nodiscard]] static auto daily_at(int hour, int minute = 0) -> cron_schedule {
        cron_schedule s;
        s.minute = std::to_string(minute);
        s.hour = std::to_string(hour);
        return s;
    }
 
    [[nodiscard]] static auto weekly_on(int day_of_week, int hour = 0, int minute = 0)
        -> cron_schedule {
        cron_schedule s;
        s.minute = std::to_string(minute);
        s.hour = std::to_string(hour);
        s.day_of_week = std::to_string(day_of_week);
        return s;
    }
 
    [[nodiscard]] static auto parse(const std::string& expr) -> cron_schedule;
 
    [[nodiscard]] auto to_string() const -> std::string;
 
    [[nodiscard]] auto is_valid() const noexcept -> bool;
};
 
struct one_time_schedule {
    std::chrono::system_clock::time_point execute_at;
};
 
using schedule = std::variant<interval_schedule, cron_schedule, one_time_schedule>;
 
// =============================================================================
// Task Types and States
// =============================================================================
 
enum class task_type {
    cleanup,       
    archive,       
    verification,  
    custom         
};
 
enum class task_state {
    pending,    
    running,    
    completed,  
    failed,     
    cancelled,  
    paused      
};
 
[[nodiscard]] inline auto to_string(task_state state) -> std::string {
    switch (state) {
        case task_state::pending: return "pending";
        case task_state::running: return "running";
        case task_state::completed: return "completed";
        case task_state::failed: return "failed";
        case task_state::cancelled: return "cancelled";
        case task_state::paused: return "paused";
        default: return "unknown";
    }
}
 
[[nodiscard]] inline auto to_string(task_type type) -> std::string {
    switch (type) {
        case task_type::cleanup: return "cleanup";
        case task_type::archive: return "archive";
        case task_type::verification: return "verification";
        case task_type::custom: return "custom";
        default: return "unknown";
    }
}
 
// =============================================================================
// Task Execution Records
// =============================================================================
 
struct task_execution_record {
    std::string execution_id;
 
    std::string task_id;
 
    std::chrono::system_clock::time_point started_at;
 
    std::optional<std::chrono::system_clock::time_point> ended_at;
 
    task_state state{task_state::pending};
 
    std::optional<std::string> error_message;
 
    std::optional<std::string> result_json;
 
    [[nodiscard]] auto duration() const
        -> std::optional<std::chrono::milliseconds> {
        if (ended_at) {
            return std::chrono::duration_cast<std::chrono::milliseconds>(
                *ended_at - started_at);
        }
        return std::nullopt;
    }
};
 
// =============================================================================
// Scheduled Task Definition
// =============================================================================
 
using task_id = std::string;
 
using task_callback = std::function<bool()>;
 
using task_callback_with_result = std::function<std::optional<std::string>()>;
 
struct scheduled_task {
    task_id id;
 
    std::string name;
 
    std::string description;
 
    task_type type{task_type::custom};
 
    schedule task_schedule;
 
    task_state state{task_state::pending};
 
    task_callback_with_result callback;
 
    bool enabled{true};
 
    int priority{0};
 
    std::set<std::string> tags;
 
    std::chrono::seconds timeout{0};
 
    std::size_t max_retries{0};
 
    std::chrono::seconds retry_delay{60};
 
    std::chrono::system_clock::time_point created_at;
 
    std::chrono::system_clock::time_point updated_at;
 
    std::optional<std::chrono::system_clock::time_point> next_run_at;
 
    std::optional<std::chrono::system_clock::time_point> last_run_at;
 
    std::optional<task_execution_record> last_execution;
 
    std::size_t execution_count{0};
 
    std::size_t success_count{0};
 
    std::size_t failure_count{0};
};
 
// =============================================================================
// Cleanup Task Configuration
// =============================================================================
 
struct cleanup_config {
    std::chrono::days default_retention{365};
 
    std::map<std::string, std::chrono::days> modality_retention;
 
    std::set<std::string> exclude_patterns;
 
    bool verify_not_locked{true};
 
    bool dry_run{false};
 
    std::size_t max_deletions_per_cycle{100};
 
    bool database_only{false};
 
    schedule cleanup_schedule{cron_schedule::daily_at(2, 0)};  // 2:00 AM
 
    [[nodiscard]] auto retention_for(const std::string& modality) const
        -> std::chrono::days {
        auto it = modality_retention.find(modality);
        return it != modality_retention.end() ? it->second : default_retention;
    }
};
 
// =============================================================================
// Archive Task Configuration
// =============================================================================
 
enum class archive_destination_type {
    local_path,    
    network_share, 
    cloud_s3,      
    cloud_azure,   
    tape           
};
 
struct archive_config {
    std::chrono::days archive_after{90};
 
    archive_destination_type destination_type{archive_destination_type::local_path};
 
    std::string destination;
 
    std::optional<std::string> credentials_key;
 
    bool verify_after_archive{true};
 
    bool delete_after_archive{false};
 
    bool compress{true};
 
    int compression_level{6};
 
    std::size_t max_archives_per_cycle{50};
 
    schedule archive_schedule{cron_schedule::daily_at(3, 0)};  // 3:00 AM
};
 
// =============================================================================
// Verification Task Configuration
// =============================================================================
 
struct verification_config {
    std::chrono::hours interval{24};
 
    bool check_checksums{true};
 
    bool check_db_consistency{true};
 
    bool check_dicom_structure{false};
 
    bool repair_on_failure{false};
 
    std::size_t max_verifications_per_cycle{1000};
 
    std::string hash_algorithm{"SHA256"};
 
    schedule verification_schedule{cron_schedule::daily_at(4, 0)};  // 4:00 AM
};
 
// =============================================================================
// Task Scheduler Service Configuration
// =============================================================================
 
struct task_scheduler_config {
    bool enabled{true};
 
    bool auto_start{false};
 
    std::size_t max_concurrent_tasks{4};
 
    std::chrono::seconds check_interval{60};
 
    std::string persistence_path;
 
    bool restore_on_startup{true};
 
    std::optional<cleanup_config> cleanup;
 
    std::optional<archive_config> archive;
 
    std::optional<verification_config> verification;
 
    using task_complete_callback =
        std::function<void(const task_id& id,
                          const task_execution_record& record)>;
    task_complete_callback on_task_complete;
 
    using task_error_callback =
        std::function<void(const task_id& id,
                          const std::string& error)>;
    task_error_callback on_task_error;
 
    using cycle_complete_callback =
        std::function<void(std::size_t tasks_executed,
                          std::size_t tasks_succeeded,
                          std::size_t tasks_failed)>;
    cycle_complete_callback on_cycle_complete;
 
    [[nodiscard]] auto is_valid() const noexcept -> bool {
        return enabled && max_concurrent_tasks > 0;
    }
};
 
// =============================================================================
// Task Scheduler Statistics
// =============================================================================
 
struct scheduler_stats {
    std::size_t scheduled_tasks{0};
 
    std::size_t running_tasks{0};
 
    std::size_t total_executions{0};
 
    std::size_t successful_executions{0};
 
    std::size_t failed_executions{0};
 
    std::size_t cancelled_executions{0};
 
    std::chrono::milliseconds avg_execution_time{0};
 
    std::chrono::milliseconds max_execution_time{0};
 
    std::chrono::seconds uptime{0};
 
    std::optional<std::chrono::system_clock::time_point> last_cycle_at;
};
 
}  // namespace kcenon::pacs::workflow