kcenon::pacs::network::v2::dicom_server_v2 Class Reference

DICOM server using network_system's messaging_server for connection management. More...

#include <dicom_server_v2.h>

Collaboration diagram for kcenon::pacs::network::v2::dicom_server_v2:

Public Types
using	clock = std::chrono::steady_clock
using	duration = std::chrono::milliseconds
using	time_point = clock::time_point
using	association_established_callback
	Callback type for association established events.
using	association_closed_callback
	Callback type for association closed events.
using	error_callback = std::function<void(const std::string& error)>
	Callback type for error events.

Public Member Functions
	dicom_server_v2 (const server_config &config)
	Construct server with configuration.
	~dicom_server_v2 ()
	Destructor (stops server if running)
	dicom_server_v2 (const dicom_server_v2 &)=delete
dicom_server_v2 &	operator= (const dicom_server_v2 &)=delete
	dicom_server_v2 (dicom_server_v2 &&)=delete
dicom_server_v2 &	operator= (dicom_server_v2 &&)=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_established_callback callback)
	Set callback for association established events.
void	on_association_closed (association_closed_callback callback)
	Set callback for association closed events.
void	on_error (error_callback callback)
	Set callback for error events.
void	set_access_control (std::shared_ptr< security::access_control_manager > acm)
	Set the access control manager for RBAC.
std::shared_ptr< security::access_control_manager >	get_access_control () const noexcept
	Get the access control manager.
void	set_access_control_enabled (bool enabled)
	Enable or disable access control enforcement.
bool	is_access_control_enabled () const noexcept
	Check if access control is enabled.

Private Member Functions
void	on_connection (std::shared_ptr< kcenon::network::interfaces::i_session > session)
	Handle new connection from server.
void	on_disconnection (std::string_view session_id)
	Handle disconnection notification.
void	on_receive (std::string_view session_id, const std::vector< uint8_t > &data)
	Handle receive data (forwarded to handler)
void	on_network_error (std::string_view session_id, std::error_code ec)
	Handle network error.
void	create_handler (std::shared_ptr< kcenon::network::interfaces::i_session > session)
	Create and register a new handler for a session.
void	remove_handler (const std::string &session_id)
	Remove handler by session ID.
std::shared_ptr< dicom_association_handler >	find_handler (const std::string &session_id) const
	Find handler by session ID.
void	check_idle_timeouts ()
	Check for idle timeouts on handlers.
dicom_association_handler::service_map	build_service_map () const
	Build service map from registered services.
void	report_error (const std::string &error)
	Report error through callback.

Private Attributes
server_config	config_
	Server configuration.
std::shared_ptr< kcenon::network::interfaces::i_protocol_server >	server_
	network_system's protocol server (via tcp_facade)
std::vector< services::scp_service_ptr >	services_
	Registered SCP services.
std::map< std::string, services::scp_service * >	sop_class_to_service_
	Map from SOP Class UID to service (non-owning pointers)
std::unordered_map< std::string, std::shared_ptr< dicom_association_handler > >	handlers_
	Active association handlers (keyed by session ID)
server_statistics	stats_
	Server statistics.
std::atomic< bool >	running_ {false}
	Running flag.
std::mutex	handlers_mutex_
	Handler mutex (protects handlers_ map)
std::mutex	services_mutex_
	Service mutex (protects services_ and sop_class_to_service_)
std::mutex	stats_mutex_
	Statistics mutex.
std::condition_variable	shutdown_cv_
	Shutdown condition variable.
std::mutex	shutdown_mutex_
	Shutdown mutex.
association_established_callback	on_established_cb_
	Association established callback.
association_closed_callback	on_closed_cb_
	Association closed callback.
error_callback	on_error_cb_
	Error callback.
std::mutex	callback_mutex_
	Callback mutex.
std::shared_ptr< security::access_control_manager >	access_control_
	Access control manager for RBAC.
std::atomic< bool >	access_control_enabled_ {false}
	Whether access control is enabled.
std::mutex	acl_mutex_
	Access control mutex.

Detailed Description

DICOM server using network_system's messaging_server for connection management.

This class provides the same functionality as dicom_server but uses network_system's messaging_server for TCP connection management. Key benefits include:

