#include <remote_node_manager.h>

Collaboration diagram for kcenon::pacs::client::remote_node_manager:

Classes
struct	impl

Public Member Functions
	remote_node_manager (std::shared_ptr< storage::node_repository > repo, node_manager_config config={}, std::shared_ptr< di::ILogger > logger=nullptr)
	Construct a remote node manager.

	~remote_node_manager ()
	Destructor - stops health check if running.

	remote_node_manager (const remote_node_manager &)=delete

auto	operator= (const remote_node_manager &) -> remote_node_manager &=delete

	remote_node_manager (remote_node_manager &&)=delete

auto	operator= (remote_node_manager &&) -> remote_node_manager &=delete

auto	add_node (const remote_node &node) -> kcenon::pacs::VoidResult
	Add a new remote node.

auto	update_node (const remote_node &node) -> kcenon::pacs::VoidResult
	Update an existing remote node.

auto	remove_node (std::string_view node_id) -> kcenon::pacs::VoidResult
	Remove a remote node.

auto	get_node (std::string_view node_id) const -> std::optional< remote_node >
	Get a node by ID.

auto	list_nodes () const -> std::vector< remote_node >
	List all registered nodes.

auto	list_nodes_by_status (node_status status) const -> std::vector< remote_node >
	List nodes filtered by status.

auto	verify_node (std::string_view node_id) -> kcenon::pacs::VoidResult
	Verify a node's connectivity synchronously.

auto	verify_node_async (std::string_view node_id) -> std::future< kcenon::pacs::VoidResult >
	Verify a node's connectivity asynchronously.

void	verify_all_nodes_async ()
	Verify all nodes asynchronously.

auto	acquire_association (std::string_view node_id, std::span< const std::string > sop_classes) -> kcenon::pacs::Result< std::unique_ptr< network::association > >
	Acquire an association from the pool.

void	release_association (std::string_view node_id, std::unique_ptr< network::association > assoc)
	Release an association back to the pool.

void	start_health_check ()
	Start the automatic health check scheduler.

void	stop_health_check ()
	Stop the automatic health check scheduler.

auto	is_health_check_running () const noexcept -> bool
	Check if health check is running.

auto	get_status (std::string_view node_id) const -> node_status
	Get the current status of a node.

void	set_status_callback (node_status_callback callback)
	Set the status change callback.

auto	get_statistics (std::string_view node_id) const -> node_statistics
	Get statistics for a node.

void	reset_statistics (std::string_view node_id="")
	Reset statistics for a node.

auto	config () const noexcept -> const node_manager_config &
	Get the current configuration.

void	set_config (node_manager_config new_config)
	Update the configuration.

Private Attributes
std::unique_ptr< impl >	impl_

Detailed Description

Definition at line 93 of file remote_node_manager.h.

Constructor & Destructor Documentation

◆ remote_node_manager() [1/3]

kcenon::pacs::client::remote_node_manager::remote_node_manager	(	std::shared_ptr< storage::node_repository >	repo,
		node_manager_config	config = {},
		std::shared_ptr< di::ILogger >	logger = nullptr )

explicit

Construct a remote node manager.

Parameters

repo	Repository for node persistence (required)
config	Configuration options
logger	Logger instance (optional, defaults to NullLogger)

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/remote_node_manager.h.

Definition at line 288 of file remote_node_manager.cpp.

    : impl_(std::make_unique<impl>()) {
 
    impl_->repo = std::move(repo);
    impl_->config = std::move(config);
    impl_->logger = logger ? std::move(logger) : di::null_logger();
 
    // Load existing nodes from repository
    impl_->load_nodes_from_repo();
 
    // Auto-start health check if configured
    if (impl_->config.auto_start_health_check) {
        start_health_check();
    }
}

References kcenon::pacs::client::node_manager_config::auto_start_health_check, config(), kcenon::pacs::client::remote_node_manager::impl::config, impl_, kcenon::pacs::client::remote_node_manager::impl::load_nodes_from_repo(), kcenon::pacs::client::remote_node_manager::impl::logger, kcenon::pacs::di::null_logger(), kcenon::pacs::client::remote_node_manager::impl::repo, and start_health_check().

Here is the call graph for this function:

◆ ~remote_node_manager()

kcenon::pacs::client::remote_node_manager::~remote_node_manager ( )

Destructor - stops health check if running.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/remote_node_manager.h.

Definition at line 307 of file remote_node_manager.cpp.

                                          {
    stop_health_check();
 
    // Clear connection pool
    {
        std::lock_guard<std::mutex> lock(impl_->pool_mutex);
        impl_->connection_pool.clear();
    }
}

References kcenon::pacs::client::remote_node_manager::impl::connection_pool, impl_, kcenon::pacs::client::remote_node_manager::impl::pool_mutex, and stop_health_check().

Here is the call graph for this function:

◆ remote_node_manager() [2/3]

kcenon::pacs::client::remote_node_manager::remote_node_manager ( const remote_node_manager & )

delete

◆ remote_node_manager() [3/3]

kcenon::pacs::client::remote_node_manager::remote_node_manager ( remote_node_manager && )

delete

Member Function Documentation

◆ acquire_association()

kcenon::pacs::Result< std::unique_ptr< network::association > > kcenon::pacs::client::remote_node_manager::acquire_association	(	std::string_view	node_id,
		std::span< const std::string >	sop_classes ) -> kcenon::pacs::Result<std::unique_ptr<network::association>>

nodiscard

Acquire an association from the pool.

Gets a pooled association or creates a new one if none available. The association is configured for the specified SOP classes.

Parameters

node_id	ID of the node to connect to
sop_classes	SOP Class UIDs needed for the operation

Returns: Result containing the association or error

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/remote_node_manager.h.

Definition at line 563 of file remote_node_manager.cpp.

                                          {
 
    std::string id_str(node_id);
    std::optional<remote_node> node;
 
    {
        std::lock_guard<std::mutex> lock(impl_->cache_mutex);
        auto it = impl_->node_cache.find(id_str);
        if (it != impl_->node_cache.end()) {
            node = it->second;
        }
    }
 
    if (!node) {
        return kcenon::pacs::pacs_error<std::unique_ptr<network::association>>(
            kcenon::pacs::error_codes::not_found,
            "Node not found: " + id_str);
    }
 
    // Try to get from pool
    {
        std::lock_guard<std::mutex> lock(impl_->pool_mutex);
        auto it = impl_->connection_pool.find(id_str);
        if (it != impl_->connection_pool.end() && !it->second.empty()) {
            auto pooled = std::move(it->second.front());
            it->second.pop_front();
 
            // Check if connection is still valid and not expired
            auto age = std::chrono::steady_clock::now() - pooled.acquired_at;
            if (age < impl_->config.pool_connection_ttl &&
                pooled.assoc && pooled.assoc->is_established()) {
                impl_->logger->debug_fmt("Reusing pooled association for {}", id_str);
                return kcenon::pacs::ok(std::move(pooled.assoc));
            }
        }
    }
 
    // Create new association
    network::association_config assoc_config;
    assoc_config.calling_ae_title = impl_->config.local_ae_title;
    assoc_config.called_ae_title = node->ae_title;
 
    uint8_t context_id = 1;
    for (const auto& sop_class : sop_classes) {
        assoc_config.proposed_contexts.push_back({
            context_id,
            sop_class,
            default_transfer_syntaxes
        });
        context_id += 2;  // Context IDs must be odd
    }
 
    auto connect_result = network::association::connect(
        node->host,
        node->port,
        assoc_config,
        std::chrono::duration_cast<network::association::duration>(node->connection_timeout)
    );
 
    if (connect_result.is_err()) {
        impl_->update_node_status(id_str, node_status::offline,
                                  connect_result.error().message);
        return connect_result.error();
    }
 
    // Update statistics
    {
        std::lock_guard<std::mutex> lock(impl_->stats_mutex);
        impl_->statistics[id_str].total_connections++;
        impl_->statistics[id_str].active_connections++;
    }
 
    return kcenon::pacs::ok(std::make_unique<network::association>(std::move(connect_result.value())));
}

Here is the call graph for this function:

◆ add_node()

kcenon::pacs::VoidResult kcenon::pacs::client::remote_node_manager::add_node ( const remote_node & node ) -> kcenon::pacs::VoidResult

nodiscard

Add a new remote node.

Parameters

node	The node to add

Returns: VoidResult indicating success or error

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/remote_node_manager.h.

Definition at line 321 of file remote_node_manager.cpp.

                                                                          {
    if (node.node_id.empty()) {
        return kcenon::pacs::pacs_void_error(
            kcenon::pacs::error_codes::invalid_argument,
            "Node ID cannot be empty");
    }
 
    if (node.ae_title.empty()) {
        return kcenon::pacs::pacs_void_error(
            kcenon::pacs::error_codes::invalid_argument,
            "AE Title cannot be empty");
    }
 
    if (node.host.empty()) {
        return kcenon::pacs::pacs_void_error(
            kcenon::pacs::error_codes::invalid_argument,
            "Host cannot be empty");
    }
 
    // Check for duplicate
    {
        std::lock_guard<std::mutex> lock(impl_->cache_mutex);
        if (impl_->node_cache.find(node.node_id) != impl_->node_cache.end()) {
            return kcenon::pacs::pacs_void_error(
                kcenon::pacs::error_codes::already_exists,
                "Node with ID already exists: " + node.node_id);
        }
    }
 
    // Persist to repository
    if (impl_->repo) {
#ifdef PACS_WITH_DATABASE_SYSTEM
        auto result = impl_->repo->save(node);
        if (result.is_err()) {
            return kcenon::pacs::pacs_void_error(
                result.error().code,
                "Failed to persist node: " + result.error().message);
        }
#else
        auto result = impl_->repo->upsert(node);
        if (result.is_err()) {
            return kcenon::pacs::pacs_void_error(
                result.error().code,
                "Failed to persist node: " + result.error().message);
        }
#endif
    }
 
    // Add to cache
    {
        std::lock_guard<std::mutex> lock(impl_->cache_mutex);
        impl_->node_cache[node.node_id] = node;
    }
 
    impl_->logger->info_fmt("Added remote node: {} ({}:{})",
                            node.node_id, node.host, node.port);
 
    return kcenon::pacs::ok();
}

References kcenon::pacs::client::remote_node::ae_title, kcenon::pacs::client::remote_node_manager::impl::cache_mutex, kcenon::pacs::client::remote_node::host, impl_, kcenon::pacs::client::remote_node_manager::impl::logger, kcenon::pacs::client::remote_node_manager::impl::node_cache, kcenon::pacs::client::remote_node::node_id, kcenon::pacs::pacs_void_error(), kcenon::pacs::client::remote_node::port, and kcenon::pacs::client::remote_node_manager::impl::repo.

Here is the call graph for this function:

◆ config()

const node_manager_config & kcenon::pacs::client::remote_node_manager::config ( ) const -> const node_manager_config&

nodiscardnoexcept

Get the current configuration.

Returns: Current manager configuration

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/remote_node_manager.h.

Definition at line 757 of file remote_node_manager.cpp.

                                                                      {
    return impl_->config;
}

References kcenon::pacs::client::remote_node_manager::impl::config, and impl_.

Referenced by acquire_association(), and remote_node_manager().

Here is the caller graph for this function:

◆ get_node()

std::optional< remote_node > kcenon::pacs::client::remote_node_manager::get_node ( std::string_view node_id ) const -> std::optional<remote_node>

nodiscard

Get a node by ID.

Parameters

node_id ID of the node to retrieve

Returns: Optional containing the node if found

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/remote_node_manager.h.

Definition at line 466 of file remote_node_manager.cpp.

                                                                                   {
    std::lock_guard<std::mutex> lock(impl_->cache_mutex);
    auto it = impl_->node_cache.find(std::string(node_id));
    if (it != impl_->node_cache.end()) {
        return it->second;
    }
    return std::nullopt;
}

References kcenon::pacs::client::remote_node_manager::impl::cache_mutex, impl_, and kcenon::pacs::client::remote_node_manager::impl::node_cache.

◆ get_statistics()

node_statistics kcenon::pacs::client::remote_node_manager::get_statistics ( std::string_view node_id ) const -> node_statistics

nodiscard

Get statistics for a node.

Parameters

node_id ID of the node

Returns: Statistics for the node

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/remote_node_manager.h.

Definition at line 735 of file remote_node_manager.cpp.

                                                                                {
    std::lock_guard<std::mutex> lock(impl_->stats_mutex);
    auto it = impl_->statistics.find(std::string(node_id));
    if (it != impl_->statistics.end()) {
        return it->second;
    }
    return {};
}

References impl_, kcenon::pacs::client::remote_node_manager::impl::statistics, and kcenon::pacs::client::remote_node_manager::impl::stats_mutex.

◆ get_status()

node_status kcenon::pacs::client::remote_node_manager::get_status ( std::string_view node_id ) const -> node_status

nodiscard

Get the current status of a node.

Parameters

node_id ID of the node

Returns: Current status (unknown if node not found)

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/remote_node_manager.h.

Definition at line 717 of file remote_node_manager.cpp.

                                                                        {
    std::lock_guard<std::mutex> lock(impl_->cache_mutex);
    auto it = impl_->node_cache.find(std::string(node_id));
    if (it != impl_->node_cache.end()) {
        return it->second.status;
    }
    return node_status::unknown;
}

References kcenon::pacs::client::remote_node_manager::impl::cache_mutex, impl_, kcenon::pacs::client::remote_node_manager::impl::node_cache, and kcenon::pacs::client::unknown.

◆ is_health_check_running()

bool kcenon::pacs::client::remote_node_manager::is_health_check_running ( ) const -> bool

nodiscardnoexcept

Check if health check is running.

Returns: true if the health check scheduler is active

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/remote_node_manager.h.

Definition at line 709 of file remote_node_manager.cpp.

                                                                 {
    return impl_->health_check_running.load();
}

References kcenon::pacs::client::remote_node_manager::impl::health_check_running, and impl_.

◆ list_nodes()

std::vector< remote_node > kcenon::pacs::client::remote_node_manager::list_nodes ( ) const -> std::vector<remote_node>

nodiscard

List all registered nodes.

Returns: Vector of all nodes

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/remote_node_manager.h.

Definition at line 475 of file remote_node_manager.cpp.

                                                             {
    std::vector<remote_node> result;
    std::lock_guard<std::mutex> lock(impl_->cache_mutex);
    result.reserve(impl_->node_cache.size());
    for (const auto& [_, node] : impl_->node_cache) {
        result.push_back(node);
    }
    return result;
}

References kcenon::pacs::client::remote_node_manager::impl::cache_mutex, impl_, and kcenon::pacs::client::remote_node_manager::impl::node_cache.

◆ list_nodes_by_status()

std::vector< remote_node > kcenon::pacs::client::remote_node_manager::list_nodes_by_status ( node_status status ) const -> std::vector<remote_node>

nodiscard

List nodes filtered by status.

Parameters

status The status to filter by

Returns: Vector of nodes with the specified status

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/remote_node_manager.h.

Definition at line 485 of file remote_node_manager.cpp.

                                                                                         {
    std::vector<remote_node> result;
    std::lock_guard<std::mutex> lock(impl_->cache_mutex);
    for (const auto& [_, node] : impl_->node_cache) {
        if (node.status == status) {
            result.push_back(node);
        }
    }
    return result;
}

References kcenon::pacs::client::remote_node_manager::impl::cache_mutex, impl_, and kcenon::pacs::client::remote_node_manager::impl::node_cache.

◆ operator=() [1/2]

auto kcenon::pacs::client::remote_node_manager::operator= ( const remote_node_manager & ) -> remote_node_manager &=delete

delete

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/remote_node_manager.h.

◆ operator=() [2/2]

auto kcenon::pacs::client::remote_node_manager::operator= ( remote_node_manager && ) -> remote_node_manager &=delete

delete

◆ release_association()

void kcenon::pacs::client::remote_node_manager::release_association	(	std::string_view	node_id,
		std::unique_ptr< network::association >	assoc )

Release an association back to the pool.

Returns an association to the pool for reuse. If the pool is full or the association is in a bad state, it will be closed instead.

Parameters

node_id	ID of the node the association is for
assoc	The association to release

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/remote_node_manager.h.

Definition at line 640 of file remote_node_manager.cpp.

                                             {
 
    std::string id_str(node_id);
 
    // Update statistics
    {
        std::lock_guard<std::mutex> lock(impl_->stats_mutex);
        auto it = impl_->statistics.find(id_str);
        if (it != impl_->statistics.end() && it->second.active_connections > 0) {
            it->second.active_connections--;
        }
    }
 
    if (!assoc || !assoc->is_established()) {
        return;
    }
 
    // Check pool capacity
    {
        std::lock_guard<std::mutex> lock(impl_->pool_mutex);
        auto& pool = impl_->connection_pool[id_str];
        if (pool.size() < impl_->config.max_pool_connections_per_node) {
            impl::pooled_association pooled;
            pooled.assoc = std::move(assoc);
            pooled.acquired_at = std::chrono::steady_clock::now();
            pool.push_back(std::move(pooled));
            impl_->logger->debug_fmt("Returned association to pool for {}", id_str);
            return;
        }
    }
 
    // Pool is full, release the association
    [[maybe_unused]] auto release_result = assoc->release();
}

◆ remove_node()

kcenon::pacs::VoidResult kcenon::pacs::client::remote_node_manager::remove_node ( std::string_view node_id ) -> kcenon::pacs::VoidResult

nodiscard

Remove a remote node.

Parameters

node_id ID of the node to remove

Returns: VoidResult indicating success or error

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/remote_node_manager.h.

Definition at line 422 of file remote_node_manager.cpp.

                                                                            {
    std::string id_str(node_id);
 
    // Check if exists
    {
        std::lock_guard<std::mutex> lock(impl_->cache_mutex);
        if (impl_->node_cache.find(id_str) == impl_->node_cache.end()) {
            return kcenon::pacs::pacs_void_error(
                kcenon::pacs::error_codes::not_found,
                "Node not found: " + id_str);
        }
    }
 
    // Remove from repository
    if (impl_->repo) {
        auto result = impl_->repo->remove(std::string(node_id));
        if (result.is_err()) {
            return result;
        }
    }
 
    // Remove from cache
    {
        std::lock_guard<std::mutex> lock(impl_->cache_mutex);
        impl_->node_cache.erase(id_str);
    }
 
    // Remove from connection pool
    {
        std::lock_guard<std::mutex> lock(impl_->pool_mutex);
        impl_->connection_pool.erase(id_str);
    }
 
    // Remove statistics
    {
        std::lock_guard<std::mutex> lock(impl_->stats_mutex);
        impl_->statistics.erase(id_str);
    }
 
    impl_->logger->info_fmt("Removed remote node: {}", id_str);
 
    return kcenon::pacs::ok();
}

Here is the call graph for this function:

◆ reset_statistics()

void kcenon::pacs::client::remote_node_manager::reset_statistics ( std::string_view node_id = "" )

Reset statistics for a node.

Parameters

node_id ID of the node (empty to reset all)

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/remote_node_manager.h.

Definition at line 744 of file remote_node_manager.cpp.

                                                                 {
    std::lock_guard<std::mutex> lock(impl_->stats_mutex);
    if (node_id.empty()) {
        impl_->statistics.clear();
    } else {
        impl_->statistics.erase(std::string(node_id));
    }
}

References impl_, kcenon::pacs::client::remote_node_manager::impl::statistics, and kcenon::pacs::client::remote_node_manager::impl::stats_mutex.

◆ set_config()

void kcenon::pacs::client::remote_node_manager::set_config ( node_manager_config new_config )

Update the configuration.

Note: Some changes may not take effect until health check is restarted.

Parameters

new_config New configuration to apply

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/remote_node_manager.h.

Definition at line 761 of file remote_node_manager.cpp.

                                                                   {
    impl_->config = std::move(new_config);
}

References kcenon::pacs::client::remote_node_manager::impl::config, and impl_.

◆ set_status_callback()

void kcenon::pacs::client::remote_node_manager::set_status_callback ( node_status_callback callback )

Set the status change callback.

The callback is invoked whenever a node's status changes. Only one callback can be set; setting a new one replaces the old.

Parameters

callback Function to call on status change

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/remote_node_manager.h.

Definition at line 726 of file remote_node_manager.cpp.

                                                                           {
    std::lock_guard<std::mutex> lock(impl_->callback_mutex);
    impl_->status_callback = std::move(callback);
}

References kcenon::pacs::client::remote_node_manager::impl::callback_mutex, impl_, and kcenon::pacs::client::remote_node_manager::impl::status_callback.

◆ start_health_check()

void kcenon::pacs::client::remote_node_manager::start_health_check ( )

Start the automatic health check scheduler.

Begins periodic verification of all nodes at the configured interval. Does nothing if already running.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/remote_node_manager.h.

Definition at line 681 of file remote_node_manager.cpp.

                                             {
    if (impl_->health_check_running.load()) {
        return;
    }
 
    impl_->health_check_running.store(true);
    impl_->health_check_thread = std::thread([this]() {
        impl_->health_check_loop();
    });
 
    impl_->logger->info("Started health check scheduler");
}

References kcenon::pacs::client::remote_node_manager::impl::health_check_loop(), kcenon::pacs::client::remote_node_manager::impl::health_check_running, kcenon::pacs::client::remote_node_manager::impl::health_check_thread, impl_, and kcenon::pacs::client::remote_node_manager::impl::logger.

Referenced by remote_node_manager().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ stop_health_check()

void kcenon::pacs::client::remote_node_manager::stop_health_check ( )

Stop the automatic health check scheduler.

Stops periodic verification. Does nothing if not running.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/remote_node_manager.h.

Definition at line 694 of file remote_node_manager.cpp.

                                            {
    if (!impl_->health_check_running.load()) {
        return;
    }
 
    impl_->health_check_running.store(false);
    impl_->health_check_cv.notify_all();
 
    if (impl_->health_check_thread.joinable()) {
        impl_->health_check_thread.join();
    }
 
    impl_->logger->info("Stopped health check scheduler");
}

References kcenon::pacs::client::remote_node_manager::impl::health_check_cv, kcenon::pacs::client::remote_node_manager::impl::health_check_running, kcenon::pacs::client::remote_node_manager::impl::health_check_thread, impl_, and kcenon::pacs::client::remote_node_manager::impl::logger.

Referenced by ~remote_node_manager().

Here is the caller graph for this function:

◆ update_node()

kcenon::pacs::VoidResult kcenon::pacs::client::remote_node_manager::update_node ( const remote_node & node ) -> kcenon::pacs::VoidResult

nodiscard

Update an existing remote node.

Parameters

node	The node to update (node_id must match existing)

Returns: VoidResult indicating success or error

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/remote_node_manager.h.

Definition at line 381 of file remote_node_manager.cpp.

                                                                             {
    // Check if exists
    {
        std::lock_guard<std::mutex> lock(impl_->cache_mutex);
        if (impl_->node_cache.find(node.node_id) == impl_->node_cache.end()) {
            return kcenon::pacs::pacs_void_error(
                kcenon::pacs::error_codes::not_found,
                "Node not found: " + node.node_id);
        }
    }
 
    // Update repository
    if (impl_->repo) {
#ifdef PACS_WITH_DATABASE_SYSTEM
        auto result = impl_->repo->save(node);
        if (result.is_err()) {
            return kcenon::pacs::pacs_void_error(
                result.error().code,
                "Failed to update node: " + result.error().message);
        }
#else
        auto result = impl_->repo->upsert(node);
        if (result.is_err()) {
            return kcenon::pacs::pacs_void_error(
                result.error().code,
                "Failed to update node: " + result.error().message);
        }
#endif
    }
 
    // Update cache
    {
        std::lock_guard<std::mutex> lock(impl_->cache_mutex);
        impl_->node_cache[node.node_id] = node;
    }
 
    impl_->logger->info_fmt("Updated remote node: {}", node.node_id);
 
    return kcenon::pacs::ok();
}

References kcenon::pacs::client::remote_node_manager::impl::cache_mutex, impl_, kcenon::pacs::client::remote_node_manager::impl::logger, kcenon::pacs::client::remote_node_manager::impl::node_cache, kcenon::pacs::client::remote_node::node_id, kcenon::pacs::pacs_void_error(), and kcenon::pacs::client::remote_node_manager::impl::repo.

Here is the call graph for this function:

◆ verify_all_nodes_async()

void kcenon::pacs::client::remote_node_manager::verify_all_nodes_async ( )

Verify all nodes asynchronously.

Initiates verification of all registered nodes. Results are reported via status callbacks.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/remote_node_manager.h.

Definition at line 543 of file remote_node_manager.cpp.

                                                 {
    std::vector<std::string> node_ids;
    {
        std::lock_guard<std::mutex> lock(impl_->cache_mutex);
        for (const auto& [id, _] : impl_->node_cache) {
            node_ids.push_back(id);
        }
    }
 
    for (const auto& id : node_ids) {
        std::thread([this, id]() {
            [[maybe_unused]] auto result = verify_node(id);
        }).detach();
    }
}

References kcenon::pacs::client::remote_node_manager::impl::cache_mutex, impl_, kcenon::pacs::client::remote_node_manager::impl::node_cache, and verify_node().

Here is the call graph for this function:

◆ verify_node()

kcenon::pacs::VoidResult kcenon::pacs::client::remote_node_manager::verify_node ( std::string_view node_id ) -> kcenon::pacs::VoidResult

nodiscard

Verify a node's connectivity synchronously.

Sends a C-ECHO to the specified node and waits for response. Updates the node's status based on the result.

Parameters

node_id ID of the node to verify

Returns: VoidResult indicating success (online) or error (offline/error)

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/remote_node_manager.h.

Definition at line 500 of file remote_node_manager.cpp.

                                                                            {
    std::optional<remote_node> node;
    {
        std::lock_guard<std::mutex> lock(impl_->cache_mutex);
        auto it = impl_->node_cache.find(std::string(node_id));
        if (it != impl_->node_cache.end()) {
            node = it->second;
        }
    }
 
    if (!node) {
        return kcenon::pacs::pacs_void_error(
            kcenon::pacs::error_codes::not_found,
            "Node not found: " + std::string(node_id));
    }
 
    impl_->update_node_status(std::string(node_id), node_status::verifying);
 
    auto result = impl_->perform_echo(*node);
 
    if (result.is_ok()) {
        impl_->update_node_status(std::string(node_id), node_status::online);
        if (impl_->repo) {
            [[maybe_unused]] auto update_result = impl_->repo->update_last_verified(node_id);
        }
    } else {
        impl_->update_node_status(std::string(node_id), node_status::offline,
                                  result.error().message);
    }
 
    return result;
}

References kcenon::pacs::client::remote_node_manager::impl::cache_mutex, impl_, kcenon::pacs::client::remote_node_manager::impl::node_cache, kcenon::pacs::client::offline, kcenon::pacs::client::online, kcenon::pacs::pacs_void_error(), kcenon::pacs::client::remote_node_manager::impl::perform_echo(), kcenon::pacs::client::remote_node_manager::impl::repo, kcenon::pacs::client::remote_node_manager::impl::update_node_status(), and kcenon::pacs::client::verifying.

Referenced by verify_all_nodes_async(), and verify_node_async().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ verify_node_async()

std::future< kcenon::pacs::VoidResult > kcenon::pacs::client::remote_node_manager::verify_node_async ( std::string_view node_id ) -> std::future<kcenon::pacs::VoidResult>

nodiscard

Verify a node's connectivity asynchronously.

Returns immediately with a future that will contain the result.

Parameters

node_id ID of the node to verify

Returns: Future containing the verification result

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/remote_node_manager.h.

Definition at line 533 of file remote_node_manager.cpp.

                            {
 
    std::string id_str(node_id);
 
    return std::async(std::launch::async, [this, id_str]() {
        return verify_node(id_str);
    });
}

References verify_node().

Here is the call graph for this function:

Member Data Documentation

◆ impl_

std::unique_ptr<impl> kcenon::pacs::client::remote_node_manager::impl_

private

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

include/kcenon/pacs/client/remote_node_manager.h
src/client/remote_node_manager.cpp

Classes

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ remote_node_manager() [1/3]

◆ ~remote_node_manager()

◆ remote_node_manager() [2/3]

◆ remote_node_manager() [3/3]

Member Function Documentation

◆ acquire_association()

◆ add_node()

◆ config()

◆ get_node()

◆ get_statistics()

◆ get_status()

◆ is_health_check_running()

◆ list_nodes()

◆ list_nodes_by_status()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ release_association()

◆ remove_node()

◆ reset_statistics()

◆ set_config()

◆ set_status_callback()

◆ start_health_check()

◆ stop_health_check()

◆ update_node()

◆ verify_all_nodes_async()

◆ verify_node()

◆ verify_node_async()

Member Data Documentation

◆ impl_