kcenon::pacs::ihe::xds::document_source::impl Class Reference

Collaboration diagram for kcenon::pacs::ihe::xds::document_source::impl:

Public Member Functions
	impl (http_options opts, signing_material signing)
void	set_audit_sink (std::shared_ptr< kcenon::pacs::security::xds_audit_sink > sink)
kcenon::common::Result< submit_response >	submit (const submission_set &s)

Private Member Functions
kcenon::common::Result< submit_response >	parse_registry_response (const std::string &body, const std::string &submission_set_uid)
void	audit (const submission_set &s, const std::vector< std::string > &document_uids, const kcenon::common::Result< submit_response > &r)

Private Attributes
http_options	opts_
signing_material	signing_
std::shared_ptr< kcenon::pacs::security::xds_audit_sink >	audit_sink_

Static Private Attributes
static constexpr std::size_t	kMaxRegistryResponseBytes

Detailed Description

Definition at line 45 of file document_source.cpp.

Constructor & Destructor Documentation

impl()

kcenon::pacs::ihe::xds::document_source::impl::impl ( http_options opts, signing_material signing )

inline

Definition at line 47 of file document_source.cpp.

        : opts_(std::move(opts)), signing_(std::move(signing)) {}

Member Function Documentation

audit()

void kcenon::pacs::ihe::xds::document_source::impl::audit ( const submission_set & s, const std::vector< std::string > & document_uids, const kcenon::common::Result< submit_response > & r )

inlineprivate

Definition at line 194 of file document_source.cpp.

                                                             {
        if (!audit_sink_) return;
        kcenon::pacs::security::xds_iti41_event e;
        e.source_id = s.source_id;
        e.destination_endpoint = opts_.endpoint;
        e.patient_id = s.patient_id;
        e.submission_set_unique_id = s.submission_set_unique_id;
        e.document_unique_ids = document_uids;
        if (r.is_ok()) {
            e.outcome = kcenon::pacs::security::atna_event_outcome::success;
        } else {
            e.outcome =
                kcenon::pacs::security::atna_event_outcome::serious_failure;
            e.failure_description = r.error().message;
        }
        audit_sink_->on_iti41_submit(e);
    }

References audit_sink_, kcenon::pacs::ihe::xds::http_options::endpoint, opts_, kcenon::pacs::ihe::xds::submission_set::patient_id, kcenon::pacs::security::serious_failure, kcenon::pacs::ihe::xds::submission_set::source_id, kcenon::pacs::ihe::xds::submission_set::submission_set_unique_id, and kcenon::pacs::security::success.

Referenced by submit().

Here is the caller graph for this function:

parse_registry_response()

kcenon::common::Result< submit_response > kcenon::pacs::ihe::xds::document_source::impl::parse_registry_response ( const std::string & body, const std::string & submission_set_uid )

inlineprivate

Definition at line 128 of file document_source.cpp.

                                                                    {
        if (body.size() > kMaxRegistryResponseBytes) {
            return kcenon::common::make_error<submit_response>(
                static_cast<int>(error_code::transport_response_too_large),
                "RegistryResponse exceeds 8 MiB cap (" +
                    std::to_string(body.size()) + " bytes) - rejected to "
                    "bound pugixml memory footprint",
                std::string(error_source));
        }
        pugi::xml_document doc;
        auto parse = doc.load_buffer(body.data(), body.size(),
                                     pugi::parse_default, pugi::encoding_utf8);
        if (!parse) {
            return kcenon::common::make_error<submit_response>(
                static_cast<int>(error_code::transport_invalid_response),
                std::string("failed to parse RegistryResponse: ") +
                    parse.description(),
                std::string(error_source));
        }
 
        auto registry_response =
            doc.select_node(
                   "//*[local-name()='RegistryResponse' or "
                   "local-name()='RegistryResponseType']")
                .node();
        if (!registry_response) {
            return kcenon::common::make_error<submit_response>(
                static_cast<int>(error_code::transport_invalid_response),
                "response contains no RegistryResponse element",
                std::string(error_source));
        }
 
        const std::string status =
            registry_response.attribute("status").as_string();
        if (status.empty()) {
            return kcenon::common::make_error<submit_response>(
                static_cast<int>(error_code::transport_invalid_response),
                "RegistryResponse is missing status attribute",
                std::string(error_source));
        }
 
        static constexpr std::string_view success_status =
            "urn:oasis:names:tc:ebxml-regrep:ResponseStatusType:Success";
        static constexpr std::string_view partial_success_status =
            "urn:oasis:names:tc:ebxml-regrep:ResponseStatusType:PartialSuccess";
 
        submit_response out;
        out.registry_response_status = status;
        out.submission_set_unique_id = submission_set_uid;
 
        if (status == success_status) {
            return out;
        }
        if (status == partial_success_status) {
            return kcenon::common::make_error<submit_response>(
                static_cast<int>(error_code::registry_partial_success),
                "registry reported PartialSuccess: " + status,
                std::string(error_source));
        }
        return kcenon::common::make_error<submit_response>(
            static_cast<int>(error_code::registry_failure_response),
            "registry reported non-success status: " + status,
            std::string(error_source));
    }

References kcenon::pacs::ihe::xds::error_source, kMaxRegistryResponseBytes, out, kcenon::pacs::ihe::xds::registry_failure_response, kcenon::pacs::ihe::xds::registry_partial_success, kcenon::pacs::ihe::xds::transport_invalid_response, and kcenon::pacs::ihe::xds::transport_response_too_large.

Referenced by submit().

Here is the caller graph for this function:

set_audit_sink()

void kcenon::pacs::ihe::xds::document_source::impl::set_audit_sink ( std::shared_ptr< kcenon::pacs::security::xds_audit_sink > sink )

inline

Definition at line 50 of file document_source.cpp.

                                                              {
        audit_sink_ = std::move(sink);
    }

References audit_sink_.

Referenced by kcenon::pacs::ihe::xds::document_source::set_audit_sink().

Here is the caller graph for this function:

submit()

kcenon::common::Result< submit_response > kcenon::pacs::ihe::xds::document_source::impl::submit ( const submission_set & s )

inline

Definition at line 55 of file document_source.cpp.

                                                                        {
        // Collect document unique ids up-front so an audit event can
        // reference them even when submission fails before the wire
        // payload is built.
        std::vector<std::string> document_uids;
        document_uids.reserve(s.documents.size());
        for (const auto& d : s.documents) {
            document_uids.push_back(d.unique_id);
        }
 
        auto do_audit = [&](const kcenon::common::Result<submit_response>& r) {
            audit(s, document_uids, r);
            return r;
        };
 
        std::vector<std::string> cids;
        cids.reserve(s.documents.size());
        for (std::size_t i = 0; i < s.documents.size(); ++i) {
            cids.push_back(make_cid(i));
        }
 
        auto env_result = detail::build_iti41_envelope(s, cids);
        if (env_result.is_err()) {
            return do_audit(kcenon::common::make_error<submit_response>(
                env_result.error()));
        }
        auto env = env_result.value();
 
        auto sign_result = detail::sign_envelope(
            env, signing_.certificate_pem, signing_.private_key_pem,
            signing_.private_key_password);
        if (sign_result.is_err()) {
            return do_audit(kcenon::common::make_error<submit_response>(
                sign_result.error()));
        }
 
        std::vector<detail::mtom_part> parts;
        parts.reserve(s.documents.size());
        for (std::size_t i = 0; i < s.documents.size(); ++i) {
            detail::mtom_part p;
            p.content_id = cids[i];
            p.mime_type = s.documents[i].mime_type;
            p.content = s.documents[i].content;
            parts.push_back(std::move(p));
        }
 
        auto mtom_result = detail::package_mtom(env.xml, parts);
        if (mtom_result.is_err()) {
            return do_audit(kcenon::common::make_error<submit_response>(
                mtom_result.error()));
        }
        auto mtom = mtom_result.value();
 
        auto http_result =
            detail::http_post(opts_, mtom.content_type, mtom.body);
        if (http_result.is_err()) {
            return do_audit(kcenon::common::make_error<submit_response>(
                http_result.error()));
        }
        auto response = http_result.value();
 
        return do_audit(parse_registry_response(response.body,
                                                s.submission_set_unique_id));
    }

References audit(), kcenon::pacs::ihe::xds::detail::build_iti41_envelope(), kcenon::pacs::ihe::xds::signing_material::certificate_pem, kcenon::pacs::ihe::xds::detail::mtom_part::content, kcenon::pacs::ihe::xds::detail::mtom_part::content_id, kcenon::pacs::ihe::xds::submission_set::documents, kcenon::pacs::ihe::xds::detail::http_post(), kcenon::pacs::ihe::xds::detail::mtom_part::mime_type, opts_, kcenon::pacs::ihe::xds::detail::package_mtom(), parse_registry_response(), kcenon::pacs::ihe::xds::signing_material::private_key_password, kcenon::pacs::ihe::xds::signing_material::private_key_pem, kcenon::pacs::ihe::xds::detail::sign_envelope(), signing_, and kcenon::pacs::ihe::xds::submission_set::submission_set_unique_id.

Here is the call graph for this function:

Member Data Documentation

audit_sink_

std::shared_ptr<kcenon::pacs::security::xds_audit_sink> kcenon::pacs::ihe::xds::document_source::impl::audit_sink_

private

Definition at line 216 of file document_source.cpp.

Referenced by audit(), and set_audit_sink().

kMaxRegistryResponseBytes

std::size_t kcenon::pacs::ihe::xds::document_source::impl::kMaxRegistryResponseBytes

staticconstexprprivate

Initial value:

=
        8 * 1024 * 1024

Definition at line 125 of file document_source.cpp.

Referenced by parse_registry_response().

opts_

http_options kcenon::pacs::ihe::xds::document_source::impl::opts_

private

Definition at line 214 of file document_source.cpp.

Referenced by audit(), and submit().

signing_

signing_material kcenon::pacs::ihe::xds::document_source::impl::signing_

private

Definition at line 215 of file document_source.cpp.

Referenced by submit().

---

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

• src/ihe/xds/document_source.cpp