job_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 <cstdint>
#include <functional>
#include <optional>
#include <string>
#include <string_view>
#include <unordered_map>
#include <vector>
 
namespace kcenon::pacs::client {
 
// =============================================================================
// Job Type
// =============================================================================
 
enum class job_type {
    query,      
    retrieve,   
    store,      
    export_,    
    import_,    
    prefetch,   
    sync        
};
 
[[nodiscard]] constexpr const char* to_string(job_type type) noexcept {
    switch (type) {
        case job_type::query: return "query";
        case job_type::retrieve: return "retrieve";
        case job_type::store: return "store";
        case job_type::export_: return "export";
        case job_type::import_: return "import";
        case job_type::prefetch: return "prefetch";
        case job_type::sync: return "sync";
        default: return "unknown";
    }
}
 
[[nodiscard]] inline job_type job_type_from_string(std::string_view str) noexcept {
    if (str == "query") return job_type::query;
    if (str == "retrieve") return job_type::retrieve;
    if (str == "store") return job_type::store;
    if (str == "export") return job_type::export_;
    if (str == "import") return job_type::import_;
    if (str == "prefetch") return job_type::prefetch;
    if (str == "sync") return job_type::sync;
    return job_type::query;
}
 
// =============================================================================
// Job Status
// =============================================================================
 
enum class job_status {
    pending,    
    queued,     
    running,    
    completed,  
    failed,     
    cancelled,  
    paused      
};
 
[[nodiscard]] constexpr const char* to_string(job_status status) noexcept {
    switch (status) {
        case job_status::pending: return "pending";
        case job_status::queued: return "queued";
        case job_status::running: return "running";
        case job_status::completed: return "completed";
        case job_status::failed: return "failed";
        case job_status::cancelled: return "cancelled";
        case job_status::paused: return "paused";
        default: return "unknown";
    }
}
 
[[nodiscard]] inline job_status job_status_from_string(std::string_view str) noexcept {
    if (str == "pending") return job_status::pending;
    if (str == "queued") return job_status::queued;
    if (str == "running") return job_status::running;
    if (str == "completed") return job_status::completed;
    if (str == "failed") return job_status::failed;
    if (str == "cancelled") return job_status::cancelled;
    if (str == "paused") return job_status::paused;
    return job_status::pending;
}
 
[[nodiscard]] constexpr bool is_terminal_status(job_status status) noexcept {
    return status == job_status::completed ||
           status == job_status::failed ||
           status == job_status::cancelled;
}
 
// =============================================================================
// Job Priority
// =============================================================================
 
enum class job_priority {
    low = 0,     
    normal = 1,  
    high = 2,    
    urgent = 3   
};
 
[[nodiscard]] constexpr const char* to_string(job_priority priority) noexcept {
    switch (priority) {
        case job_priority::low: return "low";
        case job_priority::normal: return "normal";
        case job_priority::high: return "high";
        case job_priority::urgent: return "urgent";
        default: return "unknown";
    }
}
 
[[nodiscard]] inline job_priority job_priority_from_string(std::string_view str) noexcept {
    if (str == "low") return job_priority::low;
    if (str == "normal") return job_priority::normal;
    if (str == "high") return job_priority::high;
    if (str == "urgent") return job_priority::urgent;
    return job_priority::normal;
}
 
[[nodiscard]] inline job_priority job_priority_from_int(int value) noexcept {
    if (value <= 0) return job_priority::low;
    if (value == 1) return job_priority::normal;
    if (value == 2) return job_priority::high;
    if (value >= 3) return job_priority::urgent;
    return job_priority::normal;
}
 
// =============================================================================
// Job Progress
// =============================================================================
 
struct job_progress {
    size_t total_items{0};                
    size_t completed_items{0};            
    size_t failed_items{0};               
    size_t skipped_items{0};              
    size_t bytes_transferred{0};          
 
    float percent_complete{0.0f};         
 
    std::string current_item;             
    std::string current_item_description; 
 
