#include <dicom_server.h>

Collaboration diagram for kcenon::pacs::network::dicom_server:

Classes
struct	association_info
	Internal association info for tracking. More...

Public Types
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&)>
	Callback type for association events.

using	error_callback = std::function<void(const std::string&)>
	Callback type for error events.

Public Member Functions
	dicom_server (const server_config &config)
	Construct server with configuration.

	dicom_server (const server_config &config, std::shared_ptr< integration::thread_pool_interface > thread_pool)
	Construct server with configuration and injected thread pool.

	~dicom_server ()
	Destructor (stops server if running)

	dicom_server (const dicom_server &)=delete

dicom_server &	operator= (const dicom_server &)=delete

	dicom_server (dicom_server &&)=delete

dicom_server &	operator= (dicom_server &&)=delete

void	register_service (services::scp_service_ptr service)
	Register an SCP service.

std::vector< std::string >	supported_sop_classes () const
	Get list of supported SOP Class UIDs.

Result< std::monostate >	start ()
	Start the server.

void	stop (duration timeout=std::chrono::seconds{30})
	Stop the server gracefully.

void	wait_for_shutdown ()
	Wait for server shutdown.

bool	is_running () const noexcept
	Check if server is running.

size_t	active_associations () const noexcept
	Get number of active associations.

server_statistics	get_statistics () const
	Get server statistics.

const server_config &	config () const noexcept
	Get server configuration.

void	on_association_established (association_callback callback)
	Set callback for association established events.

void	on_association_released (association_callback callback)
	Set callback for association released events.

void	on_error (error_callback callback)
	Set callback for error events.

Result< associate_ac >	simulate_association_request (const associate_rq &rq, association *client_peer)
	Simulate an incoming association request (for in-memory testing).

Static Public Member Functions
static dicom_server *	get_server_on_port (uint16_t port)
	Get server instance listening on port (for in-memory testing).

Private Member Functions
void	handle_association (uint64_t session_id, association assoc)
	Handle a single association (runs in worker thread)

void	message_loop (association_info &info)
	Process incoming DIMSE messages.

Result< std::monostate >	dispatch_to_service (association &assoc, uint8_t context_id, const dimse::dimse_message &msg)
	Dispatch message to appropriate service.

bool	validate_calling_ae (const std::string &calling_ae) const
	Validate calling AE title.

bool	validate_called_ae (const std::string &called_ae) const
	Validate called AE title.

services::scp_service *	find_service (const std::string &sop_class_uid) const
	Get service for SOP Class.

void	add_association (association_info info)
	Add association to pool.

void	remove_association (uint64_t id)
	Remove association from pool.

void	touch_association (uint64_t id)
	Update association activity timestamp.

void	check_idle_timeouts ()
	Check for idle timeout.

uint64_t	next_association_id ()
	Generate unique association ID.

void	report_error (const std::string &error)
	Report error through callback.

Private Attributes
std::shared_ptr< integration::thread_pool_interface >	thread_pool_
	Thread pool for asynchronous task execution.

server_config	config_
	Server configuration.

std::vector< services::scp_service_ptr >	services_
	Registered SCP services.

std::unordered_map< std::string, services::scp_service * >	sop_class_to_service_
	Map from SOP Class UID to service.

std::unordered_map< uint64_t, std::unique_ptr< association_info > >	associations_
	Active associations.

server_statistics	stats_
	Server statistics.

std::atomic< uint64_t >	association_id_counter_ {0}
	Association ID counter.

std::atomic< bool >	running_ {false}
	Running flag.

std::unique_ptr< detail::accept_worker >	accept_worker_
	Accept worker (replaces std::thread accept_thread_)

std::mutex	associations_mutex_
	Association mutex.

std::mutex	stats_mutex_
	Statistics mutex.

std::mutex	services_mutex_
	Service registry mutex.

std::condition_variable	shutdown_cv_
	Shutdown condition variable.

std::mutex	shutdown_mutex_
	Shutdown mutex.

association_callback	on_established_cb_
	Association established callback.

association_callback	on_released_cb_
	Association released callback.

error_callback	on_error_cb_
	Error callback.

std::mutex	callback_mutex_
	Callback mutex.

Detailed Description

Definition at line 97 of file dicom_server.h.

Member Typedef Documentation

◆ association_callback

using kcenon::pacs::network::dicom_server::association_callback = std::function<void(const association&)>

Callback type for association events.

Definition at line 108 of file dicom_server.h.

◆ clock

using kcenon::pacs::network::dicom_server::clock = std::chrono::steady_clock

Definition at line 103 of file dicom_server.h.

◆ duration

using kcenon::pacs::network::dicom_server::duration = std::chrono::milliseconds

Definition at line 104 of file dicom_server.h.

◆ error_callback

using kcenon::pacs::network::dicom_server::error_callback = std::function<void(const std::string&)>

Callback type for error events.

Definition at line 111 of file dicom_server.h.

◆ time_point

using kcenon::pacs::network::dicom_server::time_point = clock::time_point