• No manual thread management: Accept loop and I/O handled by ASIO internally
• Built-in session tracking: Automatic cleanup on disconnect
• TLS support: Ready for secure DICOM (future enhancement)
• Proven scalability: ASIO's async model for efficient connection handling

Architecture

dicom_server_v2
  └── messaging_server (network_system)
        └── messaging_session (per connection)
              └── dicom_association_handler (DICOM protocol)
                    └── scp_service (DIMSE handling)

Thread Safety

All public methods are thread-safe. The server uses internal mutexes to protect shared state and delegates I/O operations to network_system's thread model.

Migration Path

This class is API-compatible with dicom_server. To migrate:

1. Replace dicom_server with dicom_server_v2
2. No changes needed to service registration or callbacks
3. Feature flag: PACS_USE_NETWORK_SYSTEM_SERVER (when available)

Definition at line 116 of file dicom_server_v2.h.

Member Typedef Documentation

association_closed_callback

using kcenon::pacs::network::v2::dicom_server_v2::association_closed_callback

Initial value:

 
        std::function<void(const std::string& session_id, bool graceful)>

Callback type for association closed events.

Definition at line 133 of file dicom_server_v2.h.

association_established_callback

using kcenon::pacs::network::v2::dicom_server_v2::association_established_callback

Initial value:

 
        std::function<void(const std::string& session_id,
                           const std::string& calling_ae,
                           const std::string& called_ae)>

Callback type for association established events.

Definition at line 127 of file dicom_server_v2.h.

clock

using kcenon::pacs::network::v2::dicom_server_v2::clock = std::chrono::steady_clock

Definition at line 122 of file dicom_server_v2.h.

duration

using kcenon::pacs::network::v2::dicom_server_v2::duration = std::chrono::milliseconds

Definition at line 123 of file dicom_server_v2.h.

error_callback

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

Callback type for error events.

Definition at line 137 of file dicom_server_v2.h.

time_point

using kcenon::pacs::network::v2::dicom_server_v2::time_point = clock::time_point

Definition at line 124 of file dicom_server_v2.h.

Constructor & Destructor Documentation

dicom_server_v2() [1/3]

kcenon::pacs::network::v2::dicom_server_v2::dicom_server_v2 ( const server_config & config )

explicit

Construct server with configuration.

Parameters

config

Server configuration

Definition at line 37 of file dicom_server_v2.cpp.

    : config_(config) {
    stats_.start_time = clock::now();
    stats_.last_activity = stats_.start_time;
}

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

~dicom_server_v2()

kcenon::pacs::network::v2::dicom_server_v2::~dicom_server_v2

(

)

Destructor (stops server if running)

Definition at line 43 of file dicom_server_v2.cpp.

                                  {
    try {
        if (running_) {
            stop();
        }
    } catch (...) {
        // Suppress exceptions in destructor to prevent std::terminate
    }
}

References running_, and stop().

Here is the call graph for this function:

dicom_server_v2() [2/3]

kcenon::pacs::network::v2::dicom_server_v2::dicom_server_v2 ( const dicom_server_v2 & )

delete

dicom_server_v2() [3/3]

kcenon::pacs::network::v2::dicom_server_v2::dicom_server_v2 ( dicom_server_v2 && )

delete

Member Function Documentation

active_associations()

size_t kcenon::pacs::network::v2::dicom_server_v2::active_associations ( ) const

nodiscardnoexcept

Get number of active associations.

Returns

Current number of active DICOM associations

Definition at line 287 of file dicom_server_v2.cpp.

                                                           {
    std::lock_guard<std::mutex> lock(handlers_mutex_);
    return handlers_.size();
}

References handlers_, and handlers_mutex_.

Referenced by get_statistics().

Here is the caller graph for this function:

build_service_map()

dicom_association_handler::service_map kcenon::pacs::network::v2::dicom_server_v2::build_service_map ( ) const

nodiscardprivate

Build service map from registered services.

Definition at line 562 of file dicom_server_v2.cpp.

                                                                              {
    std::lock_guard<std::mutex> lock(services_mutex_);
    return sop_class_to_service_;
}

