kcenon::pacs::storage::azure_blob_storage Class Reference

#include <azure_blob_storage.h>

Inheritance diagram for kcenon::pacs::storage::azure_blob_storage:

Collaboration diagram for kcenon::pacs::storage::azure_blob_storage:

Classes
class	azure_client_interface
	Abstract interface for Azure Blob client operations. More...

Public Member Functions
	azure_blob_storage (const azure_storage_config &config)
	Construct Azure Blob storage with configuration.
	~azure_blob_storage () override
	Destructor.
	azure_blob_storage (const azure_blob_storage &)=delete
	Non-copyable (contains mutex)
azure_blob_storage &	operator= (const azure_blob_storage &)=delete
	azure_blob_storage (azure_blob_storage &&)=delete
	Non-movable (contains mutex)
azure_blob_storage &	operator= (azure_blob_storage &&)=delete
auto	store (const core::dicom_dataset &dataset) -> VoidResult override
	Store a DICOM dataset to Azure Blob Storage.
auto	retrieve (std::string_view sop_instance_uid) -> Result< core::dicom_dataset > override
	Retrieve a DICOM dataset by SOP Instance UID.
auto	remove (std::string_view sop_instance_uid) -> VoidResult override
	Remove a DICOM blob from Azure Storage.
auto	exists (std::string_view sop_instance_uid) const -> bool override
	Check if a DICOM instance exists in Azure Storage.
auto	find (const core::dicom_dataset &query) -> Result< std::vector< core::dicom_dataset > > override
	Find DICOM datasets matching query criteria.
auto	get_statistics () const -> storage_statistics override
	Get storage statistics.
auto	verify_integrity () -> VoidResult override
	Verify storage integrity.
auto	store_with_progress (const core::dicom_dataset &dataset, azure_progress_callback callback) -> VoidResult
	Store with progress tracking.
auto	retrieve_with_progress (std::string_view sop_instance_uid, azure_progress_callback callback) -> Result< core::dicom_dataset >
	Retrieve with progress tracking.
auto	get_blob_name (std::string_view sop_instance_uid) const -> std::string
	Get the blob name for a SOP Instance UID.
auto	container_name () const -> const std::string &
	Get the container name.
auto	rebuild_index () -> VoidResult
	Rebuild the local index from Azure.
auto	is_connected () const -> bool
	Check Azure connectivity.
auto	set_access_tier (std::string_view sop_instance_uid, std::string_view tier) -> VoidResult
	Set blob access tier.
Public Member Functions inherited from kcenon::pacs::storage::storage_interface
virtual	~storage_interface ()=default
	Virtual destructor for proper polymorphic destruction.
virtual auto	store_batch (const std::vector< core::dicom_dataset > &datasets) -> VoidResult
	Store multiple DICOM datasets in a single operation.
virtual auto	retrieve_batch (const std::vector< std::string > &sop_instance_uids) -> Result< std::vector< core::dicom_dataset > >
	Retrieve multiple DICOM datasets by their SOP Instance UIDs.

Private Member Functions
auto	build_blob_name (std::string_view study_uid, std::string_view series_uid, std::string_view sop_uid) const -> std::string
	Build blob name for a dataset.
auto	upload_block_blob (const std::string &blob_name, const std::vector< std::uint8_t > &data, azure_progress_callback callback) -> VoidResult
	Execute block blob upload for large files.

Static Private Member Functions
static auto	sanitize_uid (std::string_view uid) -> std::string
	Sanitize UID for use in blob name.
static auto	matches_query (const core::dicom_dataset &dataset, const core::dicom_dataset &query) -> bool
	Check if dataset matches query criteria.

Private Attributes
azure_storage_config	config_
	Storage configuration.
std::unique_ptr< azure_client_interface >	client_
	Azure client (mock for testing, Azure SDK for production)
std::unordered_map< std::string, azure_blob_info >	index_
	Mapping from SOP Instance UID to Azure blob info.
std::shared_mutex	mutex_
	Mutex for thread-safe access.

Additional Inherited Members
Protected Member Functions inherited from kcenon::pacs::storage::storage_interface
	storage_interface ()=default
	Protected default constructor for derived classes.
	storage_interface (const storage_interface &)=delete
	Non-copyable.
storage_interface &	operator= (const storage_interface &)=delete
	storage_interface (storage_interface &&)=default
	Movable.
storage_interface &	operator= (storage_interface &&)=default

Detailed Description

Definition at line 170 of file azure_blob_storage.h.

Constructor & Destructor Documentation

azure_blob_storage() [1/3]

kcenon::pacs::storage::azure_blob_storage::azure_blob_storage ( const azure_storage_config & config )

explicit

Construct Azure Blob storage with configuration.

Parameters

config

Azure storage configuration

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/azure_blob_storage.h.

Definition at line 552 of file azure_blob_storage.cpp.

    : config_(config),
#if defined(PACS_WITH_AZURE_SDK) && !defined(PACS_USE_MOCK_AZURE)
      client_(std::make_unique<azure_sdk_client>(config))
#else
      client_(std::make_unique<mock_azure_client>(config))
#endif
{
}

~azure_blob_storage()

kcenon::pacs::storage::azure_blob_storage::~azure_blob_storage ( )

overridedefault

Destructor.

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/azure_blob_storage.h.

azure_blob_storage() [2/3]

kcenon::pacs::storage::azure_blob_storage::azure_blob_storage ( const azure_blob_storage & )

delete

Non-copyable (contains mutex)

azure_blob_storage() [3/3]

kcenon::pacs::storage::azure_blob_storage::azure_blob_storage ( azure_blob_storage && )

delete

Non-movable (contains mutex)

Member Function Documentation

build_blob_name()

auto kcenon::pacs::storage::azure_blob_storage::build_blob_name ( std::string_view study_uid, std::string_view series_uid, std::string_view sop_uid ) const -> std::string

nodiscardprivate

Build blob name for a dataset.

Parameters

study_uid	Study Instance UID
series_uid	Series Instance UID
sop_uid	SOP Instance UID

Returns

The constructed blob name

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/azure_blob_storage.h.

Definition at line 902 of file azure_blob_storage.cpp.

                 {
  std::ostringstream oss;
  oss << sanitize_uid(study_uid) << "/" << sanitize_uid(series_uid) << "/"
      << sanitize_uid(sop_uid) << ".dcm";
  return oss.str();
}

container_name()

auto kcenon::pacs::storage::azure_blob_storage::container_name ( ) const -> const std::string &

nodiscard

Get the container name.

Returns

The configured container name

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/azure_blob_storage.h.

Definition at line 823 of file azure_blob_storage.cpp.

                                                                   {
  return config_.container_name;
}

References config_, and kcenon::pacs::storage::azure_storage_config::container_name.

exists()

auto kcenon::pacs::storage::azure_blob_storage::exists ( std::string_view sop_instance_uid ) const -> bool

nodiscardoverridevirtual

Check if a DICOM instance exists in Azure Storage.

Uses Azure GetBlobProperties to check existence without downloading.

Parameters

sop_instance_uid

The unique identifier to check

Returns

true if the blob exists, false otherwise

Implements kcenon::pacs::storage::storage_interface.

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/azure_blob_storage.h.

Definition at line 713 of file azure_blob_storage.cpp.

            {
  std::shared_lock lock(mutex_);
  return index_.contains(std::string{sop_instance_uid});
}

find()

auto kcenon::pacs::storage::azure_blob_storage::find ( const core::dicom_dataset & query ) -> Result<std::vector<core::dicom_dataset>>

nodiscardoverridevirtual

Find DICOM datasets matching query criteria.

This operation requires scanning the local index. For large containers, consider using the index_database instead.

Parameters

query

The query dataset containing search criteria

Returns

Result containing matching datasets or error information

Note

This operation can be slow for large storage

Implements kcenon::pacs::storage::storage_interface.

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/azure_blob_storage.h.

Definition at line 719 of file azure_blob_storage.cpp.

                                            {
  std::vector<core::dicom_dataset> results;
 
  std::vector<std::string> blobs_to_retrieve;
  {
    std::shared_lock lock(mutex_);
    blobs_to_retrieve.reserve(index_.size());
    for (const auto &[uid, info] : index_) {
      blobs_to_retrieve.push_back(info.blob_name);
    }
  }
 
  for (const auto &blob_name : blobs_to_retrieve) {
    auto download_result = client_->get_blob(blob_name);
    if (download_result.is_err()) {
      continue; // Skip blobs that can't be downloaded
    }
 
    auto parse_result = core::dicom_file::from_bytes(download_result.value());
    if (parse_result.is_err()) {
      continue; // Skip invalid DICOM files
    }
 
    const auto &dataset = parse_result.value().dataset();
    if (matches_query(dataset, query)) {
      results.push_back(dataset);
    }
  }
 
  return results;
}

References kcenon::pacs::core::dicom_file::from_bytes(), and uid.

Here is the call graph for this function:

get_blob_name()

auto kcenon::pacs::storage::azure_blob_storage::get_blob_name ( std::string_view sop_instance_uid ) const -> std::string

nodiscard

Get the blob name for a SOP Instance UID.

Parameters

sop_instance_uid

The SOP Instance UID

Returns

The blob name (may be empty if not found)

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/azure_blob_storage.h.

Definition at line 813 of file azure_blob_storage.cpp.

                                                        {
  std::shared_lock lock(mutex_);
  auto it = index_.find(std::string{sop_instance_uid});
  if (it != index_.end()) {
    return it->second.blob_name;
  }
  return {};
}

get_statistics()

auto kcenon::pacs::storage::azure_blob_storage::get_statistics ( ) const -> storage_statistics

nodiscardoverridevirtual

Get storage statistics.

Returns

Storage statistics structure

Implements kcenon::pacs::storage::storage_interface.

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/azure_blob_storage.h.

Definition at line 752 of file azure_blob_storage.cpp.

                                                                    {
  storage_statistics stats;
 
  std::set<std::string> studies;
  std::set<std::string> series;
 
  {
    std::shared_lock lock(mutex_);
    stats.total_instances = index_.size();
 
    for (const auto &[uid, info] : index_) {
      stats.total_bytes += info.size_bytes;
 
      if (!info.study_instance_uid.empty()) {
        studies.insert(info.study_instance_uid);
      }
      if (!info.series_instance_uid.empty()) {
        series.insert(info.series_instance_uid);
      }
    }
  }
 
  stats.studies_count = studies.size();
  stats.series_count = series.size();
  // Note: patient_count requires downloading datasets to extract PatientID
 
  return stats;
}

References index_, mutex_, and uid.

is_connected()

auto kcenon::pacs::storage::azure_blob_storage::is_connected ( ) const -> bool

nodiscard

Check Azure connectivity.

Returns

true if Azure is reachable, false otherwise

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/azure_blob_storage.h.

Definition at line 867 of file azure_blob_storage.cpp.

                                                    {
  return client_ && client_->is_connected();
}

References client_.

matches_query()

auto kcenon::pacs::storage::azure_blob_storage::matches_query ( const core::dicom_dataset & dataset, const core::dicom_dataset & query ) -> bool

staticnodiscardprivate

Check if dataset matches query criteria.

Parameters

dataset	The dataset to check
query	The query criteria

Returns

true if dataset matches query

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/azure_blob_storage.h.

Definition at line 976 of file azure_blob_storage.cpp.

            {
  // If query is empty, match all
  if (query.empty()) {
    return true;
  }
 
  // Check each query element
  for (const auto &[tag, element] : query) {
    auto query_value = element.as_string().unwrap_or("");
    if (query_value.empty()) {
      continue; // Empty value acts as wildcard
    }
 
    auto dataset_value = dataset.get_string(tag);
 
    // Support basic wildcard matching (* and ?)
    if (query_value.find('*') != std::string::npos ||
        query_value.find('?') != std::string::npos) {
      // Simple pattern matching
      if (query_value.front() == '*' && query_value.back() == '*') {
        // Contains
        auto inner = query_value.substr(1, query_value.length() - 2);
        if (dataset_value.find(inner) == std::string::npos) {
          return false;
        }
      } else if (query_value.front() == '*') {
        // Ends with
        auto suffix = query_value.substr(1);
        if (dataset_value.length() < suffix.length() ||
            dataset_value.substr(dataset_value.length() - suffix.length()) !=
                suffix) {
          return false;
        }
      } else if (query_value.back() == '*') {
        // Starts with
        auto prefix = query_value.substr(0, query_value.length() - 1);
        if (dataset_value.substr(0, prefix.length()) != prefix) {
          return false;
        }
      }
    } else {
      // Exact match
      if (dataset_value != query_value) {
        return false;
      }
    }
  }
 
  return true;
}

operator=() [1/2]

azure_blob_storage & kcenon::pacs::storage::azure_blob_storage::operator= ( azure_blob_storage && )

delete

operator=() [2/2]

azure_blob_storage & kcenon::pacs::storage::azure_blob_storage::operator= ( const azure_blob_storage & )

delete

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/azure_blob_storage.h.

rebuild_index()

auto kcenon::pacs::storage::azure_blob_storage::rebuild_index ( ) -> VoidResult

nodiscard

Rebuild the local index from Azure.

Lists all blobs in the container and rebuilds the SOP UID mapping.

Returns

VoidResult Success or error information

Note

This operation can be slow for containers with many blobs

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/azure_blob_storage.h.

Definition at line 827 of file azure_blob_storage.cpp.

                                                     {
  std::unique_lock lock(mutex_);
  index_.clear();
 
  // List all blobs from Azure
  auto blob_names = client_->list_blobs();
 
  for (const auto &blob_name : blob_names) {
    // Download and parse each blob to rebuild index
    auto download_result = client_->get_blob(blob_name);
    if (download_result.is_err()) {
      continue;
    }
 
    auto parse_result = core::dicom_file::from_bytes(download_result.value());
    if (parse_result.is_err()) {
      continue;
    }
 
    const auto &dataset = parse_result.value().dataset();
    auto sop_uid = dataset.get_string(core::tags::sop_instance_uid);
    auto study_uid = dataset.get_string(core::tags::study_instance_uid);
    auto series_uid = dataset.get_string(core::tags::series_instance_uid);
 
    if (!sop_uid.empty()) {
      azure_blob_info info;
      info.blob_name = blob_name;
      info.sop_instance_uid = sop_uid;
      info.study_instance_uid = study_uid;
      info.series_instance_uid = series_uid;
      info.size_bytes = client_->get_blob_size(blob_name);
      info.etag = client_->get_blob_etag(blob_name);
      info.content_md5 = client_->get_blob_md5(blob_name);
      index_[sop_uid] = std::move(info);
    }
  }
 
  return ok();
}

References kcenon::pacs::core::dicom_file::from_bytes(), kcenon::pacs::core::tags::series_instance_uid, kcenon::pacs::core::tags::sop_instance_uid, and kcenon::pacs::core::tags::study_instance_uid.

Here is the call graph for this function:

remove()

auto kcenon::pacs::storage::azure_blob_storage::remove ( std::string_view sop_instance_uid ) -> VoidResult

nodiscardoverridevirtual

Remove a DICOM blob from Azure Storage.

Parameters

sop_instance_uid

The unique identifier for the instance to remove

Returns

VoidResult Success or error information

Implements kcenon::pacs::storage::storage_interface.

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/azure_blob_storage.h.

Definition at line 691 of file azure_blob_storage.cpp.

                  {
  std::string blob_name;
 
  {
    std::unique_lock lock(mutex_);
    auto it = index_.find(std::string{sop_instance_uid});
    if (it == index_.end()) {
      // Not found is not an error for remove
      return ok();
    }
    blob_name = it->second.blob_name;
    index_.erase(it);
  }
 
  // Delete from Azure
  auto delete_result = client_->delete_blob(blob_name);
  // Ignore delete errors - blob might have been deleted externally
 
  return ok();
}

retrieve()

auto kcenon::pacs::storage::azure_blob_storage::retrieve ( std::string_view sop_instance_uid ) -> Result<core::dicom_dataset>

nodiscardoverridevirtual

Retrieve a DICOM dataset by SOP Instance UID.

Downloads the blob from Azure and deserializes to dicom_dataset.

Parameters

sop_instance_uid

The unique identifier for the instance

Returns

Result containing the dataset or error information

Implements kcenon::pacs::storage::storage_interface.

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/azure_blob_storage.h.

Definition at line 642 of file azure_blob_storage.cpp.

                                 {
  return retrieve_with_progress(sop_instance_uid, nullptr);
}

retrieve_with_progress()

auto kcenon::pacs::storage::azure_blob_storage::retrieve_with_progress ( std::string_view sop_instance_uid, azure_progress_callback callback ) -> Result<core::dicom_dataset>

nodiscard

Retrieve with progress tracking.

Parameters

sop_instance_uid	The SOP Instance UID
callback	Progress callback function

Returns

Result containing the dataset or error information

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/azure_blob_storage.h.

Definition at line 647 of file azure_blob_storage.cpp.

                                 {
  std::string blob_name;
 
  {
    std::shared_lock lock(mutex_);
    auto it = index_.find(std::string{sop_instance_uid});
    if (it == index_.end()) {
      return make_error<core::dicom_dataset>(
          kBlobNotFound,
          "Instance not found: " + std::string{sop_instance_uid},
          "azure_blob_storage");
    }
    blob_name = it->second.blob_name;
  }
 
  // Download from Azure
  auto download_result = client_->get_blob(blob_name);
  if (download_result.is_err()) {
    return make_error<core::dicom_dataset>(kDownloadError,
                                           "Failed to download from Azure",
                                           "azure_blob_storage");
  }
 
  const auto &data = download_result.value();
 
  // Report progress (download complete)
  if (callback) {
    callback(data.size(), data.size());
  }
 
  // Deserialize DICOM data
  auto parse_result = core::dicom_file::from_bytes(data);
  if (parse_result.is_err()) {
    return make_error<core::dicom_dataset>(
        kSerializationError,
        "Failed to parse DICOM data: " + parse_result.error().message,
        "azure_blob_storage");
  }
 
  return parse_result.value().dataset();
}

References kcenon::pacs::core::dicom_file::from_bytes().

Here is the call graph for this function:

sanitize_uid()

auto kcenon::pacs::storage::azure_blob_storage::sanitize_uid ( std::string_view uid ) -> std::string

staticnodiscardprivate

Sanitize UID for use in blob name.

Parameters

uid	The UID to sanitize

Returns

Sanitized string safe for blob name use

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/azure_blob_storage.h.

Definition at line 912 of file azure_blob_storage.cpp.

                                                                     {
  std::string result;
  result.reserve(uid.length());
 
  for (char c : uid) {
    // UIDs contain digits and dots, which are safe for blob names
    // Replace any other characters with underscore
    if (std::isalnum(static_cast<unsigned char>(c)) || c == '.') {
      result += c;
    } else {
      result += '_';
    }
  }
 
  return result;
}

References uid.

set_access_tier()

auto kcenon::pacs::storage::azure_blob_storage::set_access_tier ( std::string_view sop_instance_uid, std::string_view tier ) -> VoidResult

nodiscard

Set blob access tier.

Parameters

sop_instance_uid	The SOP Instance UID
tier	The access tier (Hot, Cool, Archive)

Returns

VoidResult Success or error information

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/azure_blob_storage.h.

Definition at line 871 of file azure_blob_storage.cpp.

                                                                            {
  std::string blob_name;
 
  {
    std::shared_lock lock(mutex_);
    auto it = index_.find(std::string{sop_instance_uid});
    if (it == index_.end()) {
      return make_error<std::monostate>(
          kBlobNotFound,
          "Instance not found: " + std::string{sop_instance_uid},
          "azure_blob_storage");
    }
    blob_name = it->second.blob_name;
  }
 
  auto result = client_->set_tier(blob_name, std::string{tier});
  if (result.is_err()) {
    return make_error<std::monostate>(
        kTierChangeError,
        "Failed to change access tier: " + std::string{sop_instance_uid},
        "azure_blob_storage");
  }
 
  return ok();
}

store()

auto kcenon::pacs::storage::azure_blob_storage::store ( const core::dicom_dataset & dataset ) -> VoidResult

nodiscardoverridevirtual

Store a DICOM dataset to Azure Blob Storage.

Serializes the dataset to DICOM Part 10 format and uploads to Azure. Uses block blob upload for files exceeding block_upload_threshold.

Parameters

dataset

The DICOM dataset to store

Returns

VoidResult Success or error information

Note

Requires Study, Series, and SOP Instance UIDs in the dataset

Implements kcenon::pacs::storage::storage_interface.

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/azure_blob_storage.h.

Definition at line 568 of file azure_blob_storage.cpp.

                  {
  return store_with_progress(dataset, nullptr);
}

store_with_progress()

auto kcenon::pacs::storage::azure_blob_storage::store_with_progress ( const core::dicom_dataset & dataset, azure_progress_callback callback ) -> VoidResult

nodiscard

Store with progress tracking.

Parameters

dataset	The DICOM dataset to store
callback	Progress callback function

Returns

VoidResult Success or error information

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/azure_blob_storage.h.

Definition at line 573 of file azure_blob_storage.cpp.

                  {
  // Extract required UIDs
  auto study_uid = dataset.get_string(core::tags::study_instance_uid);
  auto series_uid = dataset.get_string(core::tags::series_instance_uid);
  auto sop_uid = dataset.get_string(core::tags::sop_instance_uid);
 
  if (study_uid.empty() || series_uid.empty() || sop_uid.empty()) {
    return make_error<std::monostate>(
        kMissingRequiredUid,
        "Missing required UID (Study, Series, or SOP Instance UID)",
        "azure_blob_storage");
  }
 
  // Build blob name
  auto blob_name = build_blob_name(study_uid, series_uid, sop_uid);
 
  // Create DICOM file and serialize to bytes
  auto dicom_file = core::dicom_file::create(
      dataset, encoding::transfer_syntax::explicit_vr_little_endian);
 
  auto data = dicom_file.to_bytes();
  if (data.empty()) {
    return make_error<std::monostate>(kSerializationError,
                                      "Failed to serialize DICOM dataset",
                                      "azure_blob_storage");
  }
 
  // Report initial progress
  if (callback && !callback(0, data.size())) {
    return make_error<std::monostate>(kUploadError, "Upload cancelled by user",
                                      "azure_blob_storage");
  }
 
  // Upload to Azure (use block blob for large files)
  VoidResult upload_result = ok();
  if (data.size() > config_.block_upload_threshold) {
    upload_result = upload_block_blob(blob_name, data, callback);
  } else {
    upload_result = client_->put_blob(blob_name, data);
 
    // Report completion progress
    if (callback) {
      callback(data.size(), data.size());
    }
  }
 
  if (upload_result.is_err()) {
    return upload_result;
  }
 
  // Update local index
  {
    std::unique_lock lock(mutex_);
    azure_blob_info info;
    info.blob_name = blob_name;
    info.sop_instance_uid = sop_uid;
    info.study_instance_uid = study_uid;
    info.series_instance_uid = series_uid;
    info.size_bytes = data.size();
    info.etag = client_->get_blob_etag(blob_name);
    info.content_md5 = client_->get_blob_md5(blob_name);
    index_[sop_uid] = std::move(info);
  }
 
  return ok();
}

References kcenon::pacs::core::dicom_file::create(), kcenon::pacs::encoding::transfer_syntax::explicit_vr_little_endian, kcenon::pacs::core::tags::series_instance_uid, kcenon::pacs::core::tags::sop_instance_uid, and kcenon::pacs::core::tags::study_instance_uid.

Here is the call graph for this function:

upload_block_blob()

auto kcenon::pacs::storage::azure_blob_storage::upload_block_blob ( const std::string & blob_name, const std::vector< std::uint8_t > & data, azure_progress_callback callback ) -> VoidResult

nodiscardprivate

Execute block blob upload for large files.

Parameters

blob_name	Blob name
data	Data to upload
callback	Optional progress callback

Returns

VoidResult Success or error information

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/azure_blob_storage.h.

Definition at line 929 of file azure_blob_storage.cpp.

                                                    {
  std::size_t total_bytes = data.size();
  std::size_t bytes_uploaded = 0;
  std::vector<std::string> block_ids;
 
  // Stage blocks
  std::size_t block_index = 0;
  while (bytes_uploaded < total_bytes) {
    std::size_t block_size =
        (std::min)(config_.block_size, total_bytes - bytes_uploaded);
 
    auto block_id = generate_block_id(block_index);
    block_ids.push_back(block_id);
 
    std::vector<std::uint8_t> block_data(data.begin() + bytes_uploaded,
                                         data.begin() + bytes_uploaded +
                                             block_size);
 
    auto stage_result = client_->stage_block(blob_name, block_id, block_data);
    if (stage_result.is_err()) {
      return make_error<std::monostate>(kUploadError,
                                        "Failed to stage block: " + block_id,
                                        "azure_blob_storage");
    }
 
    bytes_uploaded += block_size;
    block_index++;
 
    if (callback && !callback(bytes_uploaded, total_bytes)) {
      return make_error<std::monostate>(kUploadError,
                                        "Upload cancelled by user",
                                        "azure_blob_storage");
    }
  }
 
  // Commit blocks
  auto commit_result = client_->commit_blocks(blob_name, block_ids);
  if (commit_result.is_err()) {
    return make_error<std::monostate>(kUploadError, "Failed to commit blocks",
                                      "azure_blob_storage");
  }
 
  return ok();
}

verify_integrity()

auto kcenon::pacs::storage::azure_blob_storage::verify_integrity ( ) -> VoidResult

nodiscardoverridevirtual

Verify storage integrity.

Checks that all indexed blobs exist in Azure and have valid ETags.

Returns

VoidResult Success if integrity is verified, error otherwise

Implements kcenon::pacs::storage::storage_interface.

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/azure_blob_storage.h.

Definition at line 781 of file azure_blob_storage.cpp.

                                                        {
  std::vector<std::pair<std::string, std::string>> entries;
  {
    std::shared_lock lock(mutex_);
    entries.reserve(index_.size());
    for (const auto &[uid, info] : index_) {
      entries.emplace_back(uid, info.blob_name);
    }
  }
 
  std::vector<std::string> invalid_entries;
 
  for (const auto &[uid, blob_name] : entries) {
    if (!client_->head_blob(blob_name)) {
      invalid_entries.push_back(uid + " (blob missing)");
    }
  }
 
  if (!invalid_entries.empty()) {
    std::string message = "Integrity check failed for " +
                          std::to_string(invalid_entries.size()) + " entries";
    return make_error<std::monostate>(kIntegrityError, message,
                                      "azure_blob_storage");
  }
 
  return ok();
}

References uid.

Member Data Documentation

client_

std::unique_ptr<azure_client_interface> kcenon::pacs::storage::azure_blob_storage::client_

private

Azure client (mock for testing, Azure SDK for production)

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/azure_blob_storage.h.

Definition at line 410 of file azure_blob_storage.h.

Referenced by is_connected().

config_

azure_storage_config kcenon::pacs::storage::azure_blob_storage::config_

private

Storage configuration.

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/azure_blob_storage.h.

Definition at line 407 of file azure_blob_storage.h.

Referenced by container_name().

index_

std::unordered_map<std::string, azure_blob_info> kcenon::pacs::storage::azure_blob_storage::index_

private

Mapping from SOP Instance UID to Azure blob info.

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/azure_blob_storage.h.

Definition at line 413 of file azure_blob_storage.h.

Referenced by get_statistics().

mutex_

std::shared_mutex kcenon::pacs::storage::azure_blob_storage::mutex_

mutableprivate

Mutex for thread-safe access.

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/azure_blob_storage.h.

Definition at line 416 of file azure_blob_storage.h.

Referenced by get_statistics().

---

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

• include/kcenon/pacs/storage/azure_blob_storage.h
• src/storage/azure_blob_storage.cpp