Definition at line 105 of file dicom_server.h.

Constructor & Destructor Documentation

◆ dicom_server() [1/4]

kcenon::pacs::network::dicom_server::dicom_server ( const server_config & config )

explicit

Construct server with configuration.

Creates a default thread pool adapter internally.

Parameters

config Server configuration

Definition at line 40 of file dicom_server.cpp.

    : dicom_server(
          config,
          std::make_shared<integration::thread_pool_adapter>(
              integration::thread_pool_config{})) {
}

◆ dicom_server() [2/4]

kcenon::pacs::network::dicom_server::dicom_server	(	const server_config &	config,
		std::shared_ptr< integration::thread_pool_interface >	thread_pool )

Construct server with configuration and injected thread pool.

Allows dependency injection of the thread pool for testability.

Parameters

config	Server configuration
thread_pool	Thread pool interface for task submission

Definition at line 47 of file dicom_server.cpp.

    : thread_pool_(std::move(thread_pool))
    , config_(config) {
    stats_.start_time = clock::now();
    stats_.last_activity = stats_.start_time;
 
    // Ensure thread pool is started
    if (thread_pool_ && !thread_pool_->is_running()) {
        static_cast<void>(thread_pool_->start());
    }
}

References kcenon::pacs::network::server_statistics::last_activity, kcenon::pacs::network::server_statistics::start_time, stats_, and thread_pool_.

◆ ~dicom_server()

kcenon::pacs::network::dicom_server::~dicom_server ( )

Destructor (stops server if running)

Definition at line 61 of file dicom_server.cpp.

                            {
    if (running_) {
        stop();
    }
}

References running_, and stop().

Here is the call graph for this function:

◆ dicom_server() [3/4]

kcenon::pacs::network::dicom_server::dicom_server ( const dicom_server & )

delete

◆ dicom_server() [4/4]

kcenon::pacs::network::dicom_server::dicom_server ( dicom_server && )

delete

Member Function Documentation

◆ active_associations()

size_t kcenon::pacs::network::dicom_server::active_associations ( ) const

nodiscardnoexcept

Get number of active associations.

Returns: Current number of active DICOM associations

Definition at line 261 of file dicom_server.cpp.

                                                        {
    std::lock_guard<std::mutex> lock(associations_mutex_);
    return associations_.size();
}

References associations_, and associations_mutex_.

Referenced by get_statistics().

Here is the caller graph for this function:

◆ add_association()

void kcenon::pacs::network::dicom_server::add_association ( association_info info )

private

Add association to pool.

Definition at line 507 of file dicom_server.cpp.

                                                        {
    std::lock_guard<std::mutex> lock(associations_mutex_);
    auto id = info.id;
    associations_.emplace(id, std::make_unique<association_info>(std::move(info)));
}

References associations_, and associations_mutex_.

Referenced by handle_association().

Here is the caller graph for this function:

◆ check_idle_timeouts()

void kcenon::pacs::network::dicom_server::check_idle_timeouts ( )

private

Check for idle timeout.

Definition at line 533 of file dicom_server.cpp.

                                       {
    if (config_.idle_timeout.count() == 0) {
        return;  // No timeout configured
    }
 
    auto now = clock::now();
    std::vector<uint64_t> timed_out;
 
    {
        std::lock_guard<std::mutex> lock(associations_mutex_);
        for (auto& [id, info] : associations_) {
            auto idle_duration = std::chrono::duration_cast<std::chrono::seconds>(
                now - info->last_activity);
 
            if (idle_duration >= config_.idle_timeout) {
                timed_out.push_back(id);
            }
        }
 
        // Abort timed-out associations
        for (auto id : timed_out) {
            auto it = associations_.find(id);
            if (it != associations_.end()) {
                it->second->assoc.abort(
                    static_cast<uint8_t>(abort_source::service_provider),
                    static_cast<uint8_t>(abort_reason::not_specified));
            }
        }
    }
}

References associations_, associations_mutex_, config_, kcenon::pacs::network::server_config::idle_timeout, kcenon::pacs::network::not_specified, and kcenon::pacs::network::service_provider.

◆ config()

const server_config & kcenon::pacs::network::dicom_server::config ( ) const

nodiscardnoexcept

Get server configuration.

Returns: Reference to current configuration

Definition at line 273 of file dicom_server.cpp.

                                                         {
    return config_;
}

References config_.

◆ dispatch_to_service()

Result< std::monostate > kcenon::pacs::network::dicom_server::dispatch_to_service	(	association &	assoc,
		uint8_t	context_id,
		const dimse::dimse_message &	msg )

private

Dispatch message to appropriate service.

Definition at line 456 of file dicom_server.cpp.

                                   {
 
    // Get the SOP Class from the message
    std::string sop_class_uid = msg.affected_sop_class_uid();
 
    if (sop_class_uid.empty()) {
        return error_info("Cannot determine SOP Class UID from message");
    }
 
    // Find the appropriate service
    auto* service = find_service(sop_class_uid);
    if (!service) {
        return error_info("No service registered for SOP Class: " + sop_class_uid);
    }
 
    // Dispatch to service
    return service->handle_message(assoc, context_id, msg);
}