References services_mutex_, and sop_class_to_service_.

Referenced by create_handler().

Here is the caller graph for this function:

check_idle_timeouts()

void kcenon::pacs::network::v2::dicom_server_v2::check_idle_timeouts ( )

private

Check for idle timeouts on handlers.

Definition at line 529 of file dicom_server_v2.cpp.

                                          {
    if (config_.idle_timeout.count() == 0) {
        return;  // No timeout configured
    }
 
    auto now = clock::now();
    std::vector<std::string> timed_out;
 
    {
        std::lock_guard<std::mutex> lock(handlers_mutex_);
        for (const auto& [session_id, handler] : handlers_) {
            auto idle_duration = std::chrono::duration_cast<std::chrono::seconds>(
                now - handler->last_activity());
 
            if (idle_duration >= config_.idle_timeout) {
                timed_out.push_back(session_id);
            }
        }
    }
 
    // Stop timed-out handlers
    for (const auto& session_id : timed_out) {
        auto handler = find_handler(session_id);
        if (handler) {
            handler->stop(false);  // Force abort
        }
    }
}

References config_, find_handler(), handlers_, handlers_mutex_, and kcenon::pacs::network::server_config::idle_timeout.

Here is the call graph for this function:

config()

const server_config & kcenon::pacs::network::v2::dicom_server_v2::config ( ) const

nodiscardnoexcept

Get server configuration.

Returns

Reference to current configuration

Definition at line 299 of file dicom_server_v2.cpp.

                                                            {
    return config_;
}

References config_.

create_handler()

void kcenon::pacs::network::v2::dicom_server_v2::create_handler ( std::shared_ptr< kcenon::network::interfaces::i_session > session )

private

Create and register a new handler for a session.

Definition at line 424 of file dicom_server_v2.cpp.

                                                             {
 
#ifdef PACS_WITH_NETWORK_SYSTEM
    const std::string session_id(session->id());
#else
    const std::string session_id;
    (void)session;
#endif
 
    // Build service map for handler
    auto service_map = build_service_map();
 
    // Create handler
    auto handler = std::make_shared<dicom_association_handler>(
        std::move(session), config_, service_map);
 
    // Set up access control if configured
    {
        std::lock_guard<std::mutex> acl_lock(acl_mutex_);
        if (access_control_) {
            handler->set_access_control(access_control_);
            handler->set_access_control_enabled(access_control_enabled_);
        }
    }
 
    // Set up handler callbacks
    auto weak_this = std::weak_ptr<dicom_server_v2*>(
        std::shared_ptr<dicom_server_v2*>(nullptr, [](dicom_server_v2**) {}));
    // Note: We can't use shared_from_this() since dicom_server_v2 doesn't inherit
    // from enable_shared_from_this. Instead, capture 'this' directly since the
    // handler's lifetime is bounded by the server's lifetime.
 
    handler->set_established_callback(
        [this](const std::string& sid, const std::string& calling_ae,
               const std::string& called_ae) {
            // Update statistics
            {
                std::lock_guard<std::mutex> lock(stats_mutex_);
                stats_.total_associations++;
                stats_.last_activity = clock::now();
            }
 
            // Forward to user callback
            {
                std::lock_guard<std::mutex> lock(callback_mutex_);
                if (on_established_cb_) {
                    on_established_cb_(sid, calling_ae, called_ae);
                }
            }
        });
 
    handler->set_closed_callback(
        [this](const std::string& sid, bool graceful) {
            // Forward to user callback
            {
                std::lock_guard<std::mutex> lock(callback_mutex_);
                if (on_closed_cb_) {
                    on_closed_cb_(sid, graceful);
                }
            }
 
            // Remove handler from map
            remove_handler(sid);
        });
 
    handler->set_error_callback(
        [this](const std::string& /*sid*/, const std::string& error) {
            report_error(error);
        });
 
    // Register handler
    {
        std::lock_guard<std::mutex> lock(handlers_mutex_);
        handlers_[session_id] = handler;
    }
 
    // Start handler (begins processing PDUs)
    handler->start();
}

