#include <job_manager.h>

Collaboration diagram for kcenon::pacs::client::job_manager:

Classes
struct	impl

Public Member Functions
	job_manager (std::shared_ptr< storage::job_repository > repo, std::shared_ptr< remote_node_manager > node_manager, std::shared_ptr< di::ILogger > logger=nullptr)
	Construct a job manager with default configuration.

	job_manager (const job_manager_config &config, std::shared_ptr< storage::job_repository > repo, std::shared_ptr< remote_node_manager > node_manager, std::shared_ptr< di::ILogger > logger=nullptr)
	Construct a job manager with custom configuration.

	~job_manager ()
	Destructor - stops workers if running.

	job_manager (const job_manager &)=delete

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

	job_manager (job_manager &&)=delete

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

auto	create_retrieve_job (std::string_view source_node_id, std::string_view study_uid, std::optional< std::string_view > series_uid=std::nullopt, job_priority priority=job_priority::normal) -> std::string
	Create a retrieve job (C-MOVE/C-GET)

auto	create_store_job (std::string_view destination_node_id, const std::vector< std::string > &instance_uids, job_priority priority=job_priority::normal) -> std::string
	Create a store job (C-STORE)

auto	create_query_job (std::string_view node_id, std::string_view query_level, const std::unordered_map< std::string, std::string > &query_keys, job_priority priority=job_priority::normal) -> std::string
	Create a query job (C-FIND)

auto	create_sync_job (std::string_view source_node_id, std::optional< std::string_view > patient_id=std::nullopt, job_priority priority=job_priority::low) -> std::string
	Create a sync job.

auto	create_prefetch_job (std::string_view source_node_id, std::string_view patient_id, job_priority priority=job_priority::low) -> std::string
	Create a prefetch job.

auto	start_job (std::string_view job_id) -> kcenon::pacs::VoidResult
	Start a pending job.

auto	pause_job (std::string_view job_id) -> kcenon::pacs::VoidResult
	Pause a running or queued job.

auto	resume_job (std::string_view job_id) -> kcenon::pacs::VoidResult
	Resume a paused job.

auto	cancel_job (std::string_view job_id) -> kcenon::pacs::VoidResult
	Cancel a job.

auto	retry_job (std::string_view job_id) -> kcenon::pacs::VoidResult
	Retry a failed job.

auto	delete_job (std::string_view job_id) -> kcenon::pacs::VoidResult
	Delete a job.

auto	get_job (std::string_view job_id) const -> std::optional< job_record >
	Get a job by ID.

auto	list_jobs (std::optional< job_status > status=std::nullopt, std::optional< job_type > type=std::nullopt, size_t limit=100, size_t offset=0) const -> std::vector< job_record >
	List jobs with optional filters.

auto	list_jobs_by_node (std::string_view node_id) const -> std::vector< job_record >
	List jobs by node ID.

auto	get_progress (std::string_view job_id) const -> job_progress
	Get current progress for a job.

void	set_progress_callback (job_progress_callback callback)
	Set the progress callback.

void	set_completion_callback (job_completion_callback callback)
	Set the completion callback.

auto	wait_for_completion (std::string_view job_id) -> std::future< job_record >
	Wait for a job to complete.

void	start_workers ()
	Start the worker threads.

void	stop_workers ()
	Stop the worker threads.

auto	is_running () const noexcept -> bool
	Check if workers are running.

auto	active_jobs () const -> size_t
	Get number of active (running) jobs.

auto	pending_jobs () const -> size_t
	Get number of pending jobs.

auto	completed_jobs_today () const -> size_t
	Get number of jobs completed today.

auto	failed_jobs_today () const -> size_t
	Get number of jobs failed today.

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

Private Attributes
std::unique_ptr< impl >	impl_

Detailed Description

Definition at line 93 of file job_manager.h.

Constructor & Destructor Documentation

◆ job_manager() [1/4]

kcenon::pacs::client::job_manager::job_manager	(	std::shared_ptr< storage::job_repository >	repo,
		std::shared_ptr< remote_node_manager >	node_manager,
		std::shared_ptr< di::ILogger >	logger = nullptr )

explicit

Construct a job manager with default configuration.

Parameters

repo	Job repository for persistence (required)
node_manager	Remote node manager for DICOM operations (required)
logger	Logger instance (optional, defaults to NullLogger)

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

Definition at line 1129 of file job_manager.cpp.

1133 : job_manager(job_manager_config{}, std::move(repo), std::move(node_manager), std::move(logger)) {

1134}

kcenon::pacs::client::job_manager::job_manager