References kcenon::pacs::network::dimse::dimse_message::affected_sop_class_uid(), and find_service().

Referenced by message_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_service()

services::scp_service * kcenon::pacs::network::dicom_server::find_service ( const std::string & sop_class_uid ) const

nodiscardprivate

Get service for SOP Class.

Definition at line 496 of file dicom_server.cpp.

                                          {
 
    std::lock_guard<std::mutex> lock(services_mutex_);
    auto it = sop_class_to_service_.find(sop_class_uid);
    if (it != sop_class_to_service_.end()) {
        return it->second;
    }
    return nullptr;
}

References services_mutex_, and sop_class_to_service_.

Referenced by dispatch_to_service().

Here is the caller graph for this function:

◆ get_server_on_port()

dicom_server * kcenon::pacs::network::dicom_server::get_server_on_port ( uint16_t port )

static

Get server instance listening on port (for in-memory testing).

Definition at line 575 of file dicom_server.cpp.

                                                            {
    std::lock_guard<std::mutex> lock(registry_mutex_);
    auto it = server_registry_.find(port);
    return it != server_registry_.end() ? it->second : nullptr;
}

References kcenon::pacs::network::registry_mutex_, and kcenon::pacs::network::server_registry_.

Referenced by kcenon::pacs::network::association::connect().

Here is the caller graph for this function:

◆ get_statistics()

server_statistics kcenon::pacs::network::dicom_server::get_statistics ( ) const

nodiscard

Get server statistics.

Returns: Current server statistics

Definition at line 266 of file dicom_server.cpp.

                                                     {
    std::lock_guard<std::mutex> lock(stats_mutex_);
    server_statistics result = stats_;
    result.active_associations = active_associations();
    return result;
}

References active_associations(), kcenon::pacs::network::server_statistics::active_associations, stats_, and stats_mutex_.

Here is the call graph for this function:

◆ handle_association()

void kcenon::pacs::network::dicom_server::handle_association	(	uint64_t	session_id,
		association	assoc )

private

Handle a single association (runs in worker thread)

Definition at line 300 of file dicom_server.cpp.

                                                                            {
    // Check max associations limit
    {
        std::lock_guard<std::mutex> lock(associations_mutex_);
        if (config_.max_associations > 0 &&
            associations_.size() >= config_.max_associations) {
            // Reject due to resource limit
            assoc.abort(
                static_cast<uint8_t>(abort_source::service_provider),
                static_cast<uint8_t>(abort_reason::not_specified));
 
            std::lock_guard<std::mutex> stats_lock(stats_mutex_);
            stats_.rejected_associations++;
            return;
        }
    }
 
    // Create association info
    association_info info;
    info.id = session_id;
    info.assoc = std::move(assoc);
    info.connected_at = clock::now();
    info.last_activity = info.connected_at;
 
    // Invoke established callback
    {
        std::lock_guard<std::mutex> lock(callback_mutex_);
        if (on_established_cb_) {
            on_established_cb_(info.assoc);
        }
    }
 
    // Publish association established event
    kcenon::common::get_event_bus().publish(
        kcenon::pacs::events::association_established_event{
            std::string(info.assoc.calling_ae()),
            std::string(info.assoc.called_ae()),
            info.remote_address,
            config_.port,
            info.assoc.max_pdu_size()
        }
    );
 
    // Add to active associations
    add_association(std::move(info));
 
    // Update statistics
    {
        std::lock_guard<std::mutex> lock(stats_mutex_);
        stats_.total_associations++;
        stats_.last_activity = clock::now();
    }
}

References kcenon::pacs::network::association::abort(), add_association(), associations_, associations_mutex_, callback_mutex_, config_, kcenon::pacs::network::server_statistics::last_activity, kcenon::pacs::network::server_config::max_associations, kcenon::pacs::network::not_specified, on_established_cb_, kcenon::pacs::network::server_config::port, kcenon::pacs::network::server_statistics::rejected_associations, kcenon::pacs::network::service_provider, stats_, stats_mutex_, and kcenon::pacs::network::server_statistics::total_associations.

Referenced by simulate_association_request().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_running()

bool kcenon::pacs::network::dicom_server::is_running ( ) const

nodiscardnoexcept

Check if server is running.

Returns: true if server is accepting connections

Definition at line 257 of file dicom_server.cpp.

                                             {
    return running_;
}

References running_.

◆ message_loop()

void kcenon::pacs::network::dicom_server::message_loop ( association_info & info )

private

Process incoming DIMSE messages.