References access_control_, access_control_enabled_, acl_mutex_, build_service_map(), callback_mutex_, config_, handlers_, handlers_mutex_, kcenon::pacs::network::server_statistics::last_activity, on_closed_cb_, on_established_cb_, remove_handler(), report_error(), stats_, stats_mutex_, and kcenon::pacs::network::server_statistics::total_associations.

Referenced by on_connection().

Here is the call graph for this function:

Here is the caller graph for this function:

find_handler()

std::shared_ptr< dicom_association_handler > kcenon::pacs::network::v2::dicom_server_v2::find_handler ( const std::string & session_id ) const

nodiscardprivate

Find handler by session ID.

Definition at line 520 of file dicom_server_v2.cpp.

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

References handlers_, and handlers_mutex_.

Referenced by check_idle_timeouts(), on_disconnection(), on_network_error(), and on_receive().

Here is the caller graph for this function:

get_access_control()

std::shared_ptr< security::access_control_manager > kcenon::pacs::network::v2::dicom_server_v2::get_access_control ( ) const

nodiscardnoexcept

Get the access control manager.

Returns

Shared pointer to access control manager, or nullptr if not set

Definition at line 588 of file dicom_server_v2.cpp.

                                                   {
    std::lock_guard<std::mutex> lock(acl_mutex_);
    return access_control_;
}

References access_control_, and acl_mutex_.

get_statistics()

server_statistics kcenon::pacs::network::v2::dicom_server_v2::get_statistics ( ) const

nodiscard

Get server statistics.

Returns

Current server statistics

Definition at line 292 of file dicom_server_v2.cpp.

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

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

Here is the call graph for this function:

is_access_control_enabled()

bool kcenon::pacs::network::v2::dicom_server_v2::is_access_control_enabled ( ) const

nodiscardnoexcept

Check if access control is enabled.

Returns

true if access control is enforced

Definition at line 597 of file dicom_server_v2.cpp.

                                                               {
    return access_control_enabled_;
}

References access_control_enabled_.

is_running()

bool kcenon::pacs::network::v2::dicom_server_v2::is_running ( ) const

nodiscardnoexcept

Check if server is running.

Returns

true if server is accepting connections

Definition at line 283 of file dicom_server_v2.cpp.

                                                {
    return running_;
}

References running_.

on_association_closed()

void kcenon::pacs::network::v2::dicom_server_v2::on_association_closed

(

association_closed_callback

callback

)

Set callback for association closed events.

Parameters

callback

Function to call when an association is closed

Definition at line 312 of file dicom_server_v2.cpp.

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

References callback_mutex_, and on_closed_cb_.

on_association_established()

void kcenon::pacs::network::v2::dicom_server_v2::on_association_established

(

association_established_callback

callback

)

Set callback for association established events.

Parameters

callback

Function to call when an association is established

Definition at line 307 of file dicom_server_v2.cpp.

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

References callback_mutex_, and on_established_cb_.

on_connection()

void kcenon::pacs::network::v2::dicom_server_v2::on_connection ( std::shared_ptr< kcenon::network::interfaces::i_session > session )

private

Handle new connection from server.

Definition at line 326 of file dicom_server_v2.cpp.

                                                             {
 
    if (!running_ || !session) {
        return;
    }
 
    // Check max associations limit
    {
        std::lock_guard<std::mutex> lock(handlers_mutex_);
        if (config_.max_associations > 0 &&
            handlers_.size() >= config_.max_associations) {
            // Reject due to resource limit
            report_error("Max associations limit reached, rejecting connection");
 
            std::lock_guard<std::mutex> stats_lock(stats_mutex_);
            stats_.rejected_associations++;
 
#ifdef PACS_WITH_NETWORK_SYSTEM
            session->close();
#endif
            return;
        }
    }
 
    // Create handler for this session
    create_handler(std::move(session));
}

References config_, create_handler(), handlers_, handlers_mutex_, kcenon::pacs::network::server_config::max_associations, kcenon::pacs::network::server_statistics::rejected_associations, report_error(), running_, stats_, and stats_mutex_.

Referenced by start().

Here is the call graph for this function:

Here is the caller graph for this function:

on_disconnection()

