kcenon::pacs::services::storage_commitment_scp Class Reference

Storage Commitment Push Model SCP. More...

#include <storage_commitment_scp.h>

Inheritance diagram for kcenon::pacs::services::storage_commitment_scp:

Collaboration diagram for kcenon::pacs::services::storage_commitment_scp:

Public Member Functions
	storage_commitment_scp (std::shared_ptr< storage::storage_interface > storage, std::shared_ptr< di::ILogger > logger=nullptr)
	Construct Storage Commitment SCP with storage backend.
	~storage_commitment_scp () override=default
std::vector< std::string >	supported_sop_classes () const override
	Get the list of SOP Class UIDs supported by this service.
network::Result< std::monostate >	handle_message (network::association &assoc, uint8_t context_id, const network::dimse::dimse_message &request) override
	Handle an incoming DIMSE message.
std::string_view	service_name () const noexcept override
	Get the service name for logging/debugging.
size_t	actions_processed () const noexcept
size_t	instances_committed () const noexcept
size_t	instances_failed () const noexcept
void	reset_statistics () noexcept
Public Member Functions inherited from kcenon::pacs::services::scp_service
	scp_service (std::shared_ptr< di::ILogger > logger=nullptr)
	Construct SCP service with optional logger.
virtual	~scp_service ()=default
	scp_service (const scp_service &)=delete
scp_service &	operator= (const scp_service &)=delete
	scp_service (scp_service &&)=default
scp_service &	operator= (scp_service &&)=default
void	set_logger (std::shared_ptr< di::ILogger > logger)
	Set the logger instance.
const std::shared_ptr< di::ILogger > &	logger () const noexcept
	Get the current logger instance.
bool	supports_sop_class (std::string_view sop_class_uid) const
	Check if this service supports a specific SOP Class.

Private Member Functions
network::Result< std::monostate >	handle_n_action (network::association &assoc, uint8_t context_id, const network::dimse::dimse_message &request)
commitment_result	verify_instances (const std::string &transaction_uid, const std::vector< sop_reference > &references)
network::Result< std::monostate >	send_event_report (network::association &assoc, uint8_t context_id, const commitment_result &result)
network::Result< std::monostate >	send_n_action_response (network::association &assoc, uint8_t context_id, uint16_t message_id, network::dimse::status_code status)

Static Private Member Functions
static std::vector< sop_reference >	parse_referenced_sop_sequence (const core::dicom_dataset &dataset)
static core::dicom_dataset	build_event_report_dataset (const commitment_result &result)

Private Attributes
std::shared_ptr< storage::storage_interface >	storage_
std::atomic< size_t >	actions_processed_ {0}
std::atomic< size_t >	instances_committed_ {0}
std::atomic< size_t >	instances_failed_ {0}

Additional Inherited Members
Protected Attributes inherited from kcenon::pacs::services::scp_service
std::shared_ptr< di::ILogger >	logger_
	Logger instance for service logging.

Detailed Description

Storage Commitment Push Model SCP.

Processes N-ACTION requests containing Referenced SOP Sequences, verifies each instance exists in storage, and sends an N-EVENT-REPORT with per-instance success/failure status.

Protocol Flow

SCU (Modality)                      SCP (this)
 │                                   │
 │── N-ACTION-RQ ──────────────────►│
 │   Transaction UID                 │
 │   Referenced SOP Sequence         │
 │◄── N-ACTION-RSP (Success) ──────│
 │                                   │
 │   ... SCP verifies storage ...    │
 │                                   │
 │◄── N-EVENT-REPORT-RQ ──────────│
 │   Transaction UID                 │
 │   Success/Failed Sequences        │
 │── N-EVENT-REPORT-RSP ──────────►│

Definition at line 59 of file storage_commitment_scp.h.

Constructor & Destructor Documentation

storage_commitment_scp()

kcenon::pacs::services::storage_commitment_scp::storage_commitment_scp ( std::shared_ptr< storage::storage_interface > storage, std::shared_ptr< di::ILogger > logger = nullptr )

explicit

Construct Storage Commitment SCP with storage backend.

Parameters

storage	The storage interface for verifying instance existence
logger	Logger instance for service logging

Definition at line 23 of file storage_commitment_scp.cpp.

    : scp_service(std::move(logger))
    , storage_(std::move(storage)) {}

~storage_commitment_scp()

kcenon::pacs::services::storage_commitment_scp::~storage_commitment_scp ( )

overridedefault

Member Function Documentation

actions_processed()

size_t kcenon::pacs::services::storage_commitment_scp::actions_processed ( ) const

nodiscardnoexcept

Definition at line 64 of file storage_commitment_scp.cpp.

                                                                {
    return actions_processed_.load();
}

References actions_processed_.

build_event_report_dataset()

core::dicom_dataset kcenon::pacs::services::storage_commitment_scp::build_event_report_dataset ( const commitment_result & result )

staticnodiscardprivate

Definition at line 266 of file storage_commitment_scp.cpp.

                                     {
 
    core::dicom_dataset ds;
 
    // Transaction UID (0008,1195)
    ds.set_string(core::tags::transaction_uid, encoding::vr_type::UI,
                  result.transaction_uid);
 
    // Referenced SOP Sequence (0008,1199) — successful instances
    if (!result.success_references.empty()) {
        auto& success_seq = ds.get_or_create_sequence(
            core::tags::referenced_sop_sequence);
 
        for (const auto& ref : result.success_references) {
            core::dicom_dataset item;
            item.set_string(core::tags::referenced_sop_class_uid,
                            encoding::vr_type::UI, ref.sop_class_uid);
            item.set_string(core::tags::referenced_sop_instance_uid,
                            encoding::vr_type::UI, ref.sop_instance_uid);
            success_seq.push_back(std::move(item));
        }
    }
 
    // Failed SOP Sequence (0008,1198) — failed instances
    if (!result.failed_references.empty()) {
        auto& failed_seq = ds.get_or_create_sequence(
            core::tags::failed_sop_sequence);
 
        for (const auto& [ref, reason] : result.failed_references) {
            core::dicom_dataset item;
            item.set_string(core::tags::referenced_sop_class_uid,
                            encoding::vr_type::UI, ref.sop_class_uid);
            item.set_string(core::tags::referenced_sop_instance_uid,
                            encoding::vr_type::UI, ref.sop_instance_uid);
            item.set_numeric<uint16_t>(core::tags::failure_reason,
                                       encoding::vr_type::US,
                                       static_cast<uint16_t>(reason));
            failed_seq.push_back(std::move(item));
        }
    }
 
    return ds;
}

References kcenon::pacs::services::commitment_result::failed_references, kcenon::pacs::core::tags::failed_sop_sequence, kcenon::pacs::core::tags::failure_reason, kcenon::pacs::core::dicom_dataset::get_or_create_sequence(), kcenon::pacs::core::tags::referenced_sop_class_uid, kcenon::pacs::core::tags::referenced_sop_instance_uid, kcenon::pacs::core::tags::referenced_sop_sequence, kcenon::pacs::core::dicom_dataset::set_string(), kcenon::pacs::services::commitment_result::success_references, kcenon::pacs::core::tags::transaction_uid, kcenon::pacs::services::commitment_result::transaction_uid, kcenon::pacs::encoding::UI, and kcenon::pacs::encoding::US.

Referenced by send_event_report().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_message()

network::Result< std::monostate > kcenon::pacs::services::storage_commitment_scp::handle_message ( network::association & assoc, uint8_t context_id, const network::dimse::dimse_message & request )

nodiscardoverridevirtual

Handle an incoming DIMSE message.

Processes the request and sends appropriate response(s) via the association.

Parameters

assoc	The association on which the message was received
context_id	The presentation context ID for the message
request	The incoming DIMSE request message

Returns

Success or error result

Implements kcenon::pacs::services::scp_service.

Definition at line 37 of file storage_commitment_scp.cpp.

                                              {
 
    using namespace network::dimse;
 
    switch (request.command()) {
        case command_field::n_action_rq:
            return handle_n_action(assoc, context_id, request);
 
        default:
            return kcenon::pacs::pacs_void_error(
                kcenon::pacs::error_codes::storage_commitment_unexpected_command,
                "Unexpected command for Storage Commitment SCP: " +
                std::string(to_string(request.command())));
    }
}

References kcenon::pacs::network::dimse::dimse_message::command(), handle_n_action(), kcenon::pacs::pacs_void_error(), kcenon::pacs::error_codes::storage_commitment_unexpected_command, and kcenon::pacs::services::to_string().

Here is the call graph for this function:

handle_n_action()

network::Result< std::monostate > kcenon::pacs::services::storage_commitment_scp::handle_n_action ( network::association & assoc, uint8_t context_id, const network::dimse::dimse_message & request )

nodiscardprivate

Definition at line 86 of file storage_commitment_scp.cpp.

                                              {
 
    using namespace network::dimse;
 
    // Validate Requested SOP Class UID
    auto sop_class_uid = request.command_set().get_string(
        tag_requested_sop_class_uid);
    if (sop_class_uid.empty()) {
        sop_class_uid = request.affected_sop_class_uid();
    }
 
    if (sop_class_uid != storage_commitment_push_model_sop_class_uid) {
        return send_n_action_response(
            assoc, context_id, request.message_id(),
            status_refused_sop_class_not_supported);
    }
 
    // Validate Action Type ID = 1 (Request Storage Commitment)
    auto action_type = request.action_type_id();
    if (!action_type.has_value() ||
        action_type.value() != storage_commitment_action_type_request) {
        return send_n_action_response(
            assoc, context_id, request.message_id(),
            status_error_no_such_action_type);
    }
 
    // Verify we have a dataset
    if (!request.has_dataset()) {
        return send_n_action_response(
            assoc, context_id, request.message_id(),
            status_error_missing_attribute);
    }
 
    const auto& dataset = request.dataset().value().get();
 
    // Extract Transaction UID (0008,1195)
    auto transaction_uid = dataset.get_string(core::tags::transaction_uid);
    if (transaction_uid.empty()) {
        return send_n_action_response(
            assoc, context_id, request.message_id(),
            status_error_missing_attribute);
    }
 
    // Parse Referenced SOP Sequence (0008,1199)
    auto references = parse_referenced_sop_sequence(dataset);
    if (references.empty()) {
        return send_n_action_response(
            assoc, context_id, request.message_id(),
            status_error_missing_attribute);
    }
 
    // Send N-ACTION-RSP with Success (acknowledge the request)
    auto rsp_result = send_n_action_response(
        assoc, context_id, request.message_id(),
        status_success);
    if (rsp_result.is_err()) {
        return rsp_result;
    }
 
    // Update statistics
    ++actions_processed_;
 
    // Verify instances against storage
    auto result = verify_instances(transaction_uid, references);
 
    // Update instance statistics
    instances_committed_ += result.success_references.size();
    instances_failed_ += result.failed_references.size();
 
    // Send N-EVENT-REPORT with verification results
    return send_event_report(assoc, context_id, result);
}

References kcenon::pacs::network::dimse::dimse_message::action_type_id(), actions_processed_, kcenon::pacs::network::dimse::dimse_message::affected_sop_class_uid(), kcenon::pacs::network::dimse::dimse_message::command_set(), kcenon::pacs::network::dimse::dimse_message::dataset(), kcenon::pacs::network::dimse::dimse_message::has_dataset(), instances_committed_, instances_failed_, kcenon::pacs::network::dimse::dimse_message::message_id(), parse_referenced_sop_sequence(), send_event_report(), send_n_action_response(), kcenon::pacs::services::storage_commitment_action_type_request, kcenon::pacs::services::storage_commitment_push_model_sop_class_uid, kcenon::pacs::core::tags::transaction_uid, and verify_instances().

Referenced by handle_message().

Here is the call graph for this function:

Here is the caller graph for this function:

instances_committed()

size_t kcenon::pacs::services::storage_commitment_scp::instances_committed ( ) const

nodiscardnoexcept

Definition at line 68 of file storage_commitment_scp.cpp.

                                                                  {
    return instances_committed_.load();
}

References instances_committed_.

instances_failed()

size_t kcenon::pacs::services::storage_commitment_scp::instances_failed ( ) const

nodiscardnoexcept

Definition at line 72 of file storage_commitment_scp.cpp.

                                                               {
    return instances_failed_.load();
}

References instances_failed_.

parse_referenced_sop_sequence()

std::vector< sop_reference > kcenon::pacs::services::storage_commitment_scp::parse_referenced_sop_sequence ( const core::dicom_dataset & dataset )

staticnodiscardprivate

Definition at line 243 of file storage_commitment_scp.cpp.

                                      {
 
    std::vector<sop_reference> references;
 
    const auto* seq = dataset.get_sequence(core::tags::referenced_sop_sequence);
    if (seq == nullptr) {
        return references;
    }
 
    for (const auto& item : *seq) {
        sop_reference ref;
        ref.sop_class_uid = item.get_string(core::tags::referenced_sop_class_uid);
        ref.sop_instance_uid = item.get_string(core::tags::referenced_sop_instance_uid);
 
        if (!ref.sop_class_uid.empty() && !ref.sop_instance_uid.empty()) {
            references.push_back(std::move(ref));
        }
    }
 
    return references;
}

References kcenon::pacs::core::dicom_dataset::get_sequence(), kcenon::pacs::core::tags::referenced_sop_class_uid, kcenon::pacs::core::tags::referenced_sop_instance_uid, kcenon::pacs::core::tags::referenced_sop_sequence, kcenon::pacs::services::sop_reference::sop_class_uid, and kcenon::pacs::services::sop_reference::sop_instance_uid.

Referenced by handle_n_action().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_statistics()

void kcenon::pacs::services::storage_commitment_scp::reset_statistics ( )

noexcept

Definition at line 76 of file storage_commitment_scp.cpp.

                                                       {
    actions_processed_ = 0;
    instances_committed_ = 0;
    instances_failed_ = 0;
}

References actions_processed_, instances_committed_, and instances_failed_.

send_event_report()

network::Result< std::monostate > kcenon::pacs::services::storage_commitment_scp::send_event_report ( network::association & assoc, uint8_t context_id, const commitment_result & result )

nodiscardprivate

Definition at line 190 of file storage_commitment_scp.cpp.

                                     {
 
    using namespace network::dimse;
 
    // Determine event type: 1 = all success, 2 = failures exist
    uint16_t event_type = result.failed_references.empty()
        ? storage_commitment_event_type_success
        : storage_commitment_event_type_failure;
 
    // Build N-EVENT-REPORT-RQ
    auto event_rq = make_n_event_report_rq(
        1,  // message_id
        storage_commitment_push_model_sop_class_uid,
        storage_commitment_push_model_sop_instance_uid,
        event_type);
 
    // Build and attach event dataset
    auto event_dataset = build_event_report_dataset(result);
    event_rq.set_dataset(std::move(event_dataset));
 
    // Send N-EVENT-REPORT-RQ
    return assoc.send_dimse(context_id, event_rq);
}

References build_event_report_dataset(), kcenon::pacs::services::commitment_result::failed_references, kcenon::pacs::network::association::send_dimse(), kcenon::pacs::services::storage_commitment_event_type_failure, kcenon::pacs::services::storage_commitment_event_type_success, kcenon::pacs::services::storage_commitment_push_model_sop_class_uid, and kcenon::pacs::services::storage_commitment_push_model_sop_instance_uid.

Referenced by handle_n_action().

Here is the call graph for this function:

Here is the caller graph for this function:

send_n_action_response()

network::Result< std::monostate > kcenon::pacs::services::storage_commitment_scp::send_n_action_response ( network::association & assoc, uint8_t context_id, uint16_t message_id, network::dimse::status_code status )

nodiscardprivate

Definition at line 221 of file storage_commitment_scp.cpp.

                                    {
 
    using namespace network::dimse;
 
    auto response = make_n_action_rsp(
        message_id,
        storage_commitment_push_model_sop_class_uid,
        storage_commitment_push_model_sop_instance_uid,
        storage_commitment_action_type_request,
        status);
 
    return assoc.send_dimse(context_id, response);
}

References kcenon::pacs::network::association::send_dimse(), kcenon::pacs::services::storage_commitment_action_type_request, kcenon::pacs::services::storage_commitment_push_model_sop_class_uid, and kcenon::pacs::services::storage_commitment_push_model_sop_instance_uid.

Referenced by handle_n_action().

Here is the call graph for this function:

Here is the caller graph for this function:

service_name()

std::string_view kcenon::pacs::services::storage_commitment_scp::service_name ( ) const

nodiscardoverridevirtualnoexcept

Get the service name for logging/debugging.

Returns

Human-readable service name

Implements kcenon::pacs::services::scp_service.

Definition at line 56 of file storage_commitment_scp.cpp.

                                                                   {
    return "Storage Commitment SCP";
}

supported_sop_classes()

std::vector< std::string > kcenon::pacs::services::storage_commitment_scp::supported_sop_classes ( ) const

nodiscardoverridevirtual

Get the list of SOP Class UIDs supported by this service.

Returns

Vector of SOP Class UIDs that this service can handle

Implements kcenon::pacs::services::scp_service.

Definition at line 33 of file storage_commitment_scp.cpp.

                                                                         {
    return {std::string(storage_commitment_push_model_sop_class_uid)};
}

References kcenon::pacs::services::storage_commitment_push_model_sop_class_uid.

verify_instances()

commitment_result kcenon::pacs::services::storage_commitment_scp::verify_instances ( const std::string & transaction_uid, const std::vector< sop_reference > & references )

nodiscardprivate

Definition at line 166 of file storage_commitment_scp.cpp.

                                                {
 
    commitment_result result;
    result.transaction_uid = transaction_uid;
    result.timestamp = std::chrono::system_clock::now();
 
    for (const auto& ref : references) {
        if (storage_ && storage_->exists(ref.sop_instance_uid)) {
            result.success_references.push_back(ref);
        } else {
            result.failed_references.emplace_back(
                ref, commitment_failure_reason::no_such_object_instance);
        }
    }
 
    return result;
}

References kcenon::pacs::services::commitment_result::failed_references, kcenon::pacs::services::no_such_object_instance, storage_, kcenon::pacs::services::commitment_result::success_references, kcenon::pacs::services::commitment_result::timestamp, and kcenon::pacs::services::commitment_result::transaction_uid.

Referenced by handle_n_action().

Here is the caller graph for this function:

Member Data Documentation

actions_processed_

std::atomic<size_t> kcenon::pacs::services::storage_commitment_scp::actions_processed_ {0}

private

Definition at line 148 of file storage_commitment_scp.h.

{0};

Referenced by actions_processed(), handle_n_action(), and reset_statistics().

instances_committed_

std::atomic<size_t> kcenon::pacs::services::storage_commitment_scp::instances_committed_ {0}

private

Definition at line 149 of file storage_commitment_scp.h.

{0};

Referenced by handle_n_action(), instances_committed(), and reset_statistics().

instances_failed_

std::atomic<size_t> kcenon::pacs::services::storage_commitment_scp::instances_failed_ {0}

private

Definition at line 150 of file storage_commitment_scp.h.

{0};

Referenced by handle_n_action(), instances_failed(), and reset_statistics().

storage_

std::shared_ptr<storage::storage_interface> kcenon::pacs::services::storage_commitment_scp::storage_

private

Definition at line 146 of file storage_commitment_scp.h.

Referenced by verify_instances().

---

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

• include/kcenon/pacs/services/storage_commitment_scp.h
• src/services/storage_commitment_scp.cpp