#include <server_app.h>

Collaboration diagram for kcenon::pacs::example::pacs_server_app:

Public Member Functions
	pacs_server_app (const pacs_server_config &config)
	Construct server application with configuration.

	~pacs_server_app ()
	Destructor - stops server if running.

	pacs_server_app (const pacs_server_app &)=delete

pacs_server_app &	operator= (const pacs_server_app &)=delete

	pacs_server_app (pacs_server_app &&)=delete

pacs_server_app &	operator= (pacs_server_app &&)=delete

bool	initialize ()
	Initialize all components.

bool	start ()
	Start the DICOM server.

void	stop ()
	Stop the server gracefully.

void	wait_for_shutdown ()
	Wait for server shutdown.

void	request_shutdown ()
	Request shutdown.

bool	is_running () const noexcept
	Check if server is running.

void	print_statistics () const
	Get current server statistics.

Private Member Functions
bool	setup_storage ()
	Set up file storage.

bool	setup_database ()
	Set up database.

bool	setup_services ()
	Set up DICOM services.

bool	setup_server ()
	Set up DICOM server.

services::storage_status	handle_store (const core::dicom_dataset &dataset, const std::string &calling_ae, const std::string &sop_class_uid, const std::string &sop_instance_uid)
	Handle incoming C-STORE request.

std::vector< core::dicom_dataset >	handle_query (services::query_level level, const core::dicom_dataset &query_keys, const std::string &calling_ae)
	Handle C-FIND query.

std::vector< core::dicom_file >	handle_retrieve (const core::dicom_dataset &query_keys)
	Handle C-MOVE/C-GET retrieve.

std::vector< core::dicom_dataset >	handle_worklist_query (const core::dicom_dataset &query_keys, const std::string &calling_ae)
	Handle worklist query.

network::Result< std::monostate >	handle_mpps_create (const services::mpps_instance &instance)
	Handle MPPS N-CREATE.

network::Result< std::monostate >	handle_mpps_set (const std::string &sop_instance_uid, const core::dicom_dataset &modifications, services::mpps_status new_status)
	Handle MPPS N-SET.

Private Attributes
pacs_server_config	config_
	Server configuration.

std::unique_ptr< network::dicom_server >	server_
	DICOM server.

std::unique_ptr< storage::file_storage >	file_storage_
	File storage.

std::unique_ptr< storage::index_database >	database_
	Index database.

std::atomic< bool >	shutdown_requested_ {false}
	Shutdown flag.

bool	initialized_ {false}
	Initialization flag.

Detailed Description

Examples: pacs_server/main.cpp.

Definition at line 90 of file server_app.h.

Constructor & Destructor Documentation

◆ pacs_server_app() [1/3]

kcenon::pacs::example::pacs_server_app::pacs_server_app ( const pacs_server_config & config )

explicit

Construct server application with configuration.

Parameters

config Server configuration

Definition at line 56 of file server_app.cpp.

57 : config_(config) {}

kcenon::pacs::example::pacs_server_app::config_

pacs_server_config config_

Server configuration.

Definition server_app.h:233

◆ ~pacs_server_app()

kcenon::pacs::example::pacs_server_app::~pacs_server_app ( )

Destructor - stops server if running.

Definition at line 59 of file server_app.cpp.

                                  {
    stop();
}

References stop().

Here is the call graph for this function:

◆ pacs_server_app() [2/3]

kcenon::pacs::example::pacs_server_app::pacs_server_app ( const pacs_server_app & )

delete

◆ pacs_server_app() [3/3]

kcenon::pacs::example::pacs_server_app::pacs_server_app ( pacs_server_app && )

delete

Member Function Documentation

◆ handle_mpps_create()

network::Result< std::monostate > kcenon::pacs::example::pacs_server_app::handle_mpps_create ( const services::mpps_instance & instance )

private

Handle MPPS N-CREATE.

Definition at line 659 of file server_app.cpp.

                                           {
 
    std::cout << log_prefix() << "MPPS N-CREATE: " << instance.sop_instance_uid << "\n";
 
    auto result = database_->create_mpps(
        instance.sop_instance_uid,
        instance.station_ae
    );
 
    if (result.is_err()) {
        return kcenon::common::make_error<std::monostate>(1, "MPPS creation failed");
    }
 
    return network::Result<std::monostate>(std::monostate{});
}

References database_, kcenon::pacs::services::mpps_instance::sop_instance_uid, and kcenon::pacs::services::mpps_instance::station_ae.

Referenced by setup_server().

Here is the caller graph for this function:

◆ handle_mpps_set()

network::Result< std::monostate > kcenon::pacs::example::pacs_server_app::handle_mpps_set	(	const std::string &	sop_instance_uid,
		const core::dicom_dataset &	modifications,
		services::mpps_status	new_status )

private

Handle MPPS N-SET.

Definition at line 676 of file server_app.cpp.

                                    {
 
    std::cout << log_prefix() << "MPPS N-SET: " << sop_instance_uid
              << " -> " << services::to_string(new_status) << "\n";
 
    auto result = database_->update_mpps(
        sop_instance_uid,
        std::string(services::to_string(new_status))
    );
 
    if (result.is_err()) {
        return kcenon::common::make_error<std::monostate>(1, "MPPS update failed");
    }
 
    return network::Result<std::monostate>(std::monostate{});
}

References database_, and kcenon::pacs::services::to_string().

Referenced by setup_server().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_query()

std::vector< core::dicom_dataset > kcenon::pacs::example::pacs_server_app::handle_query	(	services::query_level	level,
		const core::dicom_dataset &	query_keys,
		const std::string &	calling_ae )

private

Handle C-FIND query.

Definition at line 458 of file server_app.cpp.

                                 {
 
    std::cout << log_prefix() << "C-FIND from " << calling_ae
              << " at level " << services::to_string(level) << "\n";
 
    std::vector<core::dicom_dataset> results;
 
    switch (level) {
        case services::query_level::patient: {
            storage::patient_query query;
            auto id = query_keys.get_string(core::tags::patient_id);
            if (!id.empty()) {
                query.patient_id = id;
            }
            auto name = query_keys.get_string(core::tags::patient_name);
            if (!name.empty()) {
                query.patient_name = name;
            }
 
            auto patients_result = database_->search_patients(query);
            if (patients_result.is_ok()) {
                for (const auto& patient : patients_result.value()) {
                    core::dicom_dataset ds;
                    ds.set_string(core::tags::patient_id, encoding::vr_type::LO, patient.patient_id);
                    ds.set_string(core::tags::patient_name, encoding::vr_type::PN, patient.patient_name);
                    ds.set_string(core::tags::patient_birth_date, encoding::vr_type::DA, patient.birth_date);
                    ds.set_string(core::tags::patient_sex, encoding::vr_type::CS, patient.sex);
                    results.push_back(std::move(ds));
                }
            }
            break;
        }
 
        case services::query_level::study: {
            storage::study_query query;
            auto id = query_keys.get_string(core::tags::patient_id);
            if (!id.empty()) {
                query.patient_id = id;
            }
            auto uid = query_keys.get_string(core::tags::study_instance_uid);
            if (!uid.empty()) {
                query.study_uid = uid;
            }
            auto date = query_keys.get_string(core::tags::study_date);
            if (!date.empty()) {
                query.study_date = date;
            }
 
            auto studies_result = database_->search_studies(query);
            if (studies_result.is_ok()) {
                for (const auto& study : studies_result.value()) {
                    core::dicom_dataset ds;
                    ds.set_string(core::tags::study_instance_uid, encoding::vr_type::UI, study.study_uid);
                    ds.set_string(core::tags::study_date, encoding::vr_type::DA, study.study_date);
                    ds.set_string(core::tags::study_time, encoding::vr_type::TM, study.study_time);
                    ds.set_string(core::tags::accession_number, encoding::vr_type::SH, study.accession_number);
                    ds.set_string(core::tags::study_description, encoding::vr_type::LO, study.study_description);
                    results.push_back(std::move(ds));
                }
            }
            break;
        }
 
        case services::query_level::series: {
            storage::series_query query;
            auto uid = query_keys.get_string(core::tags::study_instance_uid);
            if (!uid.empty()) {
                query.study_uid = uid;
            }
            auto mod = query_keys.get_string(core::tags::modality);
            if (!mod.empty()) {
                query.modality = mod;
            }
 
            auto series_result = database_->search_series(query);
            if (series_result.is_ok()) {
                for (const auto& series : series_result.value()) {
                    core::dicom_dataset ds;
                    ds.set_string(core::tags::series_instance_uid, encoding::vr_type::UI, series.series_uid);
                    ds.set_string(core::tags::modality, encoding::vr_type::CS, series.modality);
                    if (series.series_number.has_value()) {
                        ds.set_string(core::tags::series_number, encoding::vr_type::IS,
                                      std::to_string(series.series_number.value()));
                    }
                    ds.set_string(core::tags::series_description, encoding::vr_type::LO, series.series_description);
                    results.push_back(std::move(ds));
                }
            }
            break;
        }
 
        case services::query_level::image: {
            storage::instance_query query;
            auto uid = query_keys.get_string(core::tags::series_instance_uid);
            if (!uid.empty()) {
                query.series_uid = uid;
            }
 
            auto instances_result = database_->search_instances(query);
            if (instances_result.is_ok()) {
                for (const auto& instance : instances_result.value()) {
                    core::dicom_dataset ds;
                    ds.set_string(core::tags::sop_instance_uid, encoding::vr_type::UI, instance.sop_uid);
                    ds.set_string(core::tags::sop_class_uid, encoding::vr_type::UI, instance.sop_class_uid);
                    if (instance.instance_number.has_value()) {
                        ds.set_string(core::tags::instance_number, encoding::vr_type::IS,
                                      std::to_string(instance.instance_number.value()));
                    }
                    results.push_back(std::move(ds));
                }
            }
            break;
        }
    }
 
    std::cout << log_prefix() << "  Found " << results.size() << " matches\n";
    return results;
}

Referenced by setup_server().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_retrieve()

std::vector< core::dicom_file > kcenon::pacs::example::pacs_server_app::handle_retrieve ( const core::dicom_dataset & query_keys )

private

Handle C-MOVE/C-GET retrieve.

Definition at line 580 of file server_app.cpp.

                                         {
 
    std::cout << log_prefix() << "C-MOVE/C-GET retrieve request\n";
 
    std::vector<core::dicom_file> files;
    std::vector<std::string> file_paths;
 
    // Determine query level and get file paths
    auto sop_uid = query_keys.get_string(core::tags::sop_instance_uid);
    if (!sop_uid.empty()) {
        // Instance level
        auto path_result = database_->get_file_path(sop_uid);
        if (path_result.is_ok() && path_result.value().has_value()) {
            file_paths.push_back(path_result.value().value());
        }
    } else {
        auto series_uid = query_keys.get_string(core::tags::series_instance_uid);
        if (!series_uid.empty()) {
            // Series level
            auto series_files_result = database_->get_series_files(series_uid);
            if (series_files_result.is_ok()) {
                file_paths = std::move(series_files_result.value());
            }
        } else {
            auto study_uid = query_keys.get_string(core::tags::study_instance_uid);
            if (!study_uid.empty()) {
                // Study level
                auto study_files_result = database_->get_study_files(study_uid);
                if (study_files_result.is_ok()) {
                    file_paths = std::move(study_files_result.value());
                }
            }
        }
    }
 
    // Load files
    for (const auto& path : file_paths) {
        auto file_result = core::dicom_file::open(path);
        if (file_result.is_ok()) {
            files.push_back(std::move(file_result.value()));
        }
    }
 
    std::cout << log_prefix() << "  Found " << files.size() << " files to transfer\n";
    return files;
}

References database_, kcenon::pacs::core::dicom_dataset::get_string(), kcenon::pacs::core::dicom_file::open(), kcenon::pacs::core::tags::series_instance_uid, kcenon::pacs::core::tags::sop_instance_uid, and kcenon::pacs::core::tags::study_instance_uid.

Referenced by setup_server().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_store()

services::storage_status kcenon::pacs::example::pacs_server_app::handle_store	(	const core::dicom_dataset &	dataset,
		const std::string &	calling_ae,
		const std::string &	sop_class_uid,
		const std::string &	sop_instance_uid )

private

Handle incoming C-STORE request.

Definition at line 325 of file server_app.cpp.

                                       {
 
    std::cout << log_prefix() << "C-STORE from " << calling_ae
              << ": " << sop_instance_uid << "\n";
 
    // Store to filesystem
    auto store_result = file_storage_->store(dataset);
    if (store_result.is_err()) {
        std::cerr << log_prefix() << "Storage error\n";
        return services::storage_status::storage_error;
    }
 
    // Index in database
    auto patient_id = dataset.get_string(core::tags::patient_id);
    auto patient_name = dataset.get_string(core::tags::patient_name);
    auto study_uid = dataset.get_string(core::tags::study_instance_uid);
    auto series_uid = dataset.get_string(core::tags::series_instance_uid);
 
    if (patient_id.empty()) {
        std::cerr << log_prefix() << "Warning: Missing PatientID\n";
        return services::storage_status::success;
    }
 
    // Upsert patient and get pk
    auto birth_date = dataset.get_string(core::tags::patient_birth_date);
    auto sex = dataset.get_string(core::tags::patient_sex);
    auto patient_result = database_->upsert_patient(
        patient_id,
        patient_name,
        birth_date,
        sex
    );
    if (patient_result.is_err()) {
        std::cerr << log_prefix() << "Database error (patient)\n";
        return services::storage_status::success;
    }
    int64_t patient_pk = patient_result.value();
 
    // Upsert study if we have study_uid
    int64_t study_pk = 0;
    if (!study_uid.empty()) {
        auto study_date = dataset.get_string(core::tags::study_date);
        auto study_time = dataset.get_string(core::tags::study_time);
        auto accession = dataset.get_string(core::tags::accession_number);
        auto study_desc = dataset.get_string(core::tags::study_description);
        auto referring = dataset.get_string(core::tags::referring_physician_name);
        auto study_id = dataset.get_string(core::tags::study_id);
 
        auto study_result = database_->upsert_study(
            patient_pk,
            study_uid,
            study_id,
            study_date,
            study_time,
            accession,
            referring,
            study_desc
        );
        if (study_result.is_err()) {
            std::cerr << log_prefix() << "Database error (study)\n";
            return services::storage_status::success;
        }
        study_pk = study_result.value();
    }
 
    // Upsert series if we have series_uid and study_pk
    int64_t series_pk = 0;
    if (!series_uid.empty() && study_pk > 0) {
        auto modality = dataset.get_string(core::tags::modality);
        auto series_number_str = dataset.get_string(core::tags::series_number);
        auto series_desc = dataset.get_string(core::tags::series_description);
 
        std::optional<int> series_number;
        if (!series_number_str.empty()) {
            try {
                series_number = std::stoi(series_number_str);
            } catch (...) {}
        }
 
        auto series_result = database_->upsert_series(
            study_pk,
            series_uid,
            modality,
            series_number,
            series_desc,
            "",  // body_part_examined
            ""   // station_name
        );
        if (series_result.is_err()) {
            std::cerr << log_prefix() << "Database error (series)\n";
            return services::storage_status::success;
        }
        series_pk = series_result.value();
    }
 
    // Upsert instance if we have series_pk
    if (series_pk > 0) {
        auto instance_number_str = dataset.get_string(core::tags::instance_number);
        auto file_path = file_storage_->get_file_path(sop_instance_uid);
 
        int64_t file_size = 0;
        if (std::filesystem::exists(file_path)) {
            file_size = static_cast<int64_t>(std::filesystem::file_size(file_path));
        }
 
        std::optional<int> instance_number;
        if (!instance_number_str.empty()) {
            try {
                instance_number = std::stoi(instance_number_str);
            } catch (...) {}
        }
 
        auto instance_result = database_->upsert_instance(
            series_pk,
            sop_instance_uid,
            sop_class_uid,
            file_path.string(),
            file_size,
            "",  // transfer_syntax
            instance_number
        );
        if (instance_result.is_err()) {
            std::cerr << log_prefix() << "Database error (instance)\n";
        }
    }
 
    return services::storage_status::success;
}

Referenced by setup_server().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_worklist_query()

std::vector< core::dicom_dataset > kcenon::pacs::example::pacs_server_app::handle_worklist_query	(	const core::dicom_dataset &	query_keys,
		const std::string &	calling_ae )

private

Handle worklist query.

Definition at line 628 of file server_app.cpp.

                                 {
 
    std::cout << log_prefix() << "MWL query from " << calling_ae << "\n";
 
    std::vector<core::dicom_dataset> results;
 
    storage::worklist_query query;
    auto id = query_keys.get_string(core::tags::patient_id);
    if (!id.empty()) {
        query.patient_id = id;
    }
 
    auto items_result = database_->query_worklist(query);
 
    if (items_result.is_ok()) {
        for (const auto& item : items_result.value()) {
            core::dicom_dataset ds;
            ds.set_string(core::tags::patient_id, encoding::vr_type::LO, item.patient_id);
            ds.set_string(core::tags::patient_name, encoding::vr_type::PN, item.patient_name);
            ds.set_string(core::tags::accession_number, encoding::vr_type::SH, item.accession_no);
            ds.set_string(core::tags::study_instance_uid, encoding::vr_type::UI, item.study_uid);
            results.push_back(std::move(ds));
        }
    }
 
    std::cout << log_prefix() << "  Found " << results.size() << " worklist items\n";
    return results;
}

References kcenon::pacs::core::tags::accession_number, database_, kcenon::pacs::core::dicom_dataset::get_string(), kcenon::pacs::encoding::LO, kcenon::pacs::core::tags::patient_id, kcenon::pacs::core::tags::patient_name, kcenon::pacs::encoding::PN, kcenon::pacs::core::dicom_dataset::set_string(), kcenon::pacs::encoding::SH, kcenon::pacs::core::tags::study_instance_uid, and kcenon::pacs::encoding::UI.

Referenced by setup_server().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ initialize()

bool kcenon::pacs::example::pacs_server_app::initialize ( )

nodiscard

Initialize all components.

Sets up storage, database, and DICOM services. Must be called before start().

Returns: true if initialization succeeded

Definition at line 67 of file server_app.cpp.

                                 {
    std::cout << log_prefix() << "Initializing PACS Server...\n";
 
    if (!setup_storage()) {
        return false;
    }
 
    if (!setup_database()) {
        return false;
    }
 
    if (!setup_services()) {
        return false;
    }
 
    if (!setup_server()) {
        return false;
    }
 
    initialized_ = true;
    std::cout << log_prefix() << "PACS Server initialized successfully\n";
    return true;
}

References initialized_, setup_database(), setup_server(), setup_services(), and setup_storage().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_running()

bool kcenon::pacs::example::pacs_server_app::is_running ( ) const

nodiscardnoexcept

Check if server is running.

Returns: true if server is accepting connections

Definition at line 134 of file server_app.cpp.

                                                {
    return server_ && server_->is_running();
}

References server_.

◆ operator=() [1/2]

pacs_server_app & kcenon::pacs::example::pacs_server_app::operator= ( const pacs_server_app & )

delete

◆ operator=() [2/2]

pacs_server_app & kcenon::pacs::example::pacs_server_app::operator= ( pacs_server_app && )

delete

◆ print_statistics()

void kcenon::pacs::example::pacs_server_app::print_statistics ( ) const

Get current server statistics.

Definition at line 138 of file server_app.cpp.

                                             {
    if (!server_) {
        return;
    }
 
    auto stats = server_->get_statistics();
    auto uptime = stats.uptime();
 
    std::cout << "\n";
    std::cout << "=== PACS Server Statistics ===\n";
    std::cout << "Uptime: " << uptime.count() << " seconds\n";
    std::cout << "Total Associations: " << stats.total_associations << "\n";
    std::cout << "Active Associations: " << stats.active_associations << "\n";
    std::cout << "Rejected Associations: " << stats.rejected_associations << "\n";
    std::cout << "Messages Processed: " << stats.messages_processed << "\n";
    std::cout << "Bytes Received: " << stats.bytes_received << "\n";
    std::cout << "Bytes Sent: " << stats.bytes_sent << "\n";
    std::cout << "==============================\n";
    std::cout << "\n";
}

References server_.

Referenced by main().

Here is the caller graph for this function:

◆ request_shutdown()

void kcenon::pacs::example::pacs_server_app::request_shutdown ( )

Request shutdown.

Thread-safe method to request server shutdown. Typically called from signal handler.

Definition at line 129 of file server_app.cpp.

                                       {
    shutdown_requested_ = true;
    stop();
}

References shutdown_requested_, and stop().

Here is the call graph for this function:

◆ setup_database()

bool kcenon::pacs::example::pacs_server_app::setup_database ( )

nodiscardprivate

Set up database.

Definition at line 194 of file server_app.cpp.

                                     {
    std::cout << log_prefix() << "Setting up database...\n";
    std::cout << log_prefix() << "  Path: " << config_.database.path << "\n";
 
    // Create database directory if needed
    auto db_dir = config_.database.path.parent_path();
    if (!db_dir.empty()) {
        std::error_code ec;
        std::filesystem::create_directories(db_dir, ec);
        if (ec) {
            std::cerr << log_prefix() << "Error: Failed to create database directory: "
                      << ec.message() << "\n";
            return false;
        }
    }
 
    storage::index_config db_config;
    db_config.wal_mode = config_.database.wal_mode;
 
    auto result = storage::index_database::open(
        config_.database.path.string(), db_config);
 
    if (result.is_err()) {
        std::cerr << log_prefix() << "Error: Failed to open database\n";
        return false;
    }
 
    database_ = std::move(result.value());
    std::cout << log_prefix() << "Database ready\n";
    return true;
}

References config_, kcenon::pacs::example::pacs_server_config::database, database_, kcenon::pacs::storage::index_database::open(), kcenon::pacs::example::database_config::path, kcenon::pacs::example::database_config::wal_mode, and kcenon::pacs::storage::index_config::wal_mode.

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setup_server()

bool kcenon::pacs::example::pacs_server_app::setup_server ( )

nodiscardprivate

Set up DICOM server.

Definition at line 238 of file server_app.cpp.

                                   {
    std::cout << log_prefix() << "Setting up DICOM server...\n";
 
    network::server_config server_config;
    server_config.ae_title = config_.server.ae_title;
    server_config.port = config_.server.port;
    server_config.max_associations = config_.server.max_associations;
    server_config.idle_timeout = config_.server.idle_timeout;
 
    // Set up AE whitelist if configured
    if (!config_.access_control.allowed_ae_titles.empty()) {
        server_config.ae_whitelist = config_.access_control.allowed_ae_titles;
        server_config.accept_unknown_calling_ae = false;
    }
 
    server_ = std::make_unique<network::dicom_server>(server_config);
 
    // Register Verification SCP
    server_->register_service(std::make_shared<services::verification_scp>());
 
    // Register Storage SCP
    auto storage_scp = std::make_shared<services::storage_scp>();
    storage_scp->set_handler(
        [this](const auto& ds, const auto& ae, const auto& sop_class, const auto& sop_uid) {
            return handle_store(ds, ae, sop_class, sop_uid);
        });
    server_->register_service(storage_scp);
 
    // Register Query SCP
    auto query_scp = std::make_shared<services::query_scp>();
    query_scp->set_handler(
        [this](auto level, const auto& keys, const auto& ae) {
            return handle_query(level, keys, ae);
        });
    server_->register_service(query_scp);
 
    // Register Retrieve SCP
    auto retrieve_scp = std::make_shared<services::retrieve_scp>();
    retrieve_scp->set_retrieve_handler(
        [this](const auto& keys) {
            return handle_retrieve(keys);
        });
    server_->register_service(retrieve_scp);
 
    // Register Worklist SCP
    auto worklist_scp = std::make_shared<services::worklist_scp>();
    worklist_scp->set_handler(
        [this](const auto& keys, const auto& ae) {
            return handle_worklist_query(keys, ae);
        });
    server_->register_service(worklist_scp);
 
    // Register MPPS SCP
    auto mpps_scp = std::make_shared<services::mpps_scp>();
    mpps_scp->set_create_handler(
        [this](const auto& instance) {
            return handle_mpps_create(instance);
        });
    mpps_scp->set_set_handler(
        [this](const auto& uid, const auto& mods, auto status) {
            return handle_mpps_set(uid, mods, status);
        });
    server_->register_service(mpps_scp);
 
    // Set up callbacks
    server_->on_association_established([](const network::association& assoc) {
        std::cout << log_prefix() << "Association established: "
                  << assoc.calling_ae() << " -> " << assoc.called_ae() << "\n";
    });
 
    server_->on_association_released([](const network::association& assoc) {
        std::cout << log_prefix() << "Association released: "
                  << assoc.calling_ae() << "\n";
    });
 
    server_->on_error([](const std::string& error) {
        std::cerr << log_prefix() << "Server error: " << error << "\n";
    });
 
    std::cout << log_prefix() << "DICOM server configured\n";
    return true;
}

References kcenon::pacs::example::pacs_server_config::access_control, kcenon::pacs::example::server_network_config::ae_title, kcenon::pacs::network::server_config::ae_title, kcenon::pacs::example::access_control_config::allowed_ae_titles, kcenon::pacs::network::association::called_ae(), kcenon::pacs::network::association::calling_ae(), config_, handle_mpps_create(), handle_mpps_set(), handle_query(), handle_retrieve(), handle_store(), handle_worklist_query(), kcenon::pacs::example::server_network_config::idle_timeout, kcenon::pacs::example::server_network_config::max_associations, kcenon::pacs::example::server_network_config::port, kcenon::pacs::example::pacs_server_config::server, server_, and uid.

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setup_services()

bool kcenon::pacs::example::pacs_server_app::setup_services ( )

nodiscardprivate

Set up DICOM services.

Definition at line 226 of file server_app.cpp.

                                     {
    std::cout << log_prefix() << "Setting up DICOM services...\n";
    std::cout << log_prefix() << "  - Verification SCP (C-ECHO)\n";
    std::cout << log_prefix() << "  - Storage SCP (C-STORE)\n";
    std::cout << log_prefix() << "  - Query SCP (C-FIND)\n";
    std::cout << log_prefix() << "  - Retrieve SCP (C-MOVE/C-GET)\n";
    std::cout << log_prefix() << "  - Worklist SCP (MWL)\n";
    std::cout << log_prefix() << "  - MPPS SCP (N-CREATE/N-SET)\n";
    std::cout << log_prefix() << "All DICOM services configured\n";
    return true;
}

Referenced by initialize().

Here is the caller graph for this function:

◆ setup_storage()

bool kcenon::pacs::example::pacs_server_app::setup_storage ( )

nodiscardprivate

Set up file storage.

Definition at line 163 of file server_app.cpp.

                                    {
    std::cout << log_prefix() << "Setting up file storage...\n";
    std::cout << log_prefix() << "  Directory: " << config_.storage.directory << "\n";
 
    // Create storage directory if it doesn't exist
    std::error_code ec;
    std::filesystem::create_directories(config_.storage.directory, ec);
    if (ec) {
        std::cerr << log_prefix() << "Error: Failed to create storage directory: "
                  << ec.message() << "\n";
        return false;
    }
 
    storage::file_storage_config storage_config;
    storage_config.root_path = config_.storage.directory;
    storage_config.naming = parse_naming_scheme(config_.storage.naming);
    storage_config.duplicate = parse_duplicate_policy(config_.storage.duplicate_policy);
    storage_config.create_directories = true;
 
    try {
        file_storage_ = std::make_unique<storage::file_storage>(storage_config);
    } catch (const std::exception& e) {
        std::cerr << log_prefix() << "Error: Failed to create file storage: "
                  << e.what() << "\n";
        return false;
    }
 
    std::cout << log_prefix() << "File storage ready\n";
    return true;
}

References config_, kcenon::pacs::example::storage_config::directory, kcenon::pacs::example::storage_config::duplicate_policy, file_storage_, kcenon::pacs::example::storage_config::naming, and kcenon::pacs::example::pacs_server_config::storage.

Referenced by initialize().

Here is the caller graph for this function:

◆ start()

bool kcenon::pacs::example::pacs_server_app::start ( )

nodiscard

Start the DICOM server.

Begins accepting connections on the configured port. initialize() must be called before start().

Returns: true if server started successfully

Definition at line 91 of file server_app.cpp.

                            {
    if (!initialized_) {
        std::cerr << log_prefix() << "Error: Server not initialized\n";
        return false;
    }
 
    std::cout << log_prefix() << "Starting DICOM server...\n";
    std::cout << log_prefix() << "  AE Title: " << config_.server.ae_title << "\n";
    std::cout << log_prefix() << "  Port: " << config_.server.port << "\n";
    std::cout << log_prefix() << "  Max Associations: " << config_.server.max_associations << "\n";
 
    auto result = server_->start();
    if (result.is_err()) {
        std::cerr << log_prefix() << "Error: Failed to start server\n";
        return false;
    }
 
    std::cout << log_prefix() << "PACS Server started successfully\n";
    std::cout << log_prefix() << "Listening on port " << config_.server.port << "...\n";
    std::cout << log_prefix() << "Press Ctrl+C to stop\n";
 
    return true;
}

References kcenon::pacs::example::server_network_config::ae_title, config_, initialized_, kcenon::pacs::example::server_network_config::max_associations, kcenon::pacs::example::server_network_config::port, kcenon::pacs::example::pacs_server_config::server, and server_.

Referenced by main().

Here is the caller graph for this function:

◆ stop()

void kcenon::pacs::example::pacs_server_app::stop ( )

Stop the server gracefully.

Stops accepting new connections and waits for active associations to complete.

Definition at line 115 of file server_app.cpp.

                           {
    if (server_ && server_->is_running()) {
        std::cout << log_prefix() << "Stopping DICOM server...\n";
        server_->stop();
        std::cout << log_prefix() << "DICOM server stopped\n";
    }
}

References server_.

Referenced by request_shutdown(), and ~pacs_server_app().

Here is the caller graph for this function:

◆ wait_for_shutdown()

void kcenon::pacs::example::pacs_server_app::wait_for_shutdown ( )

Wait for server shutdown.

Blocks until the server is stopped.

Definition at line 123 of file server_app.cpp.

                                        {
    if (server_) {
        server_->wait_for_shutdown();
    }
}

References server_.

Referenced by main().

Here is the caller graph for this function:

Member Data Documentation

◆ config_

pacs_server_config kcenon::pacs::example::pacs_server_app::config_

private

Server configuration.

Definition at line 233 of file server_app.h.

Referenced by setup_database(), setup_server(), setup_storage(), and start().

◆ database_

std::unique_ptr<storage::index_database> kcenon::pacs::example::pacs_server_app::database_

private

Index database.

Definition at line 242 of file server_app.h.

Referenced by handle_mpps_create(), handle_mpps_set(), handle_query(), handle_retrieve(), handle_store(), handle_worklist_query(), and setup_database().

◆ file_storage_

std::unique_ptr<storage::file_storage> kcenon::pacs::example::pacs_server_app::file_storage_

private

File storage.

Definition at line 239 of file server_app.h.

Referenced by handle_store(), and setup_storage().

◆ initialized_

bool kcenon::pacs::example::pacs_server_app::initialized_ {false}

private

Initialization flag.

Definition at line 248 of file server_app.h.

248{false};

Referenced by initialize(), and start().

◆ server_

std::unique_ptr<network::dicom_server> kcenon::pacs::example::pacs_server_app::server_

private

DICOM server.

Definition at line 236 of file server_app.h.

Referenced by is_running(), print_statistics(), setup_server(), start(), stop(), and wait_for_shutdown().

◆ shutdown_requested_

std::atomic<bool> kcenon::pacs::example::pacs_server_app::shutdown_requested_ {false}

private

Shutdown flag.

Definition at line 245 of file server_app.h.

245{false};

Referenced by request_shutdown().

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

examples/pacs_server/server_app.h
examples/pacs_server/server_app.cpp

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ pacs_server_app() [1/3]

◆ ~pacs_server_app()

◆ pacs_server_app() [2/3]

◆ pacs_server_app() [3/3]

Member Function Documentation

◆ handle_mpps_create()

◆ handle_mpps_set()

◆ handle_query()

◆ handle_retrieve()

◆ handle_store()

◆ handle_worklist_query()

◆ initialize()

◆ is_running()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ print_statistics()

◆ request_shutdown()

◆ setup_database()

◆ setup_server()

◆ setup_services()

◆ setup_storage()

◆ start()

◆ stop()

◆ wait_for_shutdown()

Member Data Documentation

◆ config_

◆ database_

◆ file_storage_

◆ initialized_

◆ server_

◆ shutdown_requested_