void kcenon::pacs::network::v2::dicom_server_v2::on_disconnection ( std::string_view session_id )

private

Handle disconnection notification.

Definition at line 355 of file dicom_server_v2.cpp.

                                                                {
    // Skip if server is shutting down
    if (!running_) {
        return;
    }
 
    std::string sid(session_id);
 
    // Notify handler of disconnection before removing it
    auto handler = find_handler(sid);
    if (handler) {
        handler->handle_disconnect();
    }
 
    // Remove handler for this session
    remove_handler(sid);
}

References find_handler(), remove_handler(), and running_.

Referenced by start().

Here is the call graph for this function:

Here is the caller graph for this function:

on_error()

void kcenon::pacs::network::v2::dicom_server_v2::on_error

(

error_callback

callback

)

Set callback for error events.

Parameters

callback

Function to call on server errors

Definition at line 317 of file dicom_server_v2.cpp.

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

References callback_mutex_, and on_error_cb_.

on_network_error()

void kcenon::pacs::network::v2::dicom_server_v2::on_network_error ( std::string_view session_id, std::error_code ec )

private

Handle network error.

Definition at line 394 of file dicom_server_v2.cpp.

                      {
 
    // Skip if server is shutting down
    if (!running_) {
        return;
    }
 
    std::string sid(session_id);
 
    std::ostringstream oss;
    oss << "Network error on session " << sid
        << ": " << ec.message() << " (" << ec.value() << ")";
    report_error(oss.str());
 
    // Notify handler of the error
    auto handler = find_handler(sid);
    if (handler) {
        handler->handle_error(ec);
    }
 
    // Remove the handler - it will clean itself up
    remove_handler(sid);
}

References find_handler(), remove_handler(), report_error(), and running_.

Referenced by start().

Here is the call graph for this function:

Here is the caller graph for this function:

on_receive()

void kcenon::pacs::network::v2::dicom_server_v2::on_receive ( std::string_view session_id, const std::vector< uint8_t > & data )

private

Handle receive data (forwarded to handler)

Definition at line 373 of file dicom_server_v2.cpp.

                                    {
 
    std::string sid(session_id);
 
    // Find handler and forward data
    auto handler = find_handler(sid);
    if (handler) {
        // Forward data to handler for PDU processing
        handler->feed_data(data);
 
        // Update statistics
        {
            std::lock_guard<std::mutex> lock(stats_mutex_);
            stats_.bytes_received += data.size();
            stats_.last_activity = clock::now();
        }
    }
}

References kcenon::pacs::network::server_statistics::bytes_received, find_handler(), kcenon::pacs::network::server_statistics::last_activity, stats_, and stats_mutex_.

Referenced by start().

Here is the call graph for this function:

Here is the caller graph for this function:

operator=() [1/2]

dicom_server_v2 & kcenon::pacs::network::v2::dicom_server_v2::operator= ( const dicom_server_v2 & )

delete

operator=() [2/2]

dicom_server_v2 & kcenon::pacs::network::v2::dicom_server_v2::operator= ( dicom_server_v2 && )

delete

register_service()

void kcenon::pacs::network::v2::dicom_server_v2::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 57 of file dicom_server_v2.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_handler()

void kcenon::pacs::network::v2::dicom_server_v2::remove_handler ( const std::string & session_id )

private

Remove handler by session ID.

Definition at line 505 of file dicom_server_v2.cpp.

                                                                {
    // Skip if server is shutting down - handlers are cleaned up in stop()
    if (!running_) {
        return;
    }
 
    std::lock_guard<std::mutex> lock(handlers_mutex_);
    auto it = handlers_.find(session_id);
    if (it != handlers_.end()) {
        // Handler cleans itself up via stop() in destructor
        handlers_.erase(it);
    }
}

References handlers_, handlers_mutex_, and running_.

Referenced by create_handler(), on_disconnection(), and on_network_error().

Here is the caller graph for this function:

report_error()

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

private

Report error through callback.

Definition at line 567 of file dicom_server_v2.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 create_handler(), on_connection(), and on_network_error().

Here is the caller graph for this function:

set_access_control()

void kcenon::pacs::network::v2::dicom_server_v2::set_access_control

