Collaboration diagram for kcenon::pacs::client::sync_manager::impl:

Public Member Functions
void	save_config (const sync_config &cfg)

std::optional< sync_config >	get_config_from_cache (std::string_view config_id) const

void	update_config_stats (std::string_view config_id, bool success, size_t studies_synced)

void	mark_sync_active (std::string_view config_id)

void	mark_sync_inactive (std::string_view config_id)

bool	is_sync_active (std::string_view config_id) const

void	store_last_result (const std::string &config_id, const sync_result &result)

void	notify_progress (const std::string &config_id, size_t synced, size_t total)

void	notify_completion (const std::string &config_id, const sync_result &result)

void	notify_conflict (const sync_conflict &conflict)

void	add_conflict (const sync_conflict &conflict)

sync_result	perform_sync (const sync_config &cfg, bool full_sync)

std::vector< std::string >	query_remote_studies (const sync_config &cfg, std::chrono::system_clock::time_point since, sync_result &result)

std::vector< sync_conflict >	compare_with_local (const sync_config &cfg, const std::vector< std::string > &remote_study_uids, sync_result &result)

void	resolve_conflict_internal (const sync_conflict &conflict, conflict_resolution resolution, sync_result &result)

void	scheduler_loop ()

void	load_configs_from_repo ()

void	load_conflicts_from_repo ()

Public Attributes
sync_manager_config	config

sync_repositories	repositories

std::shared_ptr< storage::sync_repository >	compatibility_repo

std::shared_ptr< remote_node_manager >	node_manager

std::shared_ptr< job_manager >	job_mgr

std::shared_ptr< services::query_scu >	query_scu

std::shared_ptr< di::ILogger >	logger

std::vector< sync_config >	configs

std::shared_mutex	configs_mutex

std::unordered_set< std::string >	active_sync_config_ids

std::mutex	active_mutex

std::unordered_map< std::string, sync_result >	last_results

std::shared_mutex	results_mutex

std::vector< sync_conflict >	conflicts

std::mutex	conflicts_mutex

std::thread	scheduler_thread

std::atomic< bool >	scheduler_running {false}

std::condition_variable	scheduler_cv

std::mutex	scheduler_mutex

sync_progress_callback	progress_callback

sync_completion_callback	completion_callback

sync_conflict_callback	conflict_callback

std::shared_mutex	callbacks_mutex

std::unordered_map< std::string, std::shared_ptr< std::promise< sync_result > > >	completion_promises

std::mutex	promises_mutex

std::atomic< size_t >	total_syncs {0}

std::atomic< size_t >	successful_syncs {0}

std::atomic< size_t >	failed_syncs {0}

std::atomic< size_t >	total_studies_synced {0}

std::atomic< size_t >	total_bytes_transferred {0}

std::atomic< size_t >	total_conflicts_detected {0}

std::atomic< size_t >	total_conflicts_resolved {0}

Detailed Description

Definition at line 79 of file sync_manager.cpp.

Member Function Documentation

◆ add_conflict()

void kcenon::pacs::client::sync_manager::impl::add_conflict ( const sync_conflict & conflict )

inline

Definition at line 264 of file sync_manager.cpp.

                                                     {
        {
            std::lock_guard lock(conflicts_mutex);
            // Check for existing conflict for same study
            auto it = std::find_if(conflicts.begin(), conflicts.end(),
                [&conflict](const sync_conflict& c) {
                    return c.study_uid == conflict.study_uid &&
                           c.config_id == conflict.config_id;
                });
            if (it != conflicts.end()) {
                *it = conflict;  // Update existing
            } else {
                conflicts.push_back(conflict);
            }
        }
 
        #ifdef PACS_WITH_DATABASE_SYSTEM
        if (repositories.conflicts) {
            [[maybe_unused]] auto result = repositories.conflicts->save(conflict);
        } else if (compatibility_repo) {
            [[maybe_unused]] auto result =
                compatibility_repo->save_conflict(conflict);
        }
        #else
        if (compatibility_repo) {
            [[maybe_unused]] auto result =
                compatibility_repo->save_conflict(conflict);
        }
        #endif
 
        total_conflicts_detected.fetch_add(1, std::memory_order_relaxed);
        notify_conflict(conflict);
    }

