dicom_server.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.
 
#ifndef PACS_NETWORK_DICOM_SERVER_HPP
#define PACS_NETWORK_DICOM_SERVER_HPP
 
#include "kcenon/pacs/network/association.h"
#include "kcenon/pacs/network/server_config.h"
#include "kcenon/pacs/network/detail/accept_worker.h"
#include "kcenon/pacs/services/scp_service.h"
 
#include <kcenon/thread/core/cancellation_token.h>
 
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <functional>
#include <memory>
#include <mutex>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace kcenon::pacs::integration {
class thread_pool_interface;
}  // namespace kcenon::pacs::integration
 
namespace kcenon::pacs::network {
 
// =============================================================================
// Forward Declarations
// =============================================================================
 
class association_pool;
 
// =============================================================================
// DICOM Server Class
// =============================================================================
 
class dicom_server {
public:
    // =========================================================================
    // Type Aliases
    // =========================================================================
 
    using clock = std::chrono::steady_clock;
    using duration = std::chrono::milliseconds;
    using time_point = clock::time_point;
 
    using association_callback = std::function<void(const association&)>;
 
    using error_callback = std::function<void(const std::string&)>;
 
    // =========================================================================
    // Construction / Destruction
    // =========================================================================
 
    explicit dicom_server(const server_config& config);
 
    dicom_server(
        const server_config& config,
        std::shared_ptr<integration::thread_pool_interface> thread_pool);
 
    ~dicom_server();
 
    // Non-copyable, non-movable (owns network resources)
    dicom_server(const dicom_server&) = delete;
    dicom_server& operator=(const dicom_server&) = delete;
    dicom_server(dicom_server&&) = delete;
    dicom_server& operator=(dicom_server&&) = delete;
 
    // =========================================================================
    // Service Registration
    // =========================================================================
 
    void register_service(services::scp_service_ptr service);
 
    [[nodiscard]] std::vector<std::string> supported_sop_classes() const;
 
    // =========================================================================
    // Lifecycle Management
    // =========================================================================
 
    [[nodiscard]] Result<std::monostate> start();
 
    void stop(duration timeout = std::chrono::seconds{30});
 
    void wait_for_shutdown();
 
    // =========================================================================
    // Status Queries
    // =========================================================================
 
    [[nodiscard]] bool is_running() const noexcept;
 
    [[nodiscard]] size_t active_associations() const noexcept;
 
    [[nodiscard]] server_statistics get_statistics() const;
 
    [[nodiscard]] const server_config& config() const noexcept;
 
    // =========================================================================
    // Callbacks
    // =========================================================================
 
    void on_association_established(association_callback callback);
 
    void on_association_released(association_callback callback);
 
    void on_error(error_callback callback);
 
    static dicom_server* get_server_on_port(uint16_t port);
 
    Result<associate_ac> simulate_association_request(const associate_rq& rq, association* client_peer);
 
private:
    // =========================================================================
    // Private Implementation
    // =========================================================================
 
    struct association_info {
        uint64_t id;
        association assoc;
        time_point connected_at;
        time_point last_activity;
        std::string remote_address;
        bool processing{false};
        kcenon::thread::cancellation_token cancel_token;
    };
 
    // =========================================================================
    // Private Methods
    // =========================================================================
 
    void handle_association(uint64_t session_id, association assoc);
 
    void message_loop(association_info& info);
 
    Result<std::monostate> dispatch_to_service(
        association& assoc,
        uint8_t context_id,
        const dimse::dimse_message& msg);
 
    [[nodiscard]] bool validate_calling_ae(const std::string& calling_ae) const;
 
    [[nodiscard]] bool validate_called_ae(const std::string& called_ae) const;
 
    [[nodiscard]] services::scp_service* find_service(
        const std::string& sop_class_uid) const;
 
    void add_association(association_info info);
 
    void remove_association(uint64_t id);
 
    void touch_association(uint64_t id);
 
    void check_idle_timeouts();
 
    [[nodiscard]] uint64_t next_association_id();
 
    void report_error(const std::string& error);
 
    // =========================================================================
    // Member Variables
    // =========================================================================
 
    std::shared_ptr<integration::thread_pool_interface> thread_pool_;
 
    server_config config_;
 
    std::vector<services::scp_service_ptr> services_;
 
    std::unordered_map<std::string, services::scp_service*> sop_class_to_service_;
 
    std::unordered_map<uint64_t, std::unique_ptr<association_info>> associations_;
 
    mutable server_statistics stats_;
 
    std::atomic<uint64_t> association_id_counter_{0};
 
    std::atomic<bool> running_{false};
 
    std::unique_ptr<detail::accept_worker> accept_worker_;
 
    mutable std::mutex associations_mutex_;
 
    mutable std::mutex stats_mutex_;
 
    mutable std::mutex services_mutex_;
 
    std::condition_variable shutdown_cv_;
 
    std::mutex shutdown_mutex_;
 
    association_callback on_established_cb_;
 
    association_callback on_released_cb_;
 
    error_callback on_error_cb_;
 
    std::mutex callback_mutex_;
};
 
}  // namespace kcenon::pacs::network
 
#endif  // PACS_NETWORK_DICOM_SERVER_HPP