(

std::shared_ptr< security::access_control_manager >

acm

)

Set the access control manager for RBAC.

When set, the server will validate permissions before allowing DICOM operations. If not set, all operations are allowed.

Parameters

acm	Shared pointer to access control manager

Note

Should be set before calling start()

Definition at line 578 of file dicom_server_v2.cpp.

                                                       {
    std::lock_guard<std::mutex> lock(acl_mutex_);
    access_control_ = std::move(acm);
    if (access_control_) {
        access_control_enabled_ = true;
    }
}

References access_control_, access_control_enabled_, and acl_mutex_.

set_access_control_enabled()

void kcenon::pacs::network::v2::dicom_server_v2::set_access_control_enabled

(

bool

enabled

)

Enable or disable access control enforcement.

Parameters

enabled

If true, access control is enforced; if false, all operations allowed

Definition at line 593 of file dicom_server_v2.cpp.

                                                             {
    access_control_enabled_ = enabled;
}

References access_control_enabled_.

start()

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

nodiscard

Start the server.

Binds to the configured port and begins accepting connections using network_system's messaging_server.

Returns

Success or error with description

Definition at line 89 of file dicom_server_v2.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;
    }
 
#ifdef PACS_WITH_NETWORK_SYSTEM
    try {
        // Create TCP server via tcp_facade
        kcenon::network::facade::tcp_facade facade;
        kcenon::network::facade::tcp_facade::server_config srv_cfg;
        srv_cfg.server_id = config_.ae_title;
        srv_cfg.port = config_.port;
        // Handle both old API (returns shared_ptr) and new API (returns Result<shared_ptr>)
        server_ = [](auto raw) -> std::shared_ptr<kcenon::network::interfaces::i_protocol_server> {
            if constexpr (requires { raw.is_err(); raw.value(); }) {
                if (raw.is_err()) throw std::runtime_error("Failed to create server");
                return std::move(raw.value());
            } else {
                return std::move(raw);
            }
        }(facade.create_server(srv_cfg));
 
        // Set up server-level callbacks
        server_->set_connection_callback(
            [this](std::shared_ptr<kcenon::network::interfaces::i_session> session) {
                on_connection(std::move(session));
            });
 
        server_->set_disconnection_callback(
            [this](std::string_view session_id) {
                on_disconnection(session_id);
            });
 
        server_->set_receive_callback(
            [this](std::string_view session_id,
                   const std::vector<uint8_t>& data) {
                on_receive(session_id, data);
            });
 
        server_->set_error_callback(
            [this](std::string_view session_id,
                   std::error_code ec) {
                on_network_error(session_id, ec);
            });
 
        // Start the server on configured port
        auto result = server_->start(config_.port);
        if (result.is_err()) {
            running_ = false;
            server_.reset();
            return error_info("Failed to start server");
        }
 
        return std::monostate{};
    } catch (const std::exception& e) {
        running_ = false;
        if (server_) {
            server_.reset();
        }
        return error_info(std::string("Exception during server start: ") + e.what());
    } catch (...) {
        running_ = false;
        if (server_) {
            server_.reset();
        }
        return error_info("Unknown exception during server start");
    }
#else
    running_ = false;
    return error_info("dicom_server_v2 requires PACS_WITH_NETWORK_SYSTEM");
#endif
}

References kcenon::pacs::network::server_statistics::active_associations, kcenon::pacs::network::server_config::ae_title, kcenon::pacs::network::AE_TITLE_LENGTH, kcenon::pacs::network::server_statistics::bytes_received, kcenon::pacs::network::server_statistics::bytes_sent, config_, kcenon::pacs::network::server_statistics::last_activity, kcenon::pacs::network::server_statistics::messages_processed, on_connection(), on_disconnection(), on_network_error(), on_receive(), kcenon::pacs::network::server_config::port, kcenon::pacs::network::server_statistics::rejected_associations, running_, server_, services_, services_mutex_, kcenon::pacs::network::server_statistics::start_time, stats_, stats_mutex_, and kcenon::pacs::network::server_statistics::total_associations.

Here is the call graph for this function:

stop()