References compatibility_repo, conflicts, kcenon::pacs::client::sync_repositories::conflicts, conflicts_mutex, notify_conflict(), repositories, and total_conflicts_detected.

Referenced by perform_sync().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ compare_with_local()

std::vector< sync_conflict > kcenon::pacs::client::sync_manager::impl::compare_with_local	(	const sync_config &	cfg,
		const std::vector< std::string > &	remote_study_uids,
		sync_result &	result )

inline

Definition at line 547 of file sync_manager.cpp.

                             {
        (void)result;  // Reserved for future result aggregation
 
        std::vector<sync_conflict> comparison_conflicts;
 
        // For each remote study, check if it exists locally
        for (const auto& study_uid : remote_study_uids) {
            // In real implementation, query local database
            // For now, we'll simulate that all remote studies are missing locally
            bool exists_locally = false;  // Would check storage index here
 
            if (!exists_locally) {
                sync_conflict conflict;
                conflict.config_id = cfg.config_id;
                conflict.study_uid = study_uid;
                conflict.conflict_type = sync_conflict_type::missing_local;
                conflict.remote_modified = std::chrono::system_clock::now();
                conflict.detected_at = std::chrono::system_clock::now();
                comparison_conflicts.push_back(conflict);
            }
        }
 
        return comparison_conflicts;
    }

References kcenon::pacs::client::sync_config::config_id, and kcenon::pacs::client::missing_local.

Referenced by kcenon::pacs::client::sync_manager::compare(), and perform_sync().

Here is the caller graph for this function:

◆ get_config_from_cache()

std::optional< sync_config > kcenon::pacs::client::sync_manager::impl::get_config_from_cache ( std::string_view config_id ) const

inline

Definition at line 164 of file sync_manager.cpp.

                                                                                   {
        std::shared_lock lock(configs_mutex);
        auto it = std::find_if(configs.begin(), configs.end(),
            [&config_id](const sync_config& c) {
                return c.config_id == config_id;
            });
        if (it != configs.end()) {
            return *it;
        }
        return std::nullopt;
    }

References configs, and configs_mutex.

Referenced by kcenon::pacs::client::sync_manager::add_config(), kcenon::pacs::client::sync_manager::compare(), kcenon::pacs::client::sync_manager::full_sync(), kcenon::pacs::client::sync_manager::get_config(), kcenon::pacs::client::sync_manager::get_statistics(), kcenon::pacs::client::sync_manager::incremental_sync(), kcenon::pacs::client::sync_manager::sync_now(), and kcenon::pacs::client::sync_manager::update_config().

Here is the caller graph for this function:

◆ is_sync_active()

bool kcenon::pacs::client::sync_manager::impl::is_sync_active ( std::string_view config_id ) const

inline

Definition at line 221 of file sync_manager.cpp.

                                                        {
        std::lock_guard lock(active_mutex);
        return active_sync_config_ids.count(std::string(config_id)) > 0;
    }

References active_mutex, and active_sync_config_ids.

Referenced by kcenon::pacs::client::sync_manager::is_syncing(), and scheduler_loop().

Here is the caller graph for this function:

◆ load_configs_from_repo()

void kcenon::pacs::client::sync_manager::impl::load_configs_from_repo ( )

inline

Definition at line 666 of file sync_manager.cpp.

                                  {
        std::vector<sync_config> loaded;
        #ifdef PACS_WITH_DATABASE_SYSTEM
        if (repositories.configs) {
            auto result = repositories.configs->find_all();
            if (result.is_err()) {
                return;
            }
            loaded = std::move(result.value());
        } else if (compatibility_repo) {
            loaded = compatibility_repo->list_configs();
        } else {
            return;
        }
        #else
        if (compatibility_repo) {
            loaded = compatibility_repo->list_configs();
        } else {
            return;
        }
        #endif
        {
            std::unique_lock lock(configs_mutex);
            configs = std::move(loaded);
        }
 
        if (logger && !configs.empty()) {
            logger->info_fmt("Loaded {} sync configs from repository", configs.size());
        }
    }

References compatibility_repo, configs, kcenon::pacs::client::sync_repositories::configs, configs_mutex, logger, and repositories.