job_manager(std::shared_ptr< storage::job_repository > repo, std::shared_ptr< remote_node_manager > node_manager, std::shared_ptr< di::ILogger > logger=nullptr)

Construct a job manager with default configuration.

Definition job_manager.cpp:1129

◆ job_manager() [2/4]

kcenon::pacs::client::job_manager::job_manager	(	const job_manager_config &	config,
		std::shared_ptr< storage::job_repository >	repo,
		std::shared_ptr< remote_node_manager >	node_manager,
		std::shared_ptr< di::ILogger >	logger = nullptr )

explicit

Construct a job manager with custom configuration.

Parameters

config	Manager configuration
repo	Job repository for persistence (required)
node_manager	Remote node manager for DICOM operations (required)
logger	Logger instance (optional, defaults to NullLogger)

Definition at line 1136 of file job_manager.cpp.

    : impl_(std::make_unique<impl>()) {
 
    impl_->config = config;
    impl_->repo = std::move(repo);
    impl_->node_manager = std::move(node_manager);
    impl_->logger = logger ? std::move(logger) : di::null_logger();
 
    // Load any pending jobs from repository
    impl_->load_pending_jobs_from_repo();
}

References config(), kcenon::pacs::client::job_manager::impl::config, impl_, kcenon::pacs::client::job_manager::impl::load_pending_jobs_from_repo(), kcenon::pacs::client::job_manager::impl::logger, kcenon::pacs::client::job_manager::impl::node_manager, kcenon::pacs::di::null_logger(), and kcenon::pacs::client::job_manager::impl::repo.

Here is the call graph for this function:

◆ ~job_manager()

kcenon::pacs::client::job_manager::~job_manager ( )

Destructor - stops workers if running.

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

Definition at line 1152 of file job_manager.cpp.

                          {
    stop_workers();
}

References stop_workers().

Here is the call graph for this function:

◆ job_manager() [3/4]

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

delete

◆ job_manager() [4/4]

kcenon::pacs::client::job_manager::job_manager ( job_manager && )

delete

Member Function Documentation

◆ active_jobs()

size_t kcenon::pacs::client::job_manager::active_jobs ( ) const -> size_t

nodiscard

Get number of active (running) jobs.

Returns: Number of jobs currently executing

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

Definition at line 1622 of file job_manager.cpp.

                                      {
    std::lock_guard lock(impl_->active_mutex);
    return impl_->active_job_ids.size();
}

References kcenon::pacs::client::job_manager::impl::active_job_ids, kcenon::pacs::client::job_manager::impl::active_mutex, and impl_.

◆ cancel_job()

kcenon::pacs::VoidResult kcenon::pacs::client::job_manager::cancel_job ( std::string_view job_id ) -> kcenon::pacs::VoidResult

nodiscard

Cancel a job.

Cancels a running, queued, or pending job.

Parameters

job_id The job ID to cancel

Returns: VoidResult indicating success or error

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

Definition at line 1353 of file job_manager.cpp.

                                                                  {
    auto job_opt = impl_->get_job_from_cache(job_id);
    if (!job_opt) {
        return kcenon::pacs::pacs_void_error(
            kcenon::pacs::error_codes::not_found,
            "Job not found: " + std::string(job_id));
    }
 
    if (!job_opt->can_cancel()) {
        return kcenon::pacs::pacs_void_error(
            kcenon::pacs::error_codes::invalid_argument,
            "Job cannot be cancelled in current state: " + std::string(to_string(job_opt->status)));
    }
 
    {
        std::lock_guard lock(impl_->cancelled_mutex);
        impl_->cancelled_job_ids.insert(std::string(job_id));
    }
 
    // If not actively running, update status immediately
    {
        std::lock_guard lock(impl_->active_mutex);
        if (impl_->active_job_ids.count(std::string(job_id)) == 0) {
            impl_->update_job_status(std::string(job_id), job_status::cancelled);
            auto final_job = impl_->get_job_from_cache(job_id);
            if (final_job) {
                impl_->notify_completion(std::string(job_id), *final_job);
            }
        }
    }
 
    impl_->logger->info_fmt("Cancelled job {}", job_id);
    return kcenon::pacs::ok();
}

Referenced by delete_job().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ completed_jobs_today()

size_t kcenon::pacs::client::job_manager::completed_jobs_today ( ) const -> size_t

nodiscard

Get number of jobs completed today.

Returns: Number of successful completions today

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

Definition at line 1632 of file job_manager.cpp.

                                               {
    if (impl_->repo) {
#ifdef PACS_WITH_DATABASE_SYSTEM
        auto result = impl_->repo->count_completed_today();
        if (result.is_ok()) {
            return result.value();
        }
        return 0;
#else
        return impl_->repo->count_completed_today();
#endif
    }
    return 0;
}