Definition at line 354 of file dicom_server.cpp.

                                                      {
    // Check both running flag and cancellation token for cooperative shutdown
    while (running_ && !info.cancel_token.is_cancelled() && info.assoc.is_established()) {
        // Receive DIMSE message with timeout
        // Use shorter timeout to check cancellation more frequently
        auto receive_timeout = (std::min)(
            std::chrono::duration_cast<association::duration>(config_.idle_timeout),
            association::duration{1000}  // Check cancellation at least every second
        );
 
        auto result = info.assoc.receive_dimse(receive_timeout);
 
        // Check for cancellation after potentially blocking receive
        if (info.cancel_token.is_cancelled()) {
            break;
        }
 
        if (result.is_err()) {
            // Check if it was a timeout vs. actual error
            if (info.assoc.is_established()) {
                // Still established, might be timeout - check idle
                auto now = clock::now();
                auto idle_duration = std::chrono::duration_cast<std::chrono::seconds>(
                    now - info.last_activity);
 
                if (config_.idle_timeout.count() > 0 &&
                    idle_duration >= config_.idle_timeout) {
                    // Idle timeout - abort association
                    info.assoc.abort(
                        static_cast<uint8_t>(abort_source::service_provider),
                        static_cast<uint8_t>(abort_reason::not_specified));
                }
            }
            break;
        }
 
        // Update activity timestamp
        info.last_activity = clock::now();
        touch_association(info.id);
 
        // Dispatch message to service
        auto& [context_id, msg] = result.value();
        auto dispatch_result = dispatch_to_service(info.assoc, context_id, msg);
 
        if (dispatch_result.is_err()) {
            report_error(dispatch_result.error().message);
        }
 
        // Update statistics
        {
            std::lock_guard<std::mutex> lock(stats_mutex_);
            stats_.messages_processed++;
            stats_.last_activity = clock::now();
        }
    }
 
    // If cancelled, attempt graceful release before forced abort
    if (info.cancel_token.is_cancelled() && info.assoc.is_established()) {
        // Try graceful release first - ignore result as we'll abort anyway if it fails
        // The Phase 3 shutdown will handle any remaining established associations
        (void)info.assoc.release();
    }
 
    // Calculate association duration
    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(
        clock::now() - info.connected_at);
 
    // Determine if aborted
    bool is_aborted = info.assoc.state() == association_state::aborted;
 
    // Association ended - invoke released callback
    {
        std::lock_guard<std::mutex> lock(callback_mutex_);
        if (on_released_cb_) {
            on_released_cb_(info.assoc);
        }
    }
 
    // Publish association event (released or aborted)
    if (is_aborted) {
        kcenon::common::get_event_bus().publish(
            kcenon::pacs::events::association_aborted_event{
                std::string(info.assoc.calling_ae()),
                std::string(info.assoc.called_ae()),
                "Association aborted"
            }
        );
    } else {
        kcenon::common::get_event_bus().publish(
            kcenon::pacs::events::association_released_event{
                std::string(info.assoc.calling_ae()),
                std::string(info.assoc.called_ae()),
                duration,
                0  // operations_count not tracked yet
            }
        );
    }
 
    // Remove from active associations
    remove_association(info.id);
}

References kcenon::pacs::network::aborted, callback_mutex_, config_, dispatch_to_service(), kcenon::pacs::network::server_config::idle_timeout, kcenon::pacs::network::server_statistics::last_activity, kcenon::pacs::network::server_statistics::messages_processed, kcenon::pacs::network::not_specified, on_released_cb_, remove_association(), report_error(), running_, kcenon::pacs::network::service_provider, stats_, stats_mutex_, and touch_association().

Referenced by simulate_association_request().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ next_association_id()

uint64_t kcenon::pacs::network::dicom_server::next_association_id ( )

nodiscardprivate

Generate unique association ID.

Definition at line 564 of file dicom_server.cpp.

                                           {
    return association_id_counter_.fetch_add(1, std::memory_order_relaxed);
}

References association_id_counter_.

Referenced by simulate_association_request().

Here is the caller graph for this function:

◆ on_association_established()

void kcenon::pacs::network::dicom_server::on_association_established ( association_callback callback )

Set callback for association established events.

Parameters

callback Function to call when an association is established

Definition at line 281 of file dicom_server.cpp.

                                                                           {
    std::lock_guard<std::mutex> lock(callback_mutex_);
    on_established_cb_ = std::move(callback);
}

References callback_mutex_, and on_established_cb_.

◆ on_association_released()

void kcenon::pacs::network::dicom_server::on_association_released ( association_callback callback )

Set callback for association released events.

Parameters

callback Function to call when an association is released

Definition at line 286 of file dicom_server.cpp.

                                                                        {
    std::lock_guard<std::mutex> lock(callback_mutex_);
    on_released_cb_ = std::move(callback);
}

References callback_mutex_, and on_released_cb_.

◆ on_error()

void kcenon::pacs::network::dicom_server::on_error ( error_callback callback )

Set callback for error events.

Parameters

callback Function to call on server errors

Definition at line 291 of file dicom_server.cpp.

                                                   {
    std::lock_guard<std::mutex> lock(callback_mutex_);
    on_error_cb_ = std::move(callback);
}

References callback_mutex_, and on_error_cb_.

◆ operator=() [1/2]

dicom_server & kcenon::pacs::network::dicom_server::operator= ( const dicom_server & )