void kcenon::pacs::network::v2::dicom_server_v2::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 200 of file dicom_server_v2.cpp.

                                           {
    if (!running_.exchange(false)) {
        return;  // Already stopped
    }
 
#ifdef PACS_WITH_NETWORK_SYSTEM
    // Phase 1: Stop accepting new connections
    if (server_) {
        try {
            // Stop the server - this closes the acceptor
            (void)server_->stop();
        } catch (...) {
            // Suppress exceptions during server stop
        }
    }
 
    // Phase 2: Wait for handlers to complete gracefully
    auto deadline = clock::now() + timeout;
    {
        std::unique_lock<std::mutex> lock(handlers_mutex_);
        while (!handlers_.empty() && clock::now() < deadline) {
            // Release lock while waiting
            lock.unlock();
            std::this_thread::sleep_for(std::chrono::milliseconds{100});
            lock.lock();
        }
    }
 
    // Phase 3: Force stop remaining handlers
    // Collect handlers first, then stop them without holding the lock
    // to avoid potential deadlock if handler->stop() triggers callbacks
    std::vector<std::shared_ptr<dicom_association_handler>> handlers_to_stop;
    {
        std::lock_guard<std::mutex> lock(handlers_mutex_);
        handlers_to_stop.reserve(handlers_.size());
        for (auto& [session_id, handler] : handlers_) {
            handlers_to_stop.push_back(handler);
        }
        handlers_.clear();
    }
 
    // Stop handlers without holding the lock
    for (auto& handler : handlers_to_stop) {
        try {
            handler->stop(false);  // Force abort
        } catch (...) {
            // Suppress exceptions during handler stop
        }
    }
    handlers_to_stop.clear();
 
    // Allow any pending callbacks to complete
    std::this_thread::sleep_for(std::chrono::milliseconds{50});
 
    // Clear callbacks to break reference cycles before server is destroyed.
    // The server object itself is kept alive until dicom_server_v2 is destroyed
    // to avoid use-after-free in the adapter's background I/O threads.
    if (server_) {
        server_->set_connection_callback(nullptr);
        server_->set_disconnection_callback(nullptr);
        server_->set_receive_callback(nullptr);
        server_->set_error_callback(nullptr);
    }
#else
    (void)timeout;  // Unused without network_system
#endif
 
    // Notify shutdown waiters
    {
        std::lock_guard<std::mutex> lock(shutdown_mutex_);
        shutdown_cv_.notify_all();
    }
}

References handlers_, handlers_mutex_, running_, server_, shutdown_cv_, and shutdown_mutex_.

Referenced by ~dicom_server_v2().

Here is the caller graph for this function:

supported_sop_classes()

std::vector< std::string > kcenon::pacs::network::v2::dicom_server_v2::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 72 of file dicom_server_v2.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.

wait_for_shutdown()

void kcenon::pacs::network::v2::dicom_server_v2::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 274 of file dicom_server_v2.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

access_control_

std::shared_ptr<security::access_control_manager> kcenon::pacs::network::v2::dicom_server_v2::access_control_

private

Access control manager for RBAC.

Definition at line 396 of file dicom_server_v2.h.

Referenced by create_handler(), get_access_control(), and set_access_control().

access_control_enabled_

std::atomic<bool> kcenon::pacs::network::v2::dicom_server_v2::access_control_enabled_ {false}

private

Whether access control is enabled.

Definition at line 399 of file dicom_server_v2.h.

{false};

Referenced by create_handler(), is_access_control_enabled(), set_access_control(), and set_access_control_enabled().

acl_mutex_

std::mutex kcenon::pacs::network::v2::dicom_server_v2::acl_mutex_

mutableprivate

Access control mutex.

Definition at line 402 of file dicom_server_v2.h.

Referenced by create_handler(), get_access_control(), and set_access_control().

callback_mutex_

std::mutex kcenon::pacs::network::v2::dicom_server_v2::callback_mutex_

mutableprivate

Callback mutex.

Definition at line 393 of file dicom_server_v2.h.

Referenced by create_handler(), on_association_closed(), on_association_established(), on_error(), and report_error().

config_

server_config kcenon::pacs::network::v2::dicom_server_v2::config_

private

Server configuration.