    std::chrono::milliseconds elapsed{0};             
    std::chrono::milliseconds estimated_remaining{0}; 
 
    void calculate_percent() noexcept {
        if (total_items > 0) {
            percent_complete = static_cast<float>(completed_items + failed_items + skipped_items)
                             / static_cast<float>(total_items) * 100.0f;
        }
    }
 
    [[nodiscard]] bool is_complete() const noexcept {
        return total_items > 0 &&
               (completed_items + failed_items + skipped_items) >= total_items;
    }
};
 
// =============================================================================
// Job Record
// =============================================================================
 
struct job_record {
    // =========================================================================
    // Identification
    // =========================================================================
 
    std::string job_id;         
    job_type type;              
    job_status status{job_status::pending};  
    job_priority priority{job_priority::normal};  
 
    // =========================================================================
    // Source/Destination
    // =========================================================================
 
    std::string source_node_id;       
    std::string destination_node_id;  
 
    // =========================================================================
    // Scope (what to process)
    // =========================================================================
 
    std::optional<std::string> patient_id;        
    std::optional<std::string> study_uid;         
    std::optional<std::string> series_uid;        
    std::optional<std::string> sop_instance_uid;  
    std::vector<std::string> instance_uids;       
 
    // =========================================================================
    // Progress
    // =========================================================================
 
    job_progress progress;  
 
    // =========================================================================
    // Timing
    // =========================================================================
 
    std::chrono::system_clock::time_point created_at;     
    std::optional<std::chrono::system_clock::time_point> queued_at;    
    std::optional<std::chrono::system_clock::time_point> started_at;   
    std::optional<std::chrono::system_clock::time_point> completed_at; 
 
    // =========================================================================
    // Error Handling
    // =========================================================================
 
    std::string error_message;   
    std::string error_details;   
    int retry_count{0};          
    int max_retries{3};          
 
    // =========================================================================
    // Metadata
    // =========================================================================
 
    std::string created_by;      
    std::unordered_map<std::string, std::string> metadata;  
 
    // =========================================================================
    // Database Fields
    // =========================================================================
 
    int64_t pk{0};  
 
    // =========================================================================
    // Convenience Methods
    // =========================================================================
 
    [[nodiscard]] bool is_finished() const noexcept {
        return is_terminal_status(status);
    }
 
    [[nodiscard]] bool can_start() const noexcept {
        return status == job_status::pending ||
               status == job_status::queued ||
               status == job_status::paused;
    }
 
    [[nodiscard]] bool can_cancel() const noexcept {
        return !is_terminal_status(status);
    }
 
    [[nodiscard]] bool can_pause() const noexcept {
        return status == job_status::running ||
               status == job_status::queued;
    }
 
    [[nodiscard]] bool can_retry() const noexcept {
        return status == job_status::failed && retry_count < max_retries;
    }
 
    [[nodiscard]] std::chrono::milliseconds duration() const noexcept {
        if (!started_at.has_value()) {
            return std::chrono::milliseconds{0};
        }
        auto end_time = completed_at.value_or(std::chrono::system_clock::now());
        return std::chrono::duration_cast<std::chrono::milliseconds>(
            end_time - started_at.value());
    }
};
 
// =============================================================================
// Callbacks
// =============================================================================
 
using job_progress_callback = std::function<void(
    const std::string& job_id,
    const job_progress& progress)>;
 
using job_completion_callback = std::function<void(
    const std::string& job_id,
    const job_record& record)>;
 
// =============================================================================
// Job Manager Configuration
// =============================================================================
 
struct job_manager_config {
    size_t worker_count{4};                          
    size_t max_queue_size{1000};                     
    std::chrono::seconds job_timeout{3600};          
    bool persist_jobs{true};                         
    bool auto_retry_failed{true};                    
    std::chrono::seconds retry_delay{60};            
    std::string local_ae_title{"PACS_CLIENT"};       
};
 
}  // namespace kcenon::pacs::client