delete

◆ operator=() [2/2]

dicom_server & kcenon::pacs::network::dicom_server::operator= ( dicom_server && )

delete

◆ register_service()

void kcenon::pacs::network::dicom_server::register_service ( services::scp_service_ptr service )

Register an SCP service.

The server takes ownership of the service and routes DIMSE messages to it based on the SOP Classes it supports.

Parameters

service The SCP service to register

Note: Services must be registered before calling start()

Definition at line 71 of file dicom_server.cpp.

                                                                   {
    if (!service) {
        return;
    }
 
    std::lock_guard<std::mutex> lock(services_mutex_);
 
    // Register SOP Class mappings
    for (const auto& sop_class : service->supported_sop_classes()) {
        sop_class_to_service_[sop_class] = service.get();
    }
 
    services_.push_back(std::move(service));
}

References services_, services_mutex_, and sop_class_to_service_.

◆ remove_association()

void kcenon::pacs::network::dicom_server::remove_association ( uint64_t id )

private

Remove association from pool.

Definition at line 513 of file dicom_server.cpp.

                                                 {
    std::lock_guard<std::mutex> lock(associations_mutex_);
    auto it = associations_.find(id);
    if (it != associations_.end()) {
        // With thread_pool_adapter, no thread join is needed.
        // Just mark as not processing and remove from map.
        // Note: Already holding associations_mutex_ so no atomic needed
        it->second->processing = false;
        associations_.erase(it);
    }
}

References associations_, and associations_mutex_.

Referenced by message_loop().

Here is the caller graph for this function:

◆ report_error()

void kcenon::pacs::network::dicom_server::report_error ( const std::string & error )

private

Report error through callback.

Definition at line 568 of file dicom_server.cpp.

                                                      {
    std::lock_guard<std::mutex> lock(callback_mutex_);
    if (on_error_cb_) {
        on_error_cb_(error);
    }
}

References callback_mutex_, and on_error_cb_.

Referenced by message_loop().

Here is the caller graph for this function:

◆ simulate_association_request()

Result< associate_ac > kcenon::pacs::network::dicom_server::simulate_association_request	(	const associate_rq &	rq,
		association *	client_peer )

Simulate an incoming association request (for in-memory testing).

Definition at line 581 of file dicom_server.cpp.

                                                                                                                {
    // Validate called AE title
    if (!validate_called_ae(rq.called_ae_title)) {
        return error_info("Called AE Title not recognized");
    }
 
    // Validate calling AE title
    if (!validate_calling_ae(rq.calling_ae_title)) {
        return error_info("Calling AE Title not recognized");
    }
 
    // Create SCP configuration for negotiation
    scp_config negotiation_config;
    negotiation_config.ae_title = config_.ae_title;
    negotiation_config.max_pdu_length = config_.max_pdu_size;
    negotiation_config.implementation_class_uid = config_.implementation_class_uid;
    negotiation_config.implementation_version_name = config_.implementation_version_name;
    negotiation_config.supported_abstract_syntaxes = supported_sop_classes();
    // Accept compressed and uncompressed transfer syntaxes
    negotiation_config.supported_transfer_syntaxes = {
        "1.2.840.10008.1.2.4.201", // HTJ2K Lossless Only
        "1.2.840.10008.1.2.4.202", // HTJ2K RPCL Lossless Only
        "1.2.840.10008.1.2.4.203", // HTJ2K (Lossless or Lossy)
        "1.2.840.10008.1.2.4.90",  // JPEG 2000 Lossless
        "1.2.840.10008.1.2.4.91",  // JPEG 2000 Lossy
        "1.2.840.10008.1.2.4.80",  // JPEG-LS Lossless
        "1.2.840.10008.1.2.4.81",  // JPEG-LS Near-Lossless
        "1.2.840.10008.1.2.4.70",  // JPEG Lossless
        "1.2.840.10008.1.2.4.50",  // JPEG Baseline
        "1.2.840.10008.1.2.5",     // RLE Lossless
        "1.2.840.10008.1.2.1",     // Explicit VR LE
        "1.2.840.10008.1.2"        // Implicit VR LE
    };
 
    // Accept association
    auto assoc = association::accept(rq, negotiation_config);
 
    if (!assoc.is_established()) {
        return error_info("Association rejected: no acceptable presentation contexts");
    }
 
    // Build AC PDU before moving association
    auto ac = assoc.build_associate_ac();
 
    // Register association
    uint64_t id = next_association_id();
    handle_association(id, std::move(assoc));
 
    // Link peers and start message processing via thread pool
    {
        std::lock_guard<std::mutex> lock(associations_mutex_);
        auto it = associations_.find(id);
        if (it != associations_.end()) {
            // Link peers
            it->second->assoc.set_peer(client_peer);
            client_peer->set_peer(&it->second->assoc);
 
            // Submit message loop to thread_pool_adapter instead of creating dedicated thread.
            // We need to capture the raw pointer to info because unique_ptr is in the map.
            // The map might rehash but the unique_ptr value (the pointer to association_info) is stable.
            auto* info_ptr = it->second.get();
 
            // Mark as processing before submitting to pool
            // Note: Already holding associations_mutex_ so no atomic needed
            info_ptr->processing = true;
 
            // Submit with high priority - association message handling is important
            thread_pool_->submit_fire_and_forget(
                [this, info_ptr]() {
                    message_loop(*info_ptr);
                }
            );
        }
    }
 
    return ac;
}

