Adapter for integrating network_system for DICOM protocol. More...

#include <network_adapter.h>

Collaboration diagram for kcenon::pacs::integration::network_adapter:

Public Types
using	session_ptr = std::shared_ptr<dicom_session>
	Session pointer type.

using	connection_callback = std::function<void(session_ptr)>
	Connection callback type.

using	disconnection_callback = std::function<void(const std::string&)>
	Disconnection callback type.

using	error_callback = std::function<void(session_ptr, std::error_code)>
	Error callback type.

Static Public Member Functions
static std::unique_ptr< network::dicom_server >	create_server (const network::server_config &config, const tls_config &tls_cfg={})
	Create a DICOM server using network_system.

static Result< session_ptr >	connect (const connection_config &config)

static Result< session_ptr >	connect (const std::string &host, uint16_t port, std::chrono::milliseconds timeout=std::chrono::seconds{30})
	Connect to a remote DICOM peer (simplified overload)

static Result< std::monostate >	configure_tls (const tls_config &config)

static session_ptr	wrap_session (std::shared_ptr< network_system::session::messaging_session > session)
	Wrap a network_system session for DICOM communication.

static session_ptr	wrap_session (std::shared_ptr< network_system::session::secure_session > session)
	Wrap a secure network_system session for DICOM communication.

static session_ptr	wrap_session (std::shared_ptr< kcenon::network::interfaces::i_session > session)
	Wrap a public i_session interface for DICOM communication.

Private Member Functions
	network_adapter ()=delete

	~network_adapter ()=delete

	network_adapter (const network_adapter &)=delete

network_adapter &	operator= (const network_adapter &)=delete

Detailed Description

Adapter for integrating network_system for DICOM protocol.

This class provides a PACS-specific interface to network_system's TCP server and client functionality. Key features include:

Server Creation: Create DICOM servers using network_system's messaging_server
Client Connection: Connect to remote DICOM peers with timeout support
TLS Support: Optional TLS 1.2/1.3 for DICOM secure transport
Session Management: Wrap network sessions for DICOM PDU handling

Thread Safety: All public methods are thread-safe and can be called from any thread.

Definition at line 223 of file network_adapter.h.

Member Typedef Documentation

◆ connection_callback

using kcenon::pacs::integration::network_adapter::connection_callback = std::function<void(session_ptr)>

Connection callback type.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/network_adapter.h.

Definition at line 233 of file network_adapter.h.

◆ disconnection_callback

using kcenon::pacs::integration::network_adapter::disconnection_callback = std::function<void(const std::string&)>

Disconnection callback type.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/network_adapter.h.

Definition at line 236 of file network_adapter.h.

◆ error_callback

using kcenon::pacs::integration::network_adapter::error_callback = std::function<void(session_ptr, std::error_code)>

Error callback type.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/network_adapter.h.

Definition at line 239 of file network_adapter.h.

◆ session_ptr

using kcenon::pacs::integration::network_adapter::session_ptr = std::shared_ptr<dicom_session>

Session pointer type.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/di/test_support.h, and /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/network_adapter.h.

Definition at line 230 of file network_adapter.h.

Constructor & Destructor Documentation

◆ network_adapter() [1/2]

kcenon::pacs::integration::network_adapter::network_adapter ( )

privatedelete

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/network_adapter.h.

◆ ~network_adapter()

kcenon::pacs::integration::network_adapter::~network_adapter ( )

privatedelete

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/network_adapter.h.

◆ network_adapter() [2/2]

kcenon::pacs::integration::network_adapter::network_adapter ( const network_adapter & )

privatedelete

Member Function Documentation

◆ configure_tls()

Result< std::monostate > kcenon::pacs::integration::network_adapter::configure_tls ( const tls_config & config )

staticnodiscard

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/network_adapter.h.

Definition at line 163 of file network_adapter.cpp.

                                                       {
    if (!config.enabled) {
        return Result<std::monostate>(std::monostate{});
    }
 
    // Validate certificate path
    if (!std::filesystem::exists(config.cert_path)) {
        return Result<std::monostate>(error_info(
            "TLS configuration error: certificate file not found: " +
            config.cert_path.string()));
    }
 
    // Validate key path
    if (!std::filesystem::exists(config.key_path)) {
        return Result<std::monostate>(error_info(
            "TLS configuration error: key file not found: " +
            config.key_path.string()));
    }
 
    // Validate CA path if specified
    if (!config.ca_path.empty() && !std::filesystem::exists(config.ca_path)) {
        return Result<std::monostate>(error_info(
            "TLS configuration error: CA certificate file not found: " +
            config.ca_path.string()));
    }
 
    // TLS version validation
    if (config.min_version != tls_config::tls_version::v1_2 &&
        config.min_version != tls_config::tls_version::v1_3) {
        return Result<std::monostate>(error_info(
            "TLS configuration error: unsupported TLS version"));
    }
 
    return Result<std::monostate>(std::monostate{});
}