References impl_, and kcenon::pacs::client::job_manager::impl::repo.

◆ config()

const job_manager_config & kcenon::pacs::client::job_manager::config ( ) const -> const job_manager_config&

nodiscardnoexcept

Get current configuration.

Returns: Current manager configuration

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

Definition at line 1666 of file job_manager.cpp.

                                                             {
    return impl_->config;
}

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

Referenced by job_manager().

Here is the caller graph for this function:

◆ create_prefetch_job()

std::string kcenon::pacs::client::job_manager::create_prefetch_job	(	std::string_view	source_node_id,
		std::string_view	patient_id,
		job_priority	priority = job_priority::low ) -> std::string

nodiscard

Create a prefetch job.

Creates a job to prefetch prior studies for a patient.

Parameters

source_node_id	ID of the source remote node
patient_id	Patient ID to prefetch studies for
priority	Job priority (default: low for background prefetch)

Returns: Unique job ID

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

Definition at line 1252 of file job_manager.cpp.

                           {
 
    job_record job;
    job.job_id = generate_uuid();
    job.type = job_type::prefetch;
    job.status = job_status::pending;
    job.priority = priority;
    job.source_node_id = std::string(source_node_id);
    job.patient_id = std::string(patient_id);
    job.created_at = std::chrono::system_clock::now();
 
    impl_->save_job(job);
    impl_->logger->info_fmt("Created prefetch job {}: patient={}", job.job_id, patient_id);
 
    return job.job_id;
}

References impl_, kcenon::pacs::client::job_manager::impl::logger, kcenon::pacs::client::pending, kcenon::pacs::client::prefetch, and kcenon::pacs::client::job_manager::impl::save_job().

Here is the call graph for this function:

◆ create_query_job()

std::string kcenon::pacs::client::job_manager::create_query_job	(	std::string_view	node_id,
		std::string_view	query_level,
		const std::unordered_map< std::string, std::string > &	query_keys,
		job_priority	priority = job_priority::normal ) -> std::string

nodiscard

Create a query job (C-FIND)

Creates a job to query a remote node.

Parameters

node_id	ID of the remote node to query
query_level	Query retrieve level (PATIENT, STUDY, SERIES, IMAGE)
query_keys	Query keys as key-value pairs
priority	Job priority (default: normal)

Returns: Unique job ID

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

Definition at line 1206 of file job_manager.cpp.

                           {
 
    job_record job;
    job.job_id = generate_uuid();
    job.type = job_type::query;
    job.status = job_status::pending;
    job.priority = priority;
    job.source_node_id = std::string(node_id);
    job.metadata["query_level"] = std::string(query_level);
    for (const auto& [key, value] : query_keys) {
        job.metadata["query_" + key] = value;
    }
    job.created_at = std::chrono::system_clock::now();
 
    impl_->save_job(job);
    impl_->logger->info_fmt("Created query job {}: level={}", job.job_id, query_level);
 
    return job.job_id;
}

References impl_, kcenon::pacs::client::job_manager::impl::logger, kcenon::pacs::client::pending, kcenon::pacs::client::query, and kcenon::pacs::client::job_manager::impl::save_job().

Here is the call graph for this function:

◆ create_retrieve_job()

std::string kcenon::pacs::client::job_manager::create_retrieve_job	(	std::string_view	source_node_id,
		std::string_view	study_uid,
		std::optional< std::string_view >	series_uid = std::nullopt,
		job_priority	priority = job_priority::normal ) -> std::string

nodiscard

Create a retrieve job (C-MOVE/C-GET)

Creates a job to retrieve DICOM objects from a remote node.

Parameters

source_node_id	ID of the source remote node
study_uid	Study Instance UID to retrieve
series_uid	Optional Series Instance UID (retrieve all if not specified)
priority	Job priority (default: normal)

Returns: Unique job ID

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

Definition at line 1160 of file job_manager.cpp.

                           {
 
    job_record job;
    job.job_id = generate_uuid();
    job.type = job_type::retrieve;
    job.status = job_status::pending;
    job.priority = priority;
    job.source_node_id = std::string(source_node_id);
    job.study_uid = std::string(study_uid);
    if (series_uid) {
        job.series_uid = std::string(*series_uid);
    }
    job.created_at = std::chrono::system_clock::now();
 
    impl_->save_job(job);
    impl_->logger->info_fmt("Created retrieve job {}: study={}", job.job_id, study_uid);
 
    return job.job_id;
}