Here is the call graph for this function:

◆ start()

Result< std::monostate > kcenon::pacs::network::dicom_server::start ( )

nodiscard

Start the server.

Binds to the configured port and begins accepting connections.

Returns: Success or error with description

Definition at line 103 of file dicom_server.cpp.

                                         {
    if (running_.exchange(true)) {
        return error_info("Server already running");
    }
 
    // Validate configuration
    if (config_.ae_title.empty()) {
        running_ = false;
        return error_info("AE Title cannot be empty");
    }
 
    if (config_.ae_title.length() > AE_TITLE_LENGTH) {
        running_ = false;
        return error_info("AE Title exceeds 16 characters");
    }
 
    if (config_.port == 0) {
        running_ = false;
        return error_info("Invalid port number");
    }
 
    // Check that at least one service is registered
    {
        std::lock_guard<std::mutex> lock(services_mutex_);
        if (services_.empty()) {
            running_ = false;
            return error_info("No services registered");
        }
    }
 
    // Reset statistics
    {
        std::lock_guard<std::mutex> lock(stats_mutex_);
        stats_.start_time = clock::now();
        stats_.last_activity = stats_.start_time;
        stats_.total_associations = 0;
        stats_.active_associations = 0;
        stats_.rejected_associations = 0;
        stats_.messages_processed = 0;
        stats_.bytes_received = 0;
        stats_.bytes_sent = 0;
    }
 
    // Create and start accept worker
    accept_worker_ = std::make_unique<detail::accept_worker>(
        config_.port,
        // Connection callback (currently unused - placeholder for future TCP integration)
        [](uint64_t /*session_id*/) {
            // Future: handle new TCP connection
        },
        // Maintenance callback for periodic idle timeout checks
        [this]() {
            check_idle_timeouts();
        }
    );
    accept_worker_->set_wake_interval(std::chrono::milliseconds(100));
 
    auto start_result = accept_worker_->start();
    if (start_result.is_err()) {
        running_ = false;
        return error_info("Failed to start accept worker: " +
                         start_result.error().message);
    }
 
    // Register in global registry
    {
        std::lock_guard<std::mutex> lock(registry_mutex_);
        server_registry_[config_.port] = this;
    }
 
    return std::monostate{};
}

◆ stop()

void kcenon::pacs::network::dicom_server::stop ( duration timeout = std::chrono::seconds{30} )

Stop the server gracefully.

Stops accepting new connections and waits for active associations to complete or timeout.

Parameters

timeout Maximum time to wait for associations to close

Definition at line 176 of file dicom_server.cpp.

                                        {
    if (!running_.exchange(false)) {
        return;  // Already stopped
    }
 
    // Unregister from global registry
    {
        std::lock_guard<std::mutex> lock(registry_mutex_);
        server_registry_.erase(config_.port);
    }
 
    // Stop accept worker (handles graceful shutdown via on_stop_requested hook)
    if (accept_worker_) {
        accept_worker_->stop();
        accept_worker_.reset();
    }
 
    // =========================================================================
    // Phase 1: Request graceful cancellation via cancellation tokens
    // =========================================================================
    // This triggers cooperative cancellation in all message loops.
    // The message_loop will detect cancellation and attempt graceful release.
    {
        std::lock_guard<std::mutex> lock(associations_mutex_);
        for (auto& [id, info] : associations_) {
            info->cancel_token.cancel();
        }
    }
 
    // =========================================================================
    // Phase 2: Wait for graceful shutdown with timeout
    // =========================================================================
    // Give associations time to complete their graceful release.
    // The message_loop will call release() and remove itself from the map.
    auto deadline = clock::now() + timeout;
    {
        std::unique_lock<std::mutex> lock(associations_mutex_);
        while (!associations_.empty() && clock::now() < deadline) {
            // Release lock while waiting to allow message_loop to remove associations
            lock.unlock();
            std::this_thread::sleep_for(std::chrono::milliseconds{100});
            lock.lock();
        }
    }
 
    // =========================================================================
    // Phase 3: Force abort remaining associations
    // =========================================================================
    // If any associations are still active after timeout, force abort them.
    // This ensures we don't hang indefinitely on unresponsive connections.
    {
        std::lock_guard<std::mutex> lock(associations_mutex_);
        for (auto& [id, info] : associations_) {
            if (info->assoc.is_established()) {
                info->assoc.abort(
                    static_cast<uint8_t>(abort_source::service_provider),
                    static_cast<uint8_t>(abort_reason::not_specified));
            }
            // Mark as no longer processing
            // Note: Already holding associations_mutex_ so no atomic needed
            info->processing = false;
        }
        associations_.clear();
    }
 
    // Notify shutdown waiters
    {
        std::lock_guard<std::mutex> lock(shutdown_mutex_);
        shutdown_cv_.notify_all();
    }
}