References kcenon::pacs::integration::tls_config::ca_path, kcenon::pacs::integration::tls_config::cert_path, kcenon::pacs::integration::tls_config::enabled, kcenon::pacs::integration::tls_config::key_path, kcenon::pacs::integration::tls_config::min_version, kcenon::pacs::integration::tls_config::v1_2, and kcenon::pacs::integration::tls_config::v1_3.

◆ connect() [1/2]

Result< network_adapter::session_ptr > kcenon::pacs::integration::network_adapter::connect ( const connection_config & config )

staticnodiscard

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/network_adapter.h.

Definition at line 53 of file network_adapter.cpp.

                                                        {
    // Validate configuration
    if (config.host.empty()) {
        return Result<session_ptr>(error_info("Connection failed: empty host"));
    }
 
    if (config.port == 0) {
        return Result<session_ptr>(error_info("Connection failed: invalid port"));
    }
 
    // Validate TLS configuration if enabled
    if (config.tls.enabled && !config.tls.is_valid()) {
        return Result<session_ptr>(error_info("Connection failed: invalid TLS configuration"));
    }
 
    try {
        // Create TCP client via tcp_facade
        kcenon::network::facade::tcp_facade facade;
        kcenon::network::facade::tcp_facade::client_config client_cfg;
        client_cfg.host = config.host;
        client_cfg.port = config.port;
        client_cfg.client_id = "pacs_client";
        client_cfg.timeout = config.timeout;
        client_cfg.use_ssl = config.tls.enabled;
        if (config.tls.enabled && !config.tls.ca_path.empty()) {
            client_cfg.ca_cert_path = config.tls.ca_path.string();
        }
        client_cfg.verify_certificate = config.tls.verify_peer;
 
        // Handle both old API (returns shared_ptr) and new API (returns Result<shared_ptr>)
        auto client = [](auto raw) -> std::shared_ptr<kcenon::network::interfaces::i_protocol_client> {
            if constexpr (requires { raw.is_err(); raw.value(); }) {
                return raw.is_err() ? nullptr : std::move(raw.value());
            } else {
                return std::move(raw);
            }
        }(facade.create_client(client_cfg));
        if (!client) {
            return Result<session_ptr>(error_info("Connection failed: could not create client"));
        }
 
        // Set up promise/future for synchronous connection
        std::promise<std::error_code> connect_promise;
        auto connect_future = connect_promise.get_future();
 
        // Use deprecated callbacks for synchronous connect pattern
        // (observer pattern would be preferred for long-lived clients)
#if defined(__clang__) || defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
        client->set_connected_callback([&connect_promise]() {
            connect_promise.set_value(std::error_code{});
        });
 
        client->set_error_callback([&connect_promise](std::error_code ec) {
            try {
                connect_promise.set_value(ec);
            } catch (const std::future_error&) {
                // Promise already satisfied
            }
        });
#if defined(__clang__) || defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
 
        // Start connection
        auto start_result = client->start(config.host, config.port);
        if (start_result.is_err()) {
            return Result<session_ptr>(error_info("Connection failed: unable to start client"));
        }
 
        // Wait for connection with timeout
        auto status = connect_future.wait_for(config.timeout);
        if (status == std::future_status::timeout) {
            (void)client->stop();
            return Result<session_ptr>(error_info("Connection failed: timeout"));
        }
 
        // Check connection result
        auto ec = connect_future.get();
        if (ec) {
            (void)client->stop();
            return Result<session_ptr>(error_info("Connection failed: " + ec.message()));
        }
 
        // Connection successful but client-based session wrapping
        // is not yet fully implemented for the public API
        return Result<session_ptr>(error_info("Connection not yet fully implemented"));
 
    } catch (const std::exception& e) {
        return Result<session_ptr>(
            error_info(std::string("Connection failed: ") + e.what()));
    }
}

References kcenon::pacs::integration::tls_config::ca_path, kcenon::pacs::integration::tls_config::enabled, kcenon::pacs::integration::connection_config::host, kcenon::pacs::integration::tls_config::is_valid(), kcenon::pacs::integration::connection_config::port, kcenon::pacs::integration::connection_config::timeout, kcenon::pacs::integration::connection_config::tls, and kcenon::pacs::integration::tls_config::verify_peer.

Referenced by kcenon::pacs::di::DicomNetworkService::connect(), and connect().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ connect() [2/2]

Result< network_adapter::session_ptr > kcenon::pacs::integration::network_adapter::connect	(	const std::string &	host,
		uint16_t	port,
		std::chrono::milliseconds	timeout = std::chrono::seconds{30} )

staticnodiscard

Connect to a remote DICOM peer (simplified overload)

Parameters

host	Remote host address
port	Remote port
timeout	Connection timeout

Returns: Result containing session on success, or error message

Definition at line 150 of file network_adapter.cpp.

                                                        {
    connection_config config{host, port};
    config.timeout = timeout;
    return connect(config);
}

References connect(), and kcenon::pacs::integration::connection_config::timeout.

Here is the call graph for this function:

◆ create_server()

std::unique_ptr< network::dicom_server > kcenon::pacs::integration::network_adapter::create_server	(	const network::server_config &	config,
		const tls_config &	tls_cfg = {} )

staticnodiscard

Create a DICOM server using network_system.

Creates and configures a network_system messaging_server (or secure_messaging_server if TLS is enabled) for DICOM communication.

Parameters

config	Server configuration
tls_cfg	Optional TLS configuration

Returns: Unique pointer to dicom_server, or nullptr on failure

Note: The returned server is not started; call start() to begin accepting

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/network_adapter.h.

Definition at line 27 of file network_adapter.cpp.

                                                          {
    // Validate configuration
    if (config.ae_title.empty()) {
        return nullptr;
    }
 
    if (config.port == 0) {
        return nullptr;
    }
 
    // Validate TLS configuration if enabled
    if (tls_cfg.enabled && !tls_cfg.is_valid()) {
        return nullptr;
    }
 
    // Create DICOM server with the provided configuration
    // The dicom_server internally uses network_system for TCP operations
    return std::make_unique<network::dicom_server>(config);
}

References kcenon::pacs::network::server_config::ae_title, kcenon::pacs::integration::tls_config::enabled, kcenon::pacs::integration::tls_config::is_valid(), and kcenon::pacs::network::server_config::port.

Here is the call graph for this function:

◆ operator=()

network_adapter & kcenon::pacs::integration::network_adapter::operator= ( const network_adapter & )

privatedelete

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/network_adapter.h.

◆ wrap_session() [1/3]

network_adapter::session_ptr kcenon::pacs::integration::network_adapter::wrap_session ( std::shared_ptr< kcenon::network::interfaces::i_session > session )

staticnodiscard

Wrap a public i_session interface for DICOM communication.

Parameters

session The i_session interface to wrap

Returns: Wrapped DICOM session

Definition at line 222 of file network_adapter.cpp.

                                                             {
    if (!session) {
        return nullptr;
    }
    return std::make_shared<dicom_session>(std::move(session));
}

◆ wrap_session() [2/3]

network_adapter::session_ptr kcenon::pacs::integration::network_adapter::wrap_session ( std::shared_ptr< network_system::session::messaging_session > session )

staticnodiscard

Wrap a network_system session for DICOM communication.

Creates a dicom_session wrapper around a network_system messaging_session, enabling PDU-level DICOM communication.

Parameters

session The network_system session to wrap

Returns: Wrapped DICOM session

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/network_adapter.h.

Definition at line 204 of file network_adapter.cpp.

                                                                   {
    if (!session) {
        return nullptr;
    }
    return std::make_shared<dicom_session>(std::move(session));
}

◆ wrap_session() [3/3]

network_adapter::session_ptr kcenon::pacs::integration::network_adapter::wrap_session ( std::shared_ptr< network_system::session::secure_session > session )

staticnodiscard

Wrap a secure network_system session for DICOM communication.

Parameters

session The secure network_system session to wrap

Returns: Wrapped DICOM session

Definition at line 213 of file network_adapter.cpp.

                                                                {
    if (!session) {
        return nullptr;
    }
    return std::make_shared<dicom_session>(std::move(session));
}

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

include/kcenon/pacs/integration/network_adapter.h
src/integration/network_adapter.cpp

Public Types

Static Public Member Functions

Private Member Functions

Detailed Description

Member Typedef Documentation

◆ connection_callback

◆ disconnection_callback

◆ error_callback

◆ session_ptr

Constructor & Destructor Documentation

◆ network_adapter() [1/2]

◆ ~network_adapter()

◆ network_adapter() [2/2]

Member Function Documentation

◆ configure_tls()

◆ connect() [1/2]

◆ connect() [2/2]

◆ create_server()

◆ operator=()

◆ wrap_session() [1/3]

◆ wrap_session() [2/3]

◆ wrap_session() [3/3]