References impl_, kcenon::pacs::client::job_manager::impl::logger, kcenon::pacs::client::pending, kcenon::pacs::client::retrieve, and kcenon::pacs::client::job_manager::impl::save_job().

Here is the call graph for this function:

◆ create_store_job()

std::string kcenon::pacs::client::job_manager::create_store_job	(	std::string_view	destination_node_id,
		const std::vector< std::string > &	instance_uids,
		job_priority	priority = job_priority::normal ) -> std::string

nodiscard

Create a store job (C-STORE)

Creates a job to store DICOM objects to a remote node.

Parameters

destination_node_id	ID of the destination remote node
instance_uids	SOP Instance UIDs to store
priority	Job priority (default: normal)

Returns: Unique job ID

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

Definition at line 1184 of file job_manager.cpp.

                           {
 
    job_record job;
    job.job_id = generate_uuid();
    job.type = job_type::store;
    job.status = job_status::pending;
    job.priority = priority;
    job.destination_node_id = std::string(destination_node_id);
    job.instance_uids = instance_uids;
    job.progress.total_items = instance_uids.size();
    job.created_at = std::chrono::system_clock::now();
 
    impl_->save_job(job);
    impl_->logger->info_fmt("Created store job {}: {} instances to {}",
                             job.job_id, instance_uids.size(), destination_node_id);
 
    return job.job_id;
}

References impl_, kcenon::pacs::client::job_manager::impl::logger, kcenon::pacs::client::pending, kcenon::pacs::client::job_manager::impl::save_job(), and kcenon::pacs::client::store.

Here is the call graph for this function:

◆ create_sync_job()

std::string kcenon::pacs::client::job_manager::create_sync_job	(	std::string_view	source_node_id,
		std::optional< std::string_view >	patient_id = std::nullopt,
		job_priority	priority = job_priority::low ) -> std::string

nodiscard

Create a sync job.

Creates a job to synchronize data with a remote node.

Parameters

source_node_id	ID of the source remote node
patient_id	Optional patient ID filter
priority	Job priority (default: low for background sync)

Returns: Unique job ID

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

Definition at line 1230 of file job_manager.cpp.

                           {
 
    job_record job;
    job.job_id = generate_uuid();
    job.type = job_type::sync;
    job.status = job_status::pending;
    job.priority = priority;
    job.source_node_id = std::string(source_node_id);
    if (patient_id) {
        job.patient_id = std::string(*patient_id);
    }
    job.created_at = std::chrono::system_clock::now();
 
    impl_->save_job(job);
    impl_->logger->info_fmt("Created sync job {}: from {}", job.job_id, source_node_id);
 
    return job.job_id;
}

References impl_, kcenon::pacs::client::job_manager::impl::logger, kcenon::pacs::client::pending, kcenon::pacs::client::job_manager::impl::save_job(), and kcenon::pacs::client::sync.

Here is the call graph for this function:

◆ delete_job()

kcenon::pacs::VoidResult kcenon::pacs::client::job_manager::delete_job ( std::string_view job_id ) -> kcenon::pacs::VoidResult

nodiscard

Delete a job.

Removes a job from the system. Running jobs are cancelled first.

Parameters

job_id The job ID to delete

Returns: VoidResult indicating success or error

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

Definition at line 1426 of file job_manager.cpp.

                                                                  {
    auto job_opt = impl_->get_job_from_cache(job_id);
    if (!job_opt) {
        return kcenon::pacs::pacs_void_error(
            kcenon::pacs::error_codes::not_found,
            "Job not found: " + std::string(job_id));
    }
 
    // Cancel if not terminal
    if (!job_opt->is_finished()) {
        auto cancel_result = cancel_job(job_id);
        if (cancel_result.is_err()) {
            return cancel_result;
        }
    }
 
    // Remove from cache
    {
        std::unique_lock lock(impl_->cache_mutex);
        impl_->job_cache.erase(std::string(job_id));
    }
 
    // Remove from repository
    if (impl_->repo) {
        [[maybe_unused]] auto result = impl_->repo->remove(std::string(job_id));
    }
 
    impl_->logger->info_fmt("Deleted job {}", job_id);
    return kcenon::pacs::ok();
}

References kcenon::pacs::client::job_manager::impl::cache_mutex, cancel_job(), kcenon::pacs::client::job_manager::impl::get_job_from_cache(), impl_, kcenon::pacs::client::job_manager::impl::job_cache, kcenon::pacs::client::job_manager::impl::logger, kcenon::pacs::pacs_void_error(), and kcenon::pacs::client::job_manager::impl::repo.

Here is the call graph for this function:

◆ failed_jobs_today()

size_t kcenon::pacs::client::job_manager::failed_jobs_today ( ) const -> size_t