Definition at line 348 of file dicom_server_v2.h.

Referenced by check_idle_timeouts(), config(), create_handler(), on_connection(), and start().

handlers_

std::unordered_map<std::string, std::shared_ptr<dicom_association_handler> > kcenon::pacs::network::v2::dicom_server_v2::handlers_

private

Active association handlers (keyed by session ID)

Definition at line 360 of file dicom_server_v2.h.

Referenced by active_associations(), check_idle_timeouts(), create_handler(), find_handler(), on_connection(), remove_handler(), and stop().

handlers_mutex_

std::mutex kcenon::pacs::network::v2::dicom_server_v2::handlers_mutex_

mutableprivate

Handler mutex (protects handlers_ map)

Definition at line 369 of file dicom_server_v2.h.

Referenced by active_associations(), check_idle_timeouts(), create_handler(), find_handler(), on_connection(), remove_handler(), and stop().

on_closed_cb_

association_closed_callback kcenon::pacs::network::v2::dicom_server_v2::on_closed_cb_

private

Association closed callback.

Definition at line 387 of file dicom_server_v2.h.

Referenced by create_handler(), and on_association_closed().

on_error_cb_

error_callback kcenon::pacs::network::v2::dicom_server_v2::on_error_cb_

private

Error callback.

Definition at line 390 of file dicom_server_v2.h.

Referenced by on_error(), and report_error().

on_established_cb_

association_established_callback kcenon::pacs::network::v2::dicom_server_v2::on_established_cb_

private

Association established callback.

Definition at line 384 of file dicom_server_v2.h.

Referenced by create_handler(), and on_association_established().

running_

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

private

Running flag.

Definition at line 366 of file dicom_server_v2.h.

{false};

Referenced by is_running(), on_connection(), on_disconnection(), on_network_error(), remove_handler(), start(), stop(), wait_for_shutdown(), and ~dicom_server_v2().

server_

std::shared_ptr<kcenon::network::interfaces::i_protocol_server> kcenon::pacs::network::v2::dicom_server_v2::server_

private

network_system's protocol server (via tcp_facade)

Definition at line 351 of file dicom_server_v2.h.

Referenced by start(), and stop().

services_

std::vector<services::scp_service_ptr> kcenon::pacs::network::v2::dicom_server_v2::services_

private

Registered SCP services.

Definition at line 354 of file dicom_server_v2.h.

Referenced by register_service(), and start().

services_mutex_

std::mutex kcenon::pacs::network::v2::dicom_server_v2::services_mutex_

mutableprivate

Service mutex (protects services_ and sop_class_to_service_)

Definition at line 372 of file dicom_server_v2.h.

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

shutdown_cv_

std::condition_variable kcenon::pacs::network::v2::dicom_server_v2::shutdown_cv_

private

Shutdown condition variable.

Definition at line 378 of file dicom_server_v2.h.

Referenced by stop(), and wait_for_shutdown().

shutdown_mutex_

std::mutex kcenon::pacs::network::v2::dicom_server_v2::shutdown_mutex_

private

Shutdown mutex.

Definition at line 381 of file dicom_server_v2.h.

Referenced by stop(), and wait_for_shutdown().

sop_class_to_service_

std::map<std::string, services::scp_service*> kcenon::pacs::network::v2::dicom_server_v2::sop_class_to_service_

private

Map from SOP Class UID to service (non-owning pointers)

Definition at line 357 of file dicom_server_v2.h.

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

stats_

server_statistics kcenon::pacs::network::v2::dicom_server_v2::stats_

mutableprivate

Server statistics.

Definition at line 363 of file dicom_server_v2.h.

Referenced by create_handler(), dicom_server_v2(), get_statistics(), on_connection(), on_receive(), and start().

stats_mutex_

std::mutex kcenon::pacs::network::v2::dicom_server_v2::stats_mutex_

mutableprivate

Statistics mutex.

Definition at line 375 of file dicom_server_v2.h.

Referenced by create_handler(), get_statistics(), on_connection(), on_receive(), and start().

---

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

• include/kcenon/pacs/network/v2/dicom_server_v2.h
• src/network/v2/dicom_server_v2.cpp