Referenced by kcenon::pacs::client::sync_manager::sync_manager(), and kcenon::pacs::client::sync_manager::sync_manager().

Here is the caller graph for this function:

◆ load_conflicts_from_repo()

void kcenon::pacs::client::sync_manager::impl::load_conflicts_from_repo ( )

inline

Definition at line 697 of file sync_manager.cpp.

                                    {
        std::vector<sync_conflict> loaded;
        #ifdef PACS_WITH_DATABASE_SYSTEM
        if (repositories.conflicts) {
            auto result = repositories.conflicts->find_unresolved();
            if (result.is_err()) {
                return;
            }
            loaded = std::move(result.value());
        } else if (compatibility_repo) {
            loaded = compatibility_repo->list_unresolved_conflicts();
        } else {
            return;
        }
        #else
        if (compatibility_repo) {
            loaded = compatibility_repo->list_unresolved_conflicts();
        } else {
            return;
        }
        #endif
        {
            std::lock_guard lock(conflicts_mutex);
            conflicts = std::move(loaded);
        }
 
        if (logger && !conflicts.empty()) {
            logger->info_fmt("Loaded {} unresolved conflicts from repository", conflicts.size());
        }
    }

References compatibility_repo, conflicts, kcenon::pacs::client::sync_repositories::conflicts, conflicts_mutex, logger, and repositories.

Referenced by kcenon::pacs::client::sync_manager::sync_manager(), and kcenon::pacs::client::sync_manager::sync_manager().

Here is the caller graph for this function:

◆ mark_sync_active()

void kcenon::pacs::client::sync_manager::impl::mark_sync_active ( std::string_view config_id )

inline

Definition at line 211 of file sync_manager.cpp.

                                                    {
        std::lock_guard lock(active_mutex);
        active_sync_config_ids.insert(std::string(config_id));
    }

References active_mutex, and active_sync_config_ids.

Referenced by kcenon::pacs::client::sync_manager::full_sync(), kcenon::pacs::client::sync_manager::incremental_sync(), scheduler_loop(), and kcenon::pacs::client::sync_manager::sync_now().

Here is the caller graph for this function:

◆ mark_sync_inactive()

void kcenon::pacs::client::sync_manager::impl::mark_sync_inactive ( std::string_view config_id )

inline

Definition at line 216 of file sync_manager.cpp.

                                                      {
        std::lock_guard lock(active_mutex);
        active_sync_config_ids.erase(std::string(config_id));
    }

References active_mutex, and active_sync_config_ids.

Referenced by kcenon::pacs::client::sync_manager::full_sync(), kcenon::pacs::client::sync_manager::incremental_sync(), scheduler_loop(), and kcenon::pacs::client::sync_manager::sync_now().

Here is the caller graph for this function:

◆ notify_completion()

void kcenon::pacs::client::sync_manager::impl::notify_completion	(	const std::string &	config_id,
		const sync_result &	result )

inline

Definition at line 238 of file sync_manager.cpp.

                                                                                  {
        {
            std::shared_lock lock(callbacks_mutex);
            if (completion_callback) {
                completion_callback(config_id, result);
            }
        }
 
        // Fulfill promise if exists
        {
            std::lock_guard lock(promises_mutex);
            auto it = completion_promises.find(result.job_id);
            if (it != completion_promises.end()) {
                it->second->set_value(result);
                completion_promises.erase(it);
            }
        }
    }

References callbacks_mutex, completion_callback, completion_promises, kcenon::pacs::client::sync_result::job_id, and promises_mutex.

Referenced by kcenon::pacs::client::sync_manager::full_sync(), kcenon::pacs::client::sync_manager::incremental_sync(), scheduler_loop(), and kcenon::pacs::client::sync_manager::sync_now().

Here is the caller graph for this function:

◆ notify_conflict()

void kcenon::pacs::client::sync_manager::impl::notify_conflict ( const sync_conflict & conflict )

inline

Definition at line 257 of file sync_manager.cpp.

                                                        {
        std::shared_lock lock(callbacks_mutex);
        if (conflict_callback) {
            conflict_callback(conflict);
        }
    }

References callbacks_mutex, and conflict_callback.