nodiscard

Get number of jobs failed today.

Returns: Number of failures today

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

Definition at line 1647 of file job_manager.cpp.

                                            {
    if (impl_->repo) {
#ifdef PACS_WITH_DATABASE_SYSTEM
        auto result = impl_->repo->count_failed_today();
        if (result.is_ok()) {
            return result.value();
        }
        return 0;
#else
        return impl_->repo->count_failed_today();
#endif
    }
    return 0;
}

References impl_, and kcenon::pacs::client::job_manager::impl::repo.

◆ get_job()

std::optional< job_record > kcenon::pacs::client::job_manager::get_job ( std::string_view job_id ) const -> std::optional<job_record>

nodiscard

Get a job by ID.

Parameters

job_id The job ID to retrieve

Returns: Optional containing the job if found

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

Definition at line 1461 of file job_manager.cpp.

                                                                        {
    return impl_->get_job_from_cache(job_id);
}

References kcenon::pacs::client::job_manager::impl::get_job_from_cache(), and impl_.

Here is the call graph for this function:

◆ get_progress()

job_progress kcenon::pacs::client::job_manager::get_progress ( std::string_view job_id ) const -> job_progress

nodiscard

Get current progress for a job.

Parameters

job_id The job ID

Returns: Current progress information

Definition at line 1533 of file job_manager.cpp.

                                                                  {
    auto job_opt = impl_->get_job_from_cache(job_id);
    if (job_opt) {
        return job_opt->progress;
    }
    return {};
}

References kcenon::pacs::client::job_manager::impl::get_job_from_cache(), and impl_.

Here is the call graph for this function:

◆ is_running()

bool kcenon::pacs::client::job_manager::is_running ( ) const -> bool

nodiscardnoexcept

Check if workers are running.

Returns: true if worker threads are active

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

Definition at line 1614 of file job_manager.cpp.

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

References impl_, and kcenon::pacs::client::job_manager::impl::running.

◆ list_jobs()

std::vector< job_record > kcenon::pacs::client::job_manager::list_jobs	(	std::optional< job_status >	status = std::nullopt,
		std::optional< job_type >	type = std::nullopt,
		size_t	limit = 100,
		size_t	offset = 0 ) const -> std::vector<job_record>

nodiscard

List jobs with optional filters.

Parameters

status	Optional status filter
type	Optional type filter
limit	Maximum results (default: 100)
offset	Result offset for pagination

Returns: Vector of matching jobs

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

Definition at line 1465 of file job_manager.cpp.

                         {
 
    if (impl_->repo) {
        storage::job_query_options options;
        options.status = status;
        options.type = type;
        options.limit = limit;
        options.offset = offset;
#ifdef PACS_WITH_DATABASE_SYSTEM
        auto result = impl_->repo->find_jobs(options);
        if (result.is_ok()) {
            return result.value();
        }
        return {};
#else
        return impl_->repo->find_jobs(options);
#endif
    }
 
    // Fallback to cache
    std::vector<job_record> result;
    std::shared_lock lock(impl_->cache_mutex);
    for (const auto& [_, job] : impl_->job_cache) {
        if (status && job.status != *status) continue;
        if (type && job.type != *type) continue;
        if (offset > 0) {
            --offset;
            continue;
        }
        result.push_back(job);
        if (result.size() >= limit) break;
    }
    return result;
}

References kcenon::pacs::client::job_manager::impl::cache_mutex, impl_, kcenon::pacs::client::job_manager::impl::job_cache, kcenon::pacs::client::job_manager::impl::repo, and kcenon::pacs::storage::job_query_options::status.

◆ list_jobs_by_node()

std::vector< job_record > kcenon::pacs::client::job_manager::list_jobs_by_node ( std::string_view node_id ) const -> std::vector<job_record>

nodiscard

List jobs by node ID.

Returns jobs that involve the specified node as source or destination.

Parameters

node_id The node ID to filter by

Returns: Vector of jobs involving the node

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

Definition at line 1504 of file job_manager.cpp.

                                                                                 {
    if (impl_->repo) {
#ifdef PACS_WITH_DATABASE_SYSTEM
        auto result = impl_->repo->find_by_node(node_id);
        if (result.is_ok()) {
            return result.value();
        }
        return {};
#else
        return impl_->repo->find_by_node(node_id);
#endif
    }
 
    // Fallback to cache
    std::vector<job_record> result;
    std::shared_lock lock(impl_->cache_mutex);
    std::string node_str(node_id);
    for (const auto& [_, job] : impl_->job_cache) {
        if (job.source_node_id == node_str || job.destination_node_id == node_str) {
            result.push_back(job);
        }
    }
    return result;
}