References accept_worker_, associations_, associations_mutex_, config_, kcenon::pacs::network::not_specified, kcenon::pacs::network::server_config::port, kcenon::pacs::network::registry_mutex_, running_, kcenon::pacs::network::server_registry_, kcenon::pacs::network::service_provider, shutdown_cv_, and shutdown_mutex_.

Referenced by ~dicom_server().

Here is the caller graph for this function:

◆ supported_sop_classes()

std::vector< std::string > kcenon::pacs::network::dicom_server::supported_sop_classes ( ) const

nodiscard

Get list of supported SOP Class UIDs.

Returns: Vector of all SOP Classes supported by registered services

Definition at line 86 of file dicom_server.cpp.

                                                               {
    std::lock_guard<std::mutex> lock(services_mutex_);
 
    std::vector<std::string> sop_classes;
    sop_classes.reserve(sop_class_to_service_.size());
 
    for (const auto& [uid, _] : sop_class_to_service_) {
        sop_classes.push_back(uid);
    }
 
    return sop_classes;
}

References services_mutex_, sop_class_to_service_, and uid.

Referenced by simulate_association_request().

Here is the caller graph for this function:

◆ touch_association()

void kcenon::pacs::network::dicom_server::touch_association ( uint64_t id )

private

Update association activity timestamp.

Definition at line 525 of file dicom_server.cpp.

                                                {
    std::lock_guard<std::mutex> lock(associations_mutex_);
    auto it = associations_.find(id);
    if (it != associations_.end()) {
        it->second->last_activity = clock::now();
    }
}

References associations_, and associations_mutex_.

Referenced by message_loop().

Here is the caller graph for this function:

◆ validate_called_ae()

bool kcenon::pacs::network::dicom_server::validate_called_ae ( const std::string & called_ae ) const

nodiscardprivate

Validate called AE title.

Definition at line 492 of file dicom_server.cpp.

                                                                      {
    return called_ae == config_.ae_title;
}

References kcenon::pacs::network::server_config::ae_title, and config_.

Referenced by simulate_association_request().

Here is the caller graph for this function:

◆ validate_calling_ae()

bool kcenon::pacs::network::dicom_server::validate_calling_ae ( const std::string & calling_ae ) const

nodiscardprivate

Validate calling AE title.

Definition at line 478 of file dicom_server.cpp.

                                                                        {
    if (config_.ae_whitelist.empty()) {
        return true;  // No whitelist = accept all
    }
 
    if (config_.accept_unknown_calling_ae) {
        return true;
    }
 
    return std::find(config_.ae_whitelist.begin(),
                     config_.ae_whitelist.end(),
                     calling_ae) != config_.ae_whitelist.end();
}

References kcenon::pacs::network::server_config::accept_unknown_calling_ae, kcenon::pacs::network::server_config::ae_whitelist, and config_.

Referenced by simulate_association_request().

Here is the caller graph for this function:

◆ wait_for_shutdown()

void kcenon::pacs::network::dicom_server::wait_for_shutdown ( )

Wait for server shutdown.

Blocks until the server is stopped (either by calling stop() or due to an error).

Definition at line 248 of file dicom_server.cpp.

                                     {
    std::unique_lock<std::mutex> lock(shutdown_mutex_);
    shutdown_cv_.wait(lock, [this]() { return !running_; });
}

References running_, shutdown_cv_, and shutdown_mutex_.

Member Data Documentation

◆ accept_worker_

std::unique_ptr<detail::accept_worker> kcenon::pacs::network::dicom_server::accept_worker_

private

Accept worker (replaces std::thread accept_thread_)

Definition at line 355 of file dicom_server.h.

Referenced by start(), and stop().

◆ association_id_counter_

std::atomic<uint64_t> kcenon::pacs::network::dicom_server::association_id_counter_ {0}

private

Association ID counter.

Definition at line 349 of file dicom_server.h.

349{0};

Referenced by next_association_id().

◆ associations_

std::unordered_map<uint64_t, std::unique_ptr<association_info> > kcenon::pacs::network::dicom_server::associations_

private

Active associations.

Definition at line 343 of file dicom_server.h.

Referenced by active_associations(), add_association(), check_idle_timeouts(), handle_association(), remove_association(), simulate_association_request(), stop(), and touch_association().

◆ associations_mutex_

std::mutex kcenon::pacs::network::dicom_server::associations_mutex_

mutableprivate

Association mutex.

Definition at line 358 of file dicom_server.h.

Referenced by active_associations(), add_association(), check_idle_timeouts(), handle_association(), remove_association(), simulate_association_request(), stop(), and touch_association().

◆ callback_mutex_

std::mutex kcenon::pacs::network::dicom_server::callback_mutex_

private

Callback mutex.

Definition at line 382 of file dicom_server.h.

Referenced by handle_association(), message_loop(), on_association_established(), on_association_released(), on_error(), and report_error().

◆ config_

server_config kcenon::pacs::network::dicom_server::config_

private

Server configuration.

Definition at line 334 of file dicom_server.h.

Referenced by check_idle_timeouts(), config(), handle_association(), message_loop(), simulate_association_request(), start(), stop(), validate_called_ae(), and validate_calling_ae().

◆ on_error_cb_

error_callback kcenon::pacs::network::dicom_server::on_error_cb_

private

Error callback.

Definition at line 379 of file dicom_server.h.

Referenced by on_error(), and report_error().

◆ on_established_cb_

association_callback kcenon::pacs::network::dicom_server::on_established_cb_

private

Association established callback.

Definition at line 373 of file dicom_server.h.

Referenced by handle_association(), and on_association_established().

◆ on_released_cb_

association_callback kcenon::pacs::network::dicom_server::on_released_cb_

private

Association released callback.

Definition at line 376 of file dicom_server.h.

Referenced by message_loop(), and on_association_released().

◆ running_

std::atomic<bool> kcenon::pacs::network::dicom_server::running_ {false}

private

Running flag.

Definition at line 352 of file dicom_server.h.

352{false};

Referenced by is_running(), message_loop(), start(), stop(), wait_for_shutdown(), and ~dicom_server().

◆ services_

std::vector<services::scp_service_ptr> kcenon::pacs::network::dicom_server::services_

private

Registered SCP services.

Definition at line 337 of file dicom_server.h.

Referenced by register_service(), and start().

◆ services_mutex_

std::mutex kcenon::pacs::network::dicom_server::services_mutex_

mutableprivate

Service registry mutex.

Definition at line 364 of file dicom_server.h.

Referenced by find_service(), register_service(), start(), and supported_sop_classes().

◆ shutdown_cv_

std::condition_variable kcenon::pacs::network::dicom_server::shutdown_cv_

private

Shutdown condition variable.

Definition at line 367 of file dicom_server.h.

Referenced by stop(), and wait_for_shutdown().

◆ shutdown_mutex_

std::mutex kcenon::pacs::network::dicom_server::shutdown_mutex_

private

Shutdown mutex.

Definition at line 370 of file dicom_server.h.

Referenced by stop(), and wait_for_shutdown().

◆ sop_class_to_service_

std::unordered_map<std::string, services::scp_service*> kcenon::pacs::network::dicom_server::sop_class_to_service_

private

Map from SOP Class UID to service.

Definition at line 340 of file dicom_server.h.

Referenced by find_service(), register_service(), and supported_sop_classes().

◆ stats_

server_statistics kcenon::pacs::network::dicom_server::stats_

mutableprivate

Server statistics.

Definition at line 346 of file dicom_server.h.

Referenced by dicom_server(), get_statistics(), handle_association(), message_loop(), and start().

◆ stats_mutex_

std::mutex kcenon::pacs::network::dicom_server::stats_mutex_

mutableprivate

Statistics mutex.

Definition at line 361 of file dicom_server.h.

Referenced by get_statistics(), handle_association(), message_loop(), and start().

◆ thread_pool_

std::shared_ptr<integration::thread_pool_interface> kcenon::pacs::network::dicom_server::thread_pool_

private

Thread pool for asynchronous task execution.

Definition at line 331 of file dicom_server.h.

Referenced by dicom_server(), and simulate_association_request().

The documentation for this class was generated from the following files:

include/kcenon/pacs/network/dicom_server.h
src/network/dicom_server.cpp

Classes

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ association_callback

◆ clock

◆ duration

◆ error_callback

◆ time_point

Constructor & Destructor Documentation

◆ dicom_server() [1/4]

◆ dicom_server() [2/4]

◆ ~dicom_server()

◆ dicom_server() [3/4]

◆ dicom_server() [4/4]

Member Function Documentation

◆ active_associations()

◆ add_association()

◆ check_idle_timeouts()

◆ config()

◆ dispatch_to_service()

◆ find_service()

◆ get_server_on_port()

◆ get_statistics()

◆ handle_association()

◆ is_running()

◆ message_loop()

◆ next_association_id()

◆ on_association_established()

◆ on_association_released()

◆ on_error()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ register_service()

◆ remove_association()

◆ report_error()

◆ simulate_association_request()

◆ start()

◆ stop()

◆ supported_sop_classes()

◆ touch_association()

◆ validate_called_ae()

◆ validate_calling_ae()

◆ wait_for_shutdown()

Member Data Documentation

◆ accept_worker_

◆ association_id_counter_

◆ associations_

◆ associations_mutex_

◆ callback_mutex_

◆ config_

◆ on_error_cb_

◆ on_established_cb_

◆ on_released_cb_

◆ running_

◆ services_

◆ services_mutex_

◆ shutdown_cv_

◆ shutdown_mutex_

◆ sop_class_to_service_

◆ stats_

◆ stats_mutex_

◆ thread_pool_