Referenced by add_conflict().

Here is the caller graph for this function:

◆ notify_progress()

void kcenon::pacs::client::sync_manager::impl::notify_progress	(	const std::string &	config_id,
		size_t	synced,
		size_t	total )

inline

Definition at line 231 of file sync_manager.cpp.

                                                                                  {
        std::shared_lock lock(callbacks_mutex);
        if (progress_callback) {
            progress_callback(config_id, synced, total);
        }
    }

References callbacks_mutex, and progress_callback.

Referenced by perform_sync().

Here is the caller graph for this function:

◆ perform_sync()

sync_result kcenon::pacs::client::sync_manager::impl::perform_sync	(	const sync_config &	cfg,
		bool	full_sync )

inline

Definition at line 302 of file sync_manager.cpp.

                                                                     {
        sync_result result;
        result.config_id = cfg.config_id;
        result.job_id = generate_uuid();
        result.started_at = std::chrono::system_clock::now();
 
        if (logger) {
            logger->info_fmt("Starting {} sync for config '{}' from node '{}'",
                full_sync ? "full" : "incremental", cfg.config_id, cfg.source_node_id);
        }
 
        // Get the source node
        auto node_opt = node_manager->get_node(cfg.source_node_id);
        if (!node_opt) {
            result.success = false;
            result.errors.push_back("Source node not found: " + cfg.source_node_id);
            result.completed_at = std::chrono::system_clock::now();
            result.elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
                result.completed_at - result.started_at);
            return result;
        }
 
        const auto& node = *node_opt;
        if (!node.is_online()) {
            result.success = false;
            result.errors.push_back("Source node is offline: " + cfg.source_node_id);
            result.completed_at = std::chrono::system_clock::now();
            result.elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
                result.completed_at - result.started_at);
            return result;
        }
 
        if (!node.supports_find) {
            result.success = false;
            result.errors.push_back("Node does not support C-FIND");
            result.completed_at = std::chrono::system_clock::now();
            result.elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
                result.completed_at - result.started_at);
            return result;
        }
 
        // Determine sync start time based on full_sync or incremental
        auto sync_start_time = full_sync
            ? std::chrono::system_clock::now() - cfg.lookback
            : cfg.last_successful_sync;
 
        // If no successful sync and not full sync, use lookback
        if (!full_sync && sync_start_time == std::chrono::system_clock::time_point{}) {
            sync_start_time = std::chrono::system_clock::now() - cfg.lookback;
        }
 
        // Query remote studies
        auto remote_studies = query_remote_studies(cfg, sync_start_time, result);
        if (!result.errors.empty()) {
            result.success = false;
            result.completed_at = std::chrono::system_clock::now();
            result.elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
                result.completed_at - result.started_at);
            return result;
        }
 
        result.studies_checked = remote_studies.size();
 
        // Compare with local studies
        auto comparison = compare_with_local(cfg, remote_studies, result);
 
        // Process differences based on sync direction
        if (cfg.direction == sync_direction::pull ||
            cfg.direction == sync_direction::bidirectional) {
            // Pull missing studies from remote
            for (const auto& conflict : comparison) {
                if (conflict.conflict_type == sync_conflict_type::missing_local) {
                    // Create retrieve job
                    if (job_mgr && node.supports_query_retrieve()) {
                        auto job_id = job_mgr->create_retrieve_job(
                            cfg.source_node_id, conflict.study_uid, std::nullopt,
                            job_priority::normal);
                        if (!job_id.empty()) {
                            result.studies_synced++;
                            notify_progress(cfg.config_id, result.studies_synced,
                                          result.studies_checked);
                        }
                    }
                } else if (conflict.conflict_type == sync_conflict_type::count_mismatch ||
                          conflict.conflict_type == sync_conflict_type::modified) {
                    // Handle conflicts
                    if (config.auto_resolve_conflicts) {
                        resolve_conflict_internal(conflict, config.default_resolution, result);
                    } else {
                        add_conflict(conflict);
                        result.conflicts.push_back(conflict);
                    }
                }
            }
        }
 
        if (cfg.direction == sync_direction::push ||
            cfg.direction == sync_direction::bidirectional) {
            // Push studies missing on remote
            for (const auto& conflict : comparison) {
                if (conflict.conflict_type == sync_conflict_type::missing_remote) {
                    // Store job would be created here for push
                    if (logger) {
                        logger->info_fmt("Study {} is missing on remote, would create store job",
                            conflict.study_uid);
                    }
                    result.studies_synced++;
                }
            }
        }
 
        // Update statistics
        total_syncs.fetch_add(1, std::memory_order_relaxed);
        total_studies_synced.fetch_add(result.studies_synced, std::memory_order_relaxed);
 
        result.success = result.errors.empty();
        result.completed_at = std::chrono::system_clock::now();
        result.elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
            result.completed_at - result.started_at);
 
        if (result.success) {
            successful_syncs.fetch_add(1, std::memory_order_relaxed);
        } else {
            failed_syncs.fetch_add(1, std::memory_order_relaxed);
        }
 
        // Update config statistics
        update_config_stats(cfg.config_id, result.success, result.studies_synced);
 
        // Store result
        store_last_result(cfg.config_id, result);
 
        // Save history
        sync_history history;
        history.config_id = cfg.config_id;
        history.job_id = result.job_id;
        history.success = result.success;
        history.studies_checked = result.studies_checked;
        history.studies_synced = result.studies_synced;
        history.conflicts_found = result.conflicts.size();
        history.errors = result.errors;
        history.started_at = result.started_at;
        history.completed_at = result.completed_at;
 
        #ifdef PACS_WITH_DATABASE_SYSTEM
        if (repositories.history) {
            [[maybe_unused]] auto save_result = repositories.history->save(history);
        } else if (compatibility_repo) {
            [[maybe_unused]] auto save_result =
                compatibility_repo->save_history(history);
        }
        #else
        if (compatibility_repo) {
            [[maybe_unused]] auto save_result =
                compatibility_repo->save_history(history);
        }
        #endif
 
        if (logger) {
            logger->info_fmt("Sync completed for config '{}': {} checked, {} synced, {} conflicts",
                cfg.config_id, result.studies_checked, result.studies_synced,
                result.conflicts.size());
        }
 
        return result;
    }

Referenced by kcenon::pacs::client::sync_manager::full_sync(), kcenon::pacs::client::sync_manager::incremental_sync(), scheduler_loop(), and kcenon::pacs::client::sync_manager::sync_now().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ query_remote_studies()

std::vector< std::string > kcenon::pacs::client::sync_manager::impl::query_remote_studies	(	const sync_config &	cfg,
		std::chrono::system_clock::time_point	since,
		sync_result &	result )

inline

Definition at line 469 of file sync_manager.cpp.

                             {
 
        std::vector<std::string> study_uids;
 
        // Get association for query
        std::vector<std::string> sop_classes = {
            std::string(services::study_root_find_sop_class_uid)
        };
 
        auto assoc_result = node_manager->acquire_association(
            cfg.source_node_id, sop_classes);
        if (assoc_result.is_err()) {
            result.errors.push_back("Failed to acquire association: " +
                                    assoc_result.error().message);
            return study_uids;
        }
 
        auto assoc = std::move(assoc_result.value());
 
        // Build query
        core::dicom_dataset query_keys;
        query_keys.set_string(core::tags::query_retrieve_level, encoding::vr_type::CS, "STUDY");
        query_keys.set_string(core::tags::study_instance_uid, encoding::vr_type::UI, "");
 
        // Apply filters
        if (!cfg.modalities.empty()) {
            std::string modality_filter;
            for (size_t i = 0; i < cfg.modalities.size(); ++i) {
                if (i > 0) modality_filter += "\\";
                modality_filter += cfg.modalities[i];
            }
            query_keys.set_string(core::tags::modality, encoding::vr_type::CS, modality_filter);
        }
 
        // Date range filter
        if (since != std::chrono::system_clock::time_point{}) {
            auto since_time_t = std::chrono::system_clock::to_time_t(since);
            std::tm tm_buf;
#ifdef _WIN32
            localtime_s(&tm_buf, &since_time_t);
#else
            localtime_r(&since_time_t, &tm_buf);
#endif
            std::ostringstream date_oss;
            date_oss << std::put_time(&tm_buf, "%Y%m%d") << "-";
            query_keys.set_string(core::tags::study_date, encoding::vr_type::DA, date_oss.str());
        }
 
        // Execute query
        services::query_scu_config query_config;
        query_config.model = services::query_model::study_root;
        query_config.level = services::query_level::study;
 
        services::query_scu scu(query_config, logger);
        auto query_result = scu.find(*assoc, query_keys);
 
        // Release association
        node_manager->release_association(cfg.source_node_id, std::move(assoc));
 
        if (query_result.is_err()) {
            result.errors.push_back("Query failed: " + query_result.error().message);
            return study_uids;
        }
 
        const auto& qr = query_result.value();
        for (const auto& match : qr.matches) {
            auto uid = match.get_string(core::tags::study_instance_uid);
            if (!uid.empty()) {
                study_uids.push_back(uid);
            }
        }
 
        return study_uids;
    }

References kcenon::pacs::encoding::CS, kcenon::pacs::encoding::DA, kcenon::pacs::client::sync_result::errors, kcenon::pacs::services::query_scu::find(), kcenon::pacs::services::query_scu_config::level, logger, kcenon::pacs::client::sync_config::modalities, kcenon::pacs::core::tags::modality, kcenon::pacs::services::query_scu_config::model, node_manager, kcenon::pacs::core::tags::query_retrieve_level, kcenon::pacs::core::dicom_dataset::set_string(), kcenon::pacs::client::sync_config::source_node_id, kcenon::pacs::services::study, kcenon::pacs::core::tags::study_date, kcenon::pacs::core::tags::study_instance_uid, kcenon::pacs::services::study_root, kcenon::pacs::services::study_root_find_sop_class_uid, kcenon::pacs::encoding::UI, and uid.

Referenced by kcenon::pacs::client::sync_manager::compare(), and perform_sync().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ resolve_conflict_internal()

void kcenon::pacs::client::sync_manager::impl::resolve_conflict_internal	(	const sync_conflict &	conflict,
		conflict_resolution	resolution,
		sync_result &	result )

inline

Definition at line 575 of file sync_manager.cpp.

                                                        {
        switch (resolution) {
            case conflict_resolution::prefer_remote:
                // Create retrieve job
                if (job_mgr) {
                    auto job_id = job_mgr->create_retrieve_job(
                        conflict.config_id, conflict.study_uid, std::nullopt,
                        job_priority::normal);
                    if (!job_id.empty()) {
                        result.studies_synced++;
                    }
                }
                break;
 
            case conflict_resolution::prefer_local:
                // Keep local, skip
                result.studies_skipped++;
                break;
 
            case conflict_resolution::prefer_newer:
                // Compare timestamps and choose
                if (conflict.remote_modified > conflict.local_modified) {
                    if (job_mgr) {
                        auto job_id = job_mgr->create_retrieve_job(
                            conflict.config_id, conflict.study_uid, std::nullopt,
                            job_priority::normal);
                        if (!job_id.empty()) {
                            result.studies_synced++;
                        }
                    }
                } else {
                    result.studies_skipped++;
                }
                break;
        }
 
        total_conflicts_resolved.fetch_add(1, std::memory_order_relaxed);
    }

References job_mgr, kcenon::pacs::client::normal, kcenon::pacs::client::prefer_local, kcenon::pacs::client::prefer_newer, kcenon::pacs::client::prefer_remote, kcenon::pacs::client::sync_result::studies_skipped, kcenon::pacs::client::sync_result::studies_synced, and total_conflicts_resolved.

Referenced by perform_sync(), and kcenon::pacs::client::sync_manager::resolve_conflict().

Here is the caller graph for this function:

◆ save_config()

void kcenon::pacs::client::sync_manager::impl::save_config ( const sync_config & cfg )

inline

Definition at line 137 of file sync_manager.cpp.

                                             {
        {
            std::unique_lock lock(configs_mutex);
            auto it = std::find_if(configs.begin(), configs.end(),
                [&cfg](const sync_config& c) {
                    return c.config_id == cfg.config_id;
                });
            if (it != configs.end()) {
                *it = cfg;
            } else {
                configs.push_back(cfg);
            }
        }
 
        #ifdef PACS_WITH_DATABASE_SYSTEM
        if (repositories.configs) {
            [[maybe_unused]] auto result = repositories.configs->save(cfg);
        } else if (compatibility_repo) {
            [[maybe_unused]] auto result = compatibility_repo->save_config(cfg);
        }
        #else
        if (compatibility_repo) {
            [[maybe_unused]] auto result = compatibility_repo->save_config(cfg);
        }
        #endif
    }

References compatibility_repo, configs, kcenon::pacs::client::sync_repositories::configs, configs_mutex, and repositories.

Referenced by kcenon::pacs::client::sync_manager::add_config(), and kcenon::pacs::client::sync_manager::update_config().

Here is the caller graph for this function:

◆ scheduler_loop()

void kcenon::pacs::client::sync_manager::impl::scheduler_loop ( )

inline

Definition at line 620 of file sync_manager.cpp.

                          {
        while (scheduler_running.load()) {
            std::unique_lock lock(scheduler_mutex);
            scheduler_cv.wait_for(lock, std::chrono::minutes(1), [this] {
                return !scheduler_running.load();
            });
 
            if (!scheduler_running.load()) {
                break;
            }
 
            // Check each config for scheduled syncs
            std::vector<sync_config> configs_copy;
            {
                std::shared_lock cfg_lock(configs_mutex);
                configs_copy = configs;
            }
 
            for (const auto& cfg : configs_copy) {
                if (!cfg.enabled || cfg.schedule_cron.empty()) {
                    continue;
                }
 
                // Simple cron check - in production would parse cron expression
                // For now, check if it's time based on last sync
                auto now = std::chrono::system_clock::now();
                auto since_last = now - cfg.last_sync;
 
                // Default to hourly if cron not parsed
                if (since_last >= std::chrono::hours(1)) {
                    if (!is_sync_active(cfg.config_id)) {
                        if (logger) {
                            logger->info_fmt("Scheduler triggering sync for config '{}'",
                                cfg.config_id);
                        }
 
                        mark_sync_active(cfg.config_id);
                        auto result = perform_sync(cfg, false);
                        mark_sync_inactive(cfg.config_id);
                        notify_completion(cfg.config_id, result);
                    }
                }
            }
        }
    }

References configs, configs_mutex, is_sync_active(), logger, mark_sync_active(), mark_sync_inactive(), notify_completion(), perform_sync(), scheduler_cv, scheduler_mutex, and scheduler_running.

Referenced by kcenon::pacs::client::sync_manager::start_scheduler().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ store_last_result()

void kcenon::pacs::client::sync_manager::impl::store_last_result	(	const std::string &	config_id,
		const sync_result &	result )

inline

Definition at line 226 of file sync_manager.cpp.

                                                                                  {
        std::unique_lock lock(results_mutex);
        last_results[config_id] = result;
    }

References last_results, and results_mutex.

Referenced by perform_sync().

Here is the caller graph for this function:

◆ update_config_stats()

void kcenon::pacs::client::sync_manager::impl::update_config_stats	(	std::string_view	config_id,
		bool	success,
		size_t	studies_synced )

inline

Definition at line 176 of file sync_manager.cpp.

                                                    {
        std::unique_lock lock(configs_mutex);
        auto it = std::find_if(configs.begin(), configs.end(),
            [&config_id](const sync_config& c) {
                return c.config_id == config_id;
            });
        if (it != configs.end()) {
            it->total_syncs++;
            it->studies_synced += studies_synced;
            it->last_sync = std::chrono::system_clock::now();
            if (success) {
                it->last_successful_sync = std::chrono::system_clock::now();
            }
        }
 
        #ifdef PACS_WITH_DATABASE_SYSTEM
        if (repositories.configs) {
            [[maybe_unused]] auto result =
                repositories.configs->update_stats(config_id, success,
                                                   studies_synced);
        } else if (compatibility_repo) {
            [[maybe_unused]] auto result =
                compatibility_repo->update_config_stats(config_id, success,
                                                        studies_synced);
        }
        #else
        if (compatibility_repo) {
            [[maybe_unused]] auto result =
                compatibility_repo->update_config_stats(config_id, success,
                                                        studies_synced);
        }
        #endif
    }