References kcenon::pacs::client::job_manager::impl::cache_mutex, impl_, kcenon::pacs::client::job_manager::impl::job_cache, and kcenon::pacs::client::job_manager::impl::repo.

◆ operator=() [1/2]

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

delete

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

◆ operator=() [2/2]

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

delete

◆ pause_job()

kcenon::pacs::VoidResult kcenon::pacs::client::job_manager::pause_job ( std::string_view job_id ) -> kcenon::pacs::VoidResult

nodiscard

Pause a running or queued job.

Parameters

job_id The job ID to pause

Returns: VoidResult indicating success or error

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

Definition at line 1305 of file job_manager.cpp.

                                                                 {
    auto job_opt = impl_->get_job_from_cache(job_id);
    if (!job_opt) {
        return kcenon::pacs::pacs_void_error(
            kcenon::pacs::error_codes::not_found,
            "Job not found: " + std::string(job_id));
    }
 
    if (!job_opt->can_pause()) {
        return kcenon::pacs::pacs_void_error(
            kcenon::pacs::error_codes::invalid_argument,
            "Job cannot be paused in current state: " + std::string(to_string(job_opt->status)));
    }
 
    {
        std::lock_guard lock(impl_->paused_mutex);
        impl_->paused_job_ids.insert(std::string(job_id));
    }
    impl_->update_job_status(std::string(job_id), job_status::paused);
 
    impl_->logger->info_fmt("Paused job {}", job_id);
    return kcenon::pacs::ok();
}

References kcenon::pacs::client::job_manager::impl::get_job_from_cache(), impl_, kcenon::pacs::client::job_manager::impl::logger, kcenon::pacs::pacs_void_error(), kcenon::pacs::client::paused, kcenon::pacs::client::job_manager::impl::paused_job_ids, kcenon::pacs::client::job_manager::impl::paused_mutex, kcenon::pacs::client::to_string(), and kcenon::pacs::client::job_manager::impl::update_job_status().

Here is the call graph for this function:

◆ pending_jobs()

size_t kcenon::pacs::client::job_manager::pending_jobs ( ) const -> size_t

nodiscard

Get number of pending jobs.

Returns: Number of jobs waiting in queue

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

Definition at line 1627 of file job_manager.cpp.

                                       {
    std::lock_guard lock(impl_->queue_mutex);
    return impl_->job_queue.size();
}

References impl_, kcenon::pacs::client::job_manager::impl::job_queue, and kcenon::pacs::client::job_manager::impl::queue_mutex.

◆ resume_job()

kcenon::pacs::VoidResult kcenon::pacs::client::job_manager::resume_job ( std::string_view job_id ) -> kcenon::pacs::VoidResult

nodiscard

Resume a paused job.

Parameters

job_id The job ID to resume

Returns: VoidResult indicating success or error

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

Definition at line 1329 of file job_manager.cpp.

                                                                  {
    auto job_opt = impl_->get_job_from_cache(job_id);
    if (!job_opt) {
        return kcenon::pacs::pacs_void_error(
            kcenon::pacs::error_codes::not_found,
            "Job not found: " + std::string(job_id));
    }
 
    if (job_opt->status != job_status::paused) {
        return kcenon::pacs::pacs_void_error(
            kcenon::pacs::error_codes::invalid_argument,
            "Job is not paused: " + std::string(to_string(job_opt->status)));
    }
 
    {
        std::lock_guard lock(impl_->paused_mutex);
        impl_->paused_job_ids.erase(std::string(job_id));
    }
    impl_->update_job_status(std::string(job_id), job_status::queued);
 
    impl_->logger->info_fmt("Resumed job {}", job_id);
    return kcenon::pacs::ok();
}

References kcenon::pacs::client::job_manager::impl::get_job_from_cache(), impl_, kcenon::pacs::client::job_manager::impl::logger, kcenon::pacs::pacs_void_error(), kcenon::pacs::client::paused, kcenon::pacs::client::job_manager::impl::paused_job_ids, kcenon::pacs::client::job_manager::impl::paused_mutex, kcenon::pacs::client::queued, kcenon::pacs::client::to_string(), and kcenon::pacs::client::job_manager::impl::update_job_status().

Here is the call graph for this function:

◆ retry_job()

kcenon::pacs::VoidResult kcenon::pacs::client::job_manager::retry_job ( std::string_view job_id ) -> kcenon::pacs::VoidResult

nodiscard

Retry a failed job.

Resets a failed job and queues it for re-execution.

Parameters

job_id The job ID to retry

Returns: VoidResult indicating success or error

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

Definition at line 1388 of file job_manager.cpp.

                                                                 {
    auto job_opt = impl_->get_job_from_cache(job_id);
    if (!job_opt) {
        return kcenon::pacs::pacs_void_error(
            kcenon::pacs::error_codes::not_found,
            "Job not found: " + std::string(job_id));
    }
 
    if (!job_opt->can_retry()) {
        return kcenon::pacs::pacs_void_error(
            kcenon::pacs::error_codes::invalid_argument,
            "Job cannot be retried: " + std::string(to_string(job_opt->status)));
    }
 
    // Reset job state
    {
        std::unique_lock lock(impl_->cache_mutex);
        auto it = impl_->job_cache.find(std::string(job_id));
        if (it != impl_->job_cache.end()) {
            it->second.status = job_status::pending;
            it->second.retry_count++;
            it->second.error_message.clear();
            it->second.error_details.clear();
            it->second.started_at = std::nullopt;
            it->second.completed_at = std::nullopt;
            it->second.progress = job_progress{};
        }
    }
 
    if (impl_->repo) {
        [[maybe_unused]] auto result = impl_->repo->increment_retry(job_id);
        [[maybe_unused]] auto status_result = impl_->repo->update_status(job_id, job_status::pending);
    }
 
    impl_->logger->info_fmt("Retrying job {} (attempt {})", job_id, job_opt->retry_count + 1);
    return kcenon::pacs::ok();
}

References kcenon::pacs::client::job_manager::impl::cache_mutex, kcenon::pacs::client::job_manager::impl::get_job_from_cache(), impl_, kcenon::pacs::client::job_manager::impl::job_cache, kcenon::pacs::client::job_manager::impl::logger, kcenon::pacs::pacs_void_error(), kcenon::pacs::client::pending, kcenon::pacs::client::job_manager::impl::repo, and kcenon::pacs::client::to_string().

Here is the call graph for this function:

◆ set_completion_callback()

void kcenon::pacs::client::job_manager::set_completion_callback ( job_completion_callback callback )

Set the completion callback.

The callback is invoked when a job completes (success, failure, or cancel). Only one callback can be set; setting a new one replaces the old.

Parameters

callback Function to call on job completion

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

Definition at line 1546 of file job_manager.cpp.

                                                                          {
    std::unique_lock lock(impl_->callbacks_mutex);
    impl_->completion_callback = std::move(callback);
}

References kcenon::pacs::client::job_manager::impl::callbacks_mutex, kcenon::pacs::client::job_manager::impl::completion_callback, and impl_.

◆ set_progress_callback()

void kcenon::pacs::client::job_manager::set_progress_callback ( job_progress_callback callback )

Set the progress callback.

The callback is invoked whenever job progress is updated. Only one callback can be set; setting a new one replaces the old.

Parameters

callback Function to call on progress updates

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

Definition at line 1541 of file job_manager.cpp.

                                                                      {
    std::unique_lock lock(impl_->callbacks_mutex);
    impl_->progress_callback = std::move(callback);
}

References kcenon::pacs::client::job_manager::impl::callbacks_mutex, impl_, and kcenon::pacs::client::job_manager::impl::progress_callback.

◆ start_job()

kcenon::pacs::VoidResult kcenon::pacs::client::job_manager::start_job ( std::string_view job_id ) -> kcenon::pacs::VoidResult

nodiscard

Start a pending job.

Moves a pending job to the execution queue.

Parameters

job_id The job ID to start

Returns: VoidResult indicating success or error

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

Definition at line 1276 of file job_manager.cpp.

                                                                 {
    auto job_opt = impl_->get_job_from_cache(job_id);
    if (!job_opt) {
        return kcenon::pacs::pacs_void_error(
            kcenon::pacs::error_codes::not_found,
            "Job not found: " + std::string(job_id));
    }
 
    if (!job_opt->can_start()) {
        return kcenon::pacs::pacs_void_error(
            kcenon::pacs::error_codes::invalid_argument,
            "Job cannot be started in current state: " + std::string(to_string(job_opt->status)));
    }
 
    // Update status and enqueue
    impl_->update_job_status(std::string(job_id), job_status::queued);
    {
        std::unique_lock lock(impl_->cache_mutex);
        auto it = impl_->job_cache.find(std::string(job_id));
        if (it != impl_->job_cache.end()) {
            it->second.queued_at = std::chrono::system_clock::now();
        }
    }
    impl_->enqueue_job(std::string(job_id), job_opt->priority);
 
    impl_->logger->info_fmt("Started job {}", job_id);
    return kcenon::pacs::ok();
}

References kcenon::pacs::client::job_manager::impl::cache_mutex, kcenon::pacs::client::job_manager::impl::enqueue_job(), kcenon::pacs::client::job_manager::impl::get_job_from_cache(), impl_, kcenon::pacs::client::job_manager::impl::job_cache, kcenon::pacs::client::job_manager::impl::logger, kcenon::pacs::pacs_void_error(), kcenon::pacs::client::queued, kcenon::pacs::client::to_string(), and kcenon::pacs::client::job_manager::impl::update_job_status().

Here is the call graph for this function:

◆ start_workers()

void kcenon::pacs::client::job_manager::start_workers ( )

Start the worker threads.

Starts the configured number of worker threads. Does nothing if already running.

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

Definition at line 1579 of file job_manager.cpp.

                                {
    if (impl_->running.load()) {
        return;
    }
 
    impl_->running.store(true);
    impl_->workers.reserve(impl_->config.worker_count);
 
    for (size_t i = 0; i < impl_->config.worker_count; ++i) {
        impl_->workers.emplace_back([this]() {
            impl_->worker_loop();
        });
    }
 
    impl_->logger->info_fmt("Started {} worker threads", impl_->config.worker_count);
}

References kcenon::pacs::client::job_manager::impl::config, impl_, kcenon::pacs::client::job_manager::impl::logger, kcenon::pacs::client::job_manager::impl::running, kcenon::pacs::client::job_manager_config::worker_count, kcenon::pacs::client::job_manager::impl::worker_loop(), and kcenon::pacs::client::job_manager::impl::workers.

Here is the call graph for this function:

◆ stop_workers()

void kcenon::pacs::client::job_manager::stop_workers ( )

Stop the worker threads.

Gracefully stops all worker threads. Running jobs are allowed to complete or timeout.

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

Definition at line 1596 of file job_manager.cpp.

                               {
    if (!impl_->running.load()) {
        return;
    }
 
    impl_->running.store(false);
    impl_->queue_cv.notify_all();
 
    for (auto& worker : impl_->workers) {
        if (worker.joinable()) {
            worker.join();
        }
    }
    impl_->workers.clear();
 
    impl_->logger->info("Stopped worker threads");
}

References impl_, kcenon::pacs::client::job_manager::impl::logger, kcenon::pacs::client::job_manager::impl::queue_cv, kcenon::pacs::client::job_manager::impl::running, and kcenon::pacs::client::job_manager::impl::workers.

Referenced by ~job_manager().

Here is the caller graph for this function:

◆ wait_for_completion()

std::future< job_record > kcenon::pacs::client::job_manager::wait_for_completion ( std::string_view job_id ) -> std::future<job_record>

nodiscard

Wait for a job to complete.

Returns a future that completes when the job finishes.

Parameters

job_id The job ID to wait for

Returns: Future containing the final job record

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

Definition at line 1555 of file job_manager.cpp.

                                                                            {
    auto promise = std::make_shared<std::promise<job_record>>();
    auto future = promise->get_future();
 
    // Check if already completed
    auto job_opt = impl_->get_job_from_cache(job_id);
    if (job_opt && job_opt->is_finished()) {
        promise->set_value(*job_opt);
        return future;
    }
 
    // Store promise for later fulfillment
    {
        std::lock_guard lock(impl_->promises_mutex);
        impl_->completion_promises[std::string(job_id)] = promise;
    }
 
    return future;
}

References kcenon::pacs::client::job_manager::impl::completion_promises, kcenon::pacs::client::job_manager::impl::get_job_from_cache(), impl_, and kcenon::pacs::client::job_manager::impl::promises_mutex.

Here is the call graph for this function:

Member Data Documentation

◆ impl_

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

private

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

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

Classes

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ job_manager() [1/4]

◆ job_manager() [2/4]

◆ ~job_manager()

◆ job_manager() [3/4]

◆ job_manager() [4/4]

Member Function Documentation

◆ active_jobs()

◆ cancel_job()

◆ completed_jobs_today()

◆ config()

◆ create_prefetch_job()

◆ create_query_job()

◆ create_retrieve_job()

◆ create_store_job()

◆ create_sync_job()

◆ delete_job()

◆ failed_jobs_today()

◆ get_job()

◆ get_progress()

◆ is_running()

◆ list_jobs()

◆ list_jobs_by_node()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ pause_job()

◆ pending_jobs()

◆ resume_job()

◆ retry_job()

◆ set_completion_callback()

◆ set_progress_callback()

◆ start_job()

◆ start_workers()

◆ stop_workers()

◆ wait_for_completion()

Member Data Documentation

◆ impl_