From f99e4a57c7528ef6138686f9b3e0c9e8d87cf635 Mon Sep 17 00:00:00 2001 From: JinmingHu Date: Wed, 11 Nov 2020 09:41:19 +0800 Subject: [PATCH] move stuff to Details namespace (#921) --- .../azure/storage/blobs/blob_sas_builder.hpp | 2 +- .../blobs/protocol/blob_rest_client.hpp | 16365 ++++++++-------- .../src/append_blob_client.cpp | 26 +- .../src/blob_batch_client.cpp | 46 +- .../azure-storage-blobs/src/blob_client.cpp | 102 +- .../src/blob_container_client.cpp | 70 +- .../src/blob_sas_builder.cpp | 84 +- .../src/blob_service_client.cpp | 40 +- .../src/block_blob_client.cpp | 37 +- .../src/page_blob_client.cpp | 38 +- .../test/blob_service_client_test.cpp | 2 +- .../test/storage_retry_policy_test.cpp | 8 +- .../src/datalake_file_client.cpp | 4 +- 13 files changed, 8457 insertions(+), 8367 deletions(-) diff --git a/sdk/storage/azure-storage-blobs/inc/azure/storage/blobs/blob_sas_builder.hpp b/sdk/storage/azure-storage-blobs/inc/azure/storage/blobs/blob_sas_builder.hpp index 2769a0d50..9601a4de3 100644 --- a/sdk/storage/azure-storage-blobs/inc/azure/storage/blobs/blob_sas_builder.hpp +++ b/sdk/storage/azure-storage-blobs/inc/azure/storage/blobs/blob_sas_builder.hpp @@ -182,7 +182,7 @@ namespace Azure { namespace Storage { namespace Blobs { * shared access signature, and the service version to use when handling requests made with this * shared access signature. */ - std::string Version = Details::c_defaultSasVersion; + std::string Version = Storage::Details::c_defaultSasVersion; /** * @brief The optional signed protocol field specifies the protocol permitted for a diff --git a/sdk/storage/azure-storage-blobs/inc/azure/storage/blobs/protocol/blob_rest_client.hpp b/sdk/storage/azure-storage-blobs/inc/azure/storage/blobs/protocol/blob_rest_client.hpp index cd93f9cfd..4f41b9446 100644 --- a/sdk/storage/azure-storage-blobs/inc/azure/storage/blobs/protocol/blob_rest_client.hpp +++ b/sdk/storage/azure-storage-blobs/inc/azure/storage/blobs/protocol/blob_rest_client.hpp @@ -25,7 +25,9 @@ namespace Azure { namespace Storage { namespace Blobs { - constexpr static const char* c_ApiVersion = "2020-02-10"; + namespace Details { + constexpr static const char* c_ApiVersion = "2020-02-10"; + } // namespace Details struct AbortCopyBlobFromUriResult { @@ -53,127 +55,129 @@ namespace Azure { namespace Storage { namespace Blobs { Archive, }; // enum class AccessTier - inline std::string AccessTierToString(const AccessTier& access_tier) - { - switch (access_tier) + namespace Details { + inline std::string AccessTierToString(const AccessTier& access_tier) { - case AccessTier::Unknown: - return ""; - case AccessTier::P1: - return "P1"; - case AccessTier::P2: - return "P2"; - case AccessTier::P3: - return "P3"; - case AccessTier::P4: - return "P4"; - case AccessTier::P6: - return "P6"; - case AccessTier::P10: - return "P10"; - case AccessTier::P15: - return "P15"; - case AccessTier::P20: - return "P20"; - case AccessTier::P30: - return "P30"; - case AccessTier::P40: - return "P40"; - case AccessTier::P50: - return "P50"; - case AccessTier::P60: - return "P60"; - case AccessTier::P70: - return "P70"; - case AccessTier::P80: - return "P80"; - case AccessTier::Hot: - return "Hot"; - case AccessTier::Cool: - return "Cool"; - case AccessTier::Archive: - return "Archive"; - default: - return std::string(); + switch (access_tier) + { + case AccessTier::Unknown: + return ""; + case AccessTier::P1: + return "P1"; + case AccessTier::P2: + return "P2"; + case AccessTier::P3: + return "P3"; + case AccessTier::P4: + return "P4"; + case AccessTier::P6: + return "P6"; + case AccessTier::P10: + return "P10"; + case AccessTier::P15: + return "P15"; + case AccessTier::P20: + return "P20"; + case AccessTier::P30: + return "P30"; + case AccessTier::P40: + return "P40"; + case AccessTier::P50: + return "P50"; + case AccessTier::P60: + return "P60"; + case AccessTier::P70: + return "P70"; + case AccessTier::P80: + return "P80"; + case AccessTier::Hot: + return "Hot"; + case AccessTier::Cool: + return "Cool"; + case AccessTier::Archive: + return "Archive"; + default: + return std::string(); + } } - } - inline AccessTier AccessTierFromString(const std::string& access_tier) - { - if (access_tier == "") + inline AccessTier AccessTierFromString(const std::string& access_tier) { - return AccessTier::Unknown; + if (access_tier == "") + { + return AccessTier::Unknown; + } + if (access_tier == "P1") + { + return AccessTier::P1; + } + if (access_tier == "P2") + { + return AccessTier::P2; + } + if (access_tier == "P3") + { + return AccessTier::P3; + } + if (access_tier == "P4") + { + return AccessTier::P4; + } + if (access_tier == "P6") + { + return AccessTier::P6; + } + if (access_tier == "P10") + { + return AccessTier::P10; + } + if (access_tier == "P15") + { + return AccessTier::P15; + } + if (access_tier == "P20") + { + return AccessTier::P20; + } + if (access_tier == "P30") + { + return AccessTier::P30; + } + if (access_tier == "P40") + { + return AccessTier::P40; + } + if (access_tier == "P50") + { + return AccessTier::P50; + } + if (access_tier == "P60") + { + return AccessTier::P60; + } + if (access_tier == "P70") + { + return AccessTier::P70; + } + if (access_tier == "P80") + { + return AccessTier::P80; + } + if (access_tier == "Hot") + { + return AccessTier::Hot; + } + if (access_tier == "Cool") + { + return AccessTier::Cool; + } + if (access_tier == "Archive") + { + return AccessTier::Archive; + } + throw std::runtime_error("cannot convert " + access_tier + " to AccessTier"); } - if (access_tier == "P1") - { - return AccessTier::P1; - } - if (access_tier == "P2") - { - return AccessTier::P2; - } - if (access_tier == "P3") - { - return AccessTier::P3; - } - if (access_tier == "P4") - { - return AccessTier::P4; - } - if (access_tier == "P6") - { - return AccessTier::P6; - } - if (access_tier == "P10") - { - return AccessTier::P10; - } - if (access_tier == "P15") - { - return AccessTier::P15; - } - if (access_tier == "P20") - { - return AccessTier::P20; - } - if (access_tier == "P30") - { - return AccessTier::P30; - } - if (access_tier == "P40") - { - return AccessTier::P40; - } - if (access_tier == "P50") - { - return AccessTier::P50; - } - if (access_tier == "P60") - { - return AccessTier::P60; - } - if (access_tier == "P70") - { - return AccessTier::P70; - } - if (access_tier == "P80") - { - return AccessTier::P80; - } - if (access_tier == "Hot") - { - return AccessTier::Hot; - } - if (access_tier == "Cool") - { - return AccessTier::Cool; - } - if (access_tier == "Archive") - { - return AccessTier::Archive; - } - throw std::runtime_error("cannot convert " + access_tier + " to AccessTier"); - } + } // namespace Details enum class AccountKind { @@ -185,55 +189,57 @@ namespace Azure { namespace Storage { namespace Blobs { BlockBlobStorage, }; // enum class AccountKind - inline std::string AccountKindToString(const AccountKind& account_kind) - { - switch (account_kind) + namespace Details { + inline std::string AccountKindToString(const AccountKind& account_kind) { - case AccountKind::Unknown: - return ""; - case AccountKind::Storage: - return "Storage"; - case AccountKind::BlobStorage: - return "BlobStorage"; - case AccountKind::StorageV2: - return "StorageV2"; - case AccountKind::FileStorage: - return "FileStorage"; - case AccountKind::BlockBlobStorage: - return "BlockBlobStorage"; - default: - return std::string(); + switch (account_kind) + { + case AccountKind::Unknown: + return ""; + case AccountKind::Storage: + return "Storage"; + case AccountKind::BlobStorage: + return "BlobStorage"; + case AccountKind::StorageV2: + return "StorageV2"; + case AccountKind::FileStorage: + return "FileStorage"; + case AccountKind::BlockBlobStorage: + return "BlockBlobStorage"; + default: + return std::string(); + } } - } - inline AccountKind AccountKindFromString(const std::string& account_kind) - { - if (account_kind == "") + inline AccountKind AccountKindFromString(const std::string& account_kind) { - return AccountKind::Unknown; + if (account_kind == "") + { + return AccountKind::Unknown; + } + if (account_kind == "Storage") + { + return AccountKind::Storage; + } + if (account_kind == "BlobStorage") + { + return AccountKind::BlobStorage; + } + if (account_kind == "StorageV2") + { + return AccountKind::StorageV2; + } + if (account_kind == "FileStorage") + { + return AccountKind::FileStorage; + } + if (account_kind == "BlockBlobStorage") + { + return AccountKind::BlockBlobStorage; + } + throw std::runtime_error("cannot convert " + account_kind + " to AccountKind"); } - if (account_kind == "Storage") - { - return AccountKind::Storage; - } - if (account_kind == "BlobStorage") - { - return AccountKind::BlobStorage; - } - if (account_kind == "StorageV2") - { - return AccountKind::StorageV2; - } - if (account_kind == "FileStorage") - { - return AccountKind::FileStorage; - } - if (account_kind == "BlockBlobStorage") - { - return AccountKind::BlockBlobStorage; - } - throw std::runtime_error("cannot convert " + account_kind + " to AccountKind"); - } + } // namespace Details struct AcquireBlobLeaseResult { @@ -282,37 +288,39 @@ namespace Azure { namespace Storage { namespace Blobs { RehydratePendingToCool, }; // enum class BlobArchiveStatus - inline std::string BlobArchiveStatusToString(const BlobArchiveStatus& blob_archive_status) - { - switch (blob_archive_status) + namespace Details { + inline std::string BlobArchiveStatusToString(const BlobArchiveStatus& blob_archive_status) { - case BlobArchiveStatus::Unknown: - return ""; - case BlobArchiveStatus::RehydratePendingToHot: - return "rehydrate-pending-to-hot"; - case BlobArchiveStatus::RehydratePendingToCool: - return "rehydrate-pending-to-cool"; - default: - return std::string(); + switch (blob_archive_status) + { + case BlobArchiveStatus::Unknown: + return ""; + case BlobArchiveStatus::RehydratePendingToHot: + return "rehydrate-pending-to-hot"; + case BlobArchiveStatus::RehydratePendingToCool: + return "rehydrate-pending-to-cool"; + default: + return std::string(); + } } - } - inline BlobArchiveStatus BlobArchiveStatusFromString(const std::string& blob_archive_status) - { - if (blob_archive_status == "") + inline BlobArchiveStatus BlobArchiveStatusFromString(const std::string& blob_archive_status) { - return BlobArchiveStatus::Unknown; + if (blob_archive_status == "") + { + return BlobArchiveStatus::Unknown; + } + if (blob_archive_status == "rehydrate-pending-to-hot") + { + return BlobArchiveStatus::RehydratePendingToHot; + } + if (blob_archive_status == "rehydrate-pending-to-cool") + { + return BlobArchiveStatus::RehydratePendingToCool; + } + throw std::runtime_error("cannot convert " + blob_archive_status + " to BlobArchiveStatus"); } - if (blob_archive_status == "rehydrate-pending-to-hot") - { - return BlobArchiveStatus::RehydratePendingToHot; - } - if (blob_archive_status == "rehydrate-pending-to-cool") - { - return BlobArchiveStatus::RehydratePendingToCool; - } - throw std::runtime_error("cannot convert " + blob_archive_status + " to BlobArchiveStatus"); - } + } // namespace Details struct BlobBlock { @@ -337,46 +345,48 @@ namespace Azure { namespace Storage { namespace Blobs { Unavailable, }; // enum class BlobGeoReplicationStatus - inline std::string BlobGeoReplicationStatusToString( - const BlobGeoReplicationStatus& blob_geo_replication_status) - { - switch (blob_geo_replication_status) + namespace Details { + inline std::string BlobGeoReplicationStatusToString( + const BlobGeoReplicationStatus& blob_geo_replication_status) { - case BlobGeoReplicationStatus::Unknown: - return ""; - case BlobGeoReplicationStatus::Live: - return "live"; - case BlobGeoReplicationStatus::Bootstrap: - return "bootstrap"; - case BlobGeoReplicationStatus::Unavailable: - return "unavailable"; - default: - return std::string(); + switch (blob_geo_replication_status) + { + case BlobGeoReplicationStatus::Unknown: + return ""; + case BlobGeoReplicationStatus::Live: + return "live"; + case BlobGeoReplicationStatus::Bootstrap: + return "bootstrap"; + case BlobGeoReplicationStatus::Unavailable: + return "unavailable"; + default: + return std::string(); + } } - } - inline BlobGeoReplicationStatus BlobGeoReplicationStatusFromString( - const std::string& blob_geo_replication_status) - { - if (blob_geo_replication_status == "") + inline BlobGeoReplicationStatus BlobGeoReplicationStatusFromString( + const std::string& blob_geo_replication_status) { - return BlobGeoReplicationStatus::Unknown; + if (blob_geo_replication_status == "") + { + return BlobGeoReplicationStatus::Unknown; + } + if (blob_geo_replication_status == "live") + { + return BlobGeoReplicationStatus::Live; + } + if (blob_geo_replication_status == "bootstrap") + { + return BlobGeoReplicationStatus::Bootstrap; + } + if (blob_geo_replication_status == "unavailable") + { + return BlobGeoReplicationStatus::Unavailable; + } + throw std::runtime_error( + "cannot convert " + blob_geo_replication_status + " to BlobGeoReplicationStatus"); } - if (blob_geo_replication_status == "live") - { - return BlobGeoReplicationStatus::Live; - } - if (blob_geo_replication_status == "bootstrap") - { - return BlobGeoReplicationStatus::Bootstrap; - } - if (blob_geo_replication_status == "unavailable") - { - return BlobGeoReplicationStatus::Unavailable; - } - throw std::runtime_error( - "cannot convert " + blob_geo_replication_status + " to BlobGeoReplicationStatus"); - } + } // namespace Details struct BlobHttpHeaders { @@ -397,49 +407,51 @@ namespace Azure { namespace Storage { namespace Blobs { Broken, }; // enum class BlobLeaseState - inline std::string BlobLeaseStateToString(const BlobLeaseState& blob_lease_state) - { - switch (blob_lease_state) + namespace Details { + inline std::string BlobLeaseStateToString(const BlobLeaseState& blob_lease_state) { - case BlobLeaseState::Available: - return "available"; - case BlobLeaseState::Leased: - return "leased"; - case BlobLeaseState::Expired: - return "expired"; - case BlobLeaseState::Breaking: - return "breaking"; - case BlobLeaseState::Broken: - return "broken"; - default: - return std::string(); + switch (blob_lease_state) + { + case BlobLeaseState::Available: + return "available"; + case BlobLeaseState::Leased: + return "leased"; + case BlobLeaseState::Expired: + return "expired"; + case BlobLeaseState::Breaking: + return "breaking"; + case BlobLeaseState::Broken: + return "broken"; + default: + return std::string(); + } } - } - inline BlobLeaseState BlobLeaseStateFromString(const std::string& blob_lease_state) - { - if (blob_lease_state == "available") + inline BlobLeaseState BlobLeaseStateFromString(const std::string& blob_lease_state) { - return BlobLeaseState::Available; + if (blob_lease_state == "available") + { + return BlobLeaseState::Available; + } + if (blob_lease_state == "leased") + { + return BlobLeaseState::Leased; + } + if (blob_lease_state == "expired") + { + return BlobLeaseState::Expired; + } + if (blob_lease_state == "breaking") + { + return BlobLeaseState::Breaking; + } + if (blob_lease_state == "broken") + { + return BlobLeaseState::Broken; + } + throw std::runtime_error("cannot convert " + blob_lease_state + " to BlobLeaseState"); } - if (blob_lease_state == "leased") - { - return BlobLeaseState::Leased; - } - if (blob_lease_state == "expired") - { - return BlobLeaseState::Expired; - } - if (blob_lease_state == "breaking") - { - return BlobLeaseState::Breaking; - } - if (blob_lease_state == "broken") - { - return BlobLeaseState::Broken; - } - throw std::runtime_error("cannot convert " + blob_lease_state + " to BlobLeaseState"); - } + } // namespace Details enum class BlobLeaseStatus { @@ -447,31 +459,33 @@ namespace Azure { namespace Storage { namespace Blobs { Unlocked, }; // enum class BlobLeaseStatus - inline std::string BlobLeaseStatusToString(const BlobLeaseStatus& blob_lease_status) - { - switch (blob_lease_status) + namespace Details { + inline std::string BlobLeaseStatusToString(const BlobLeaseStatus& blob_lease_status) { - case BlobLeaseStatus::Locked: - return "locked"; - case BlobLeaseStatus::Unlocked: - return "unlocked"; - default: - return std::string(); + switch (blob_lease_status) + { + case BlobLeaseStatus::Locked: + return "locked"; + case BlobLeaseStatus::Unlocked: + return "unlocked"; + default: + return std::string(); + } } - } - inline BlobLeaseStatus BlobLeaseStatusFromString(const std::string& blob_lease_status) - { - if (blob_lease_status == "locked") + inline BlobLeaseStatus BlobLeaseStatusFromString(const std::string& blob_lease_status) { - return BlobLeaseStatus::Locked; + if (blob_lease_status == "locked") + { + return BlobLeaseStatus::Locked; + } + if (blob_lease_status == "unlocked") + { + return BlobLeaseStatus::Unlocked; + } + throw std::runtime_error("cannot convert " + blob_lease_status + " to BlobLeaseStatus"); } - if (blob_lease_status == "unlocked") - { - return BlobLeaseStatus::Unlocked; - } - throw std::runtime_error("cannot convert " + blob_lease_status + " to BlobLeaseStatus"); - } + } // namespace Details struct BlobPrefix { @@ -508,43 +522,45 @@ namespace Azure { namespace Storage { namespace Blobs { AppendBlob, }; // enum class BlobType - inline std::string BlobTypeToString(const BlobType& blob_type) - { - switch (blob_type) + namespace Details { + inline std::string BlobTypeToString(const BlobType& blob_type) { - case BlobType::Unknown: - return ""; - case BlobType::BlockBlob: - return "BlockBlob"; - case BlobType::PageBlob: - return "PageBlob"; - case BlobType::AppendBlob: - return "AppendBlob"; - default: - return std::string(); + switch (blob_type) + { + case BlobType::Unknown: + return ""; + case BlobType::BlockBlob: + return "BlockBlob"; + case BlobType::PageBlob: + return "PageBlob"; + case BlobType::AppendBlob: + return "AppendBlob"; + default: + return std::string(); + } } - } - inline BlobType BlobTypeFromString(const std::string& blob_type) - { - if (blob_type == "") + inline BlobType BlobTypeFromString(const std::string& blob_type) { - return BlobType::Unknown; + if (blob_type == "") + { + return BlobType::Unknown; + } + if (blob_type == "BlockBlob") + { + return BlobType::BlockBlob; + } + if (blob_type == "PageBlob") + { + return BlobType::PageBlob; + } + if (blob_type == "AppendBlob") + { + return BlobType::AppendBlob; + } + throw std::runtime_error("cannot convert " + blob_type + " to BlobType"); } - if (blob_type == "BlockBlob") - { - return BlobType::BlockBlob; - } - if (blob_type == "PageBlob") - { - return BlobType::PageBlob; - } - if (blob_type == "AppendBlob") - { - return BlobType::AppendBlob; - } - throw std::runtime_error("cannot convert " + blob_type + " to BlobType"); - } + } // namespace Details enum class BlockListTypeOption { @@ -553,39 +569,42 @@ namespace Azure { namespace Storage { namespace Blobs { All, }; // enum class BlockListTypeOption - inline std::string BlockListTypeOptionToString(const BlockListTypeOption& block_list_type_option) - { - switch (block_list_type_option) + namespace Details { + inline std::string BlockListTypeOptionToString( + const BlockListTypeOption& block_list_type_option) { - case BlockListTypeOption::Committed: - return "committed"; - case BlockListTypeOption::Uncommitted: - return "uncommitted"; - case BlockListTypeOption::All: - return "all"; - default: - return std::string(); + switch (block_list_type_option) + { + case BlockListTypeOption::Committed: + return "committed"; + case BlockListTypeOption::Uncommitted: + return "uncommitted"; + case BlockListTypeOption::All: + return "all"; + default: + return std::string(); + } } - } - inline BlockListTypeOption BlockListTypeOptionFromString( - const std::string& block_list_type_option) - { - if (block_list_type_option == "committed") + inline BlockListTypeOption BlockListTypeOptionFromString( + const std::string& block_list_type_option) { - return BlockListTypeOption::Committed; + if (block_list_type_option == "committed") + { + return BlockListTypeOption::Committed; + } + if (block_list_type_option == "uncommitted") + { + return BlockListTypeOption::Uncommitted; + } + if (block_list_type_option == "all") + { + return BlockListTypeOption::All; + } + throw std::runtime_error( + "cannot convert " + block_list_type_option + " to BlockListTypeOption"); } - if (block_list_type_option == "uncommitted") - { - return BlockListTypeOption::Uncommitted; - } - if (block_list_type_option == "all") - { - return BlockListTypeOption::All; - } - throw std::runtime_error( - "cannot convert " + block_list_type_option + " to BlockListTypeOption"); - } + } // namespace Details enum class BlockType { @@ -594,37 +613,39 @@ namespace Azure { namespace Storage { namespace Blobs { Latest, }; // enum class BlockType - inline std::string BlockTypeToString(const BlockType& block_type) - { - switch (block_type) + namespace Details { + inline std::string BlockTypeToString(const BlockType& block_type) { - case BlockType::Committed: - return "Committed"; - case BlockType::Uncommitted: - return "Uncommitted"; - case BlockType::Latest: - return "Latest"; - default: - return std::string(); + switch (block_type) + { + case BlockType::Committed: + return "Committed"; + case BlockType::Uncommitted: + return "Uncommitted"; + case BlockType::Latest: + return "Latest"; + default: + return std::string(); + } } - } - inline BlockType BlockTypeFromString(const std::string& block_type) - { - if (block_type == "Committed") + inline BlockType BlockTypeFromString(const std::string& block_type) { - return BlockType::Committed; + if (block_type == "Committed") + { + return BlockType::Committed; + } + if (block_type == "Uncommitted") + { + return BlockType::Uncommitted; + } + if (block_type == "Latest") + { + return BlockType::Latest; + } + throw std::runtime_error("cannot convert " + block_type + " to BlockType"); } - if (block_type == "Uncommitted") - { - return BlockType::Uncommitted; - } - if (block_type == "Latest") - { - return BlockType::Latest; - } - throw std::runtime_error("cannot convert " + block_type + " to BlockType"); - } + } // namespace Details struct BreakBlobLeaseResult { @@ -683,37 +704,39 @@ namespace Azure { namespace Storage { namespace Blobs { Pending, }; // enum class CopyStatus - inline std::string CopyStatusToString(const CopyStatus& copy_status) - { - switch (copy_status) + namespace Details { + inline std::string CopyStatusToString(const CopyStatus& copy_status) { - case CopyStatus::Unknown: - return ""; - case CopyStatus::Success: - return "success"; - case CopyStatus::Pending: - return "pending"; - default: - return std::string(); + switch (copy_status) + { + case CopyStatus::Unknown: + return ""; + case CopyStatus::Success: + return "success"; + case CopyStatus::Pending: + return "pending"; + default: + return std::string(); + } } - } - inline CopyStatus CopyStatusFromString(const std::string& copy_status) - { - if (copy_status == "") + inline CopyStatus CopyStatusFromString(const std::string& copy_status) { - return CopyStatus::Unknown; + if (copy_status == "") + { + return CopyStatus::Unknown; + } + if (copy_status == "success") + { + return CopyStatus::Success; + } + if (copy_status == "pending") + { + return CopyStatus::Pending; + } + throw std::runtime_error("cannot convert " + copy_status + " to CopyStatus"); } - if (copy_status == "success") - { - return CopyStatus::Success; - } - if (copy_status == "pending") - { - return CopyStatus::Pending; - } - throw std::runtime_error("cannot convert " + copy_status + " to CopyStatus"); - } + } // namespace Details struct CreateAppendBlobResult { @@ -768,40 +791,42 @@ namespace Azure { namespace Storage { namespace Blobs { Only, }; // enum class DeleteSnapshotsOption - inline std::string DeleteSnapshotsOptionToString( - const DeleteSnapshotsOption& delete_snapshots_option) - { - switch (delete_snapshots_option) + namespace Details { + inline std::string DeleteSnapshotsOptionToString( + const DeleteSnapshotsOption& delete_snapshots_option) { - case DeleteSnapshotsOption::None: - return ""; - case DeleteSnapshotsOption::IncludeSnapshots: - return "include"; - case DeleteSnapshotsOption::Only: - return "only"; - default: - return std::string(); + switch (delete_snapshots_option) + { + case DeleteSnapshotsOption::None: + return ""; + case DeleteSnapshotsOption::IncludeSnapshots: + return "include"; + case DeleteSnapshotsOption::Only: + return "only"; + default: + return std::string(); + } } - } - inline DeleteSnapshotsOption DeleteSnapshotsOptionFromString( - const std::string& delete_snapshots_option) - { - if (delete_snapshots_option == "") + inline DeleteSnapshotsOption DeleteSnapshotsOptionFromString( + const std::string& delete_snapshots_option) { - return DeleteSnapshotsOption::None; + if (delete_snapshots_option == "") + { + return DeleteSnapshotsOption::None; + } + if (delete_snapshots_option == "include") + { + return DeleteSnapshotsOption::IncludeSnapshots; + } + if (delete_snapshots_option == "only") + { + return DeleteSnapshotsOption::Only; + } + throw std::runtime_error( + "cannot convert " + delete_snapshots_option + " to DeleteSnapshotsOption"); } - if (delete_snapshots_option == "include") - { - return DeleteSnapshotsOption::IncludeSnapshots; - } - if (delete_snapshots_option == "only") - { - return DeleteSnapshotsOption::Only; - } - throw std::runtime_error( - "cannot convert " + delete_snapshots_option + " to DeleteSnapshotsOption"); - } + } // namespace Details enum class EncryptionAlgorithmType { @@ -809,34 +834,36 @@ namespace Azure { namespace Storage { namespace Blobs { Aes256, }; // enum class EncryptionAlgorithmType - inline std::string EncryptionAlgorithmTypeToString( - const EncryptionAlgorithmType& encryption_algorithm_type) - { - switch (encryption_algorithm_type) + namespace Details { + inline std::string EncryptionAlgorithmTypeToString( + const EncryptionAlgorithmType& encryption_algorithm_type) { - case EncryptionAlgorithmType::Unknown: - return ""; - case EncryptionAlgorithmType::Aes256: - return "AES256"; - default: - return std::string(); + switch (encryption_algorithm_type) + { + case EncryptionAlgorithmType::Unknown: + return ""; + case EncryptionAlgorithmType::Aes256: + return "AES256"; + default: + return std::string(); + } } - } - inline EncryptionAlgorithmType EncryptionAlgorithmTypeFromString( - const std::string& encryption_algorithm_type) - { - if (encryption_algorithm_type == "") + inline EncryptionAlgorithmType EncryptionAlgorithmTypeFromString( + const std::string& encryption_algorithm_type) { - return EncryptionAlgorithmType::Unknown; + if (encryption_algorithm_type == "") + { + return EncryptionAlgorithmType::Unknown; + } + if (encryption_algorithm_type == "AES256") + { + return EncryptionAlgorithmType::Aes256; + } + throw std::runtime_error( + "cannot convert " + encryption_algorithm_type + " to EncryptionAlgorithmType"); } - if (encryption_algorithm_type == "AES256") - { - return EncryptionAlgorithmType::Aes256; - } - throw std::runtime_error( - "cannot convert " + encryption_algorithm_type + " to EncryptionAlgorithmType"); - } + } // namespace Details struct FilterBlobItem { @@ -911,30 +938,33 @@ namespace Azure { namespace Storage { namespace Blobs { return lhs; } - inline std::string ListBlobContainersIncludeItemToString(const ListBlobContainersIncludeItem& val) - { - ListBlobContainersIncludeItem value_list[] = { - ListBlobContainersIncludeItem::Metadata, - ListBlobContainersIncludeItem::Deleted, - }; - const char* string_list[] = { - "metadata", - "deleted", - }; - std::string ret; - for (std::size_t i = 0; i < sizeof(value_list) / sizeof(ListBlobContainersIncludeItem); ++i) + namespace Details { + inline std::string ListBlobContainersIncludeItemToString( + const ListBlobContainersIncludeItem& val) { - if ((val & value_list[i]) == value_list[i]) + ListBlobContainersIncludeItem value_list[] = { + ListBlobContainersIncludeItem::Metadata, + ListBlobContainersIncludeItem::Deleted, + }; + const char* string_list[] = { + "metadata", + "deleted", + }; + std::string ret; + for (std::size_t i = 0; i < sizeof(value_list) / sizeof(ListBlobContainersIncludeItem); ++i) { - if (!ret.empty()) + if ((val & value_list[i]) == value_list[i]) { - ret += ","; + if (!ret.empty()) + { + ret += ","; + } + ret += string_list[i]; } - ret += string_list[i]; } + return ret; } - return ret; - } + } // namespace Details enum class ListBlobsIncludeItem { @@ -971,38 +1001,40 @@ namespace Azure { namespace Storage { namespace Blobs { return lhs; } - inline std::string ListBlobsIncludeItemToString(const ListBlobsIncludeItem& val) - { - ListBlobsIncludeItem value_list[] = { - ListBlobsIncludeItem::Copy, - ListBlobsIncludeItem::Deleted, - ListBlobsIncludeItem::Metadata, - ListBlobsIncludeItem::Snapshots, - ListBlobsIncludeItem::Versions, - ListBlobsIncludeItem::UncomittedBlobs, - }; - const char* string_list[] = { - "copy", - "deleted", - "metadata", - "snapshots", - "versions", - "uncommittedblobs", - }; - std::string ret; - for (std::size_t i = 0; i < sizeof(value_list) / sizeof(ListBlobsIncludeItem); ++i) + namespace Details { + inline std::string ListBlobsIncludeItemToString(const ListBlobsIncludeItem& val) { - if ((val & value_list[i]) == value_list[i]) + ListBlobsIncludeItem value_list[] = { + ListBlobsIncludeItem::Copy, + ListBlobsIncludeItem::Deleted, + ListBlobsIncludeItem::Metadata, + ListBlobsIncludeItem::Snapshots, + ListBlobsIncludeItem::Versions, + ListBlobsIncludeItem::UncomittedBlobs, + }; + const char* string_list[] = { + "copy", + "deleted", + "metadata", + "snapshots", + "versions", + "uncommittedblobs", + }; + std::string ret; + for (std::size_t i = 0; i < sizeof(value_list) / sizeof(ListBlobsIncludeItem); ++i) { - if (!ret.empty()) + if ((val & value_list[i]) == value_list[i]) { - ret += ","; + if (!ret.empty()) + { + ret += ","; + } + ret += string_list[i]; } - ret += string_list[i]; } + return ret; } - return ret; - } + } // namespace Details enum class ObjectReplicationStatus { @@ -1011,40 +1043,42 @@ namespace Azure { namespace Storage { namespace Blobs { Failed, }; // enum class ObjectReplicationStatus - inline std::string ObjectReplicationStatusToString( - const ObjectReplicationStatus& object_replication_status) - { - switch (object_replication_status) + namespace Details { + inline std::string ObjectReplicationStatusToString( + const ObjectReplicationStatus& object_replication_status) { - case ObjectReplicationStatus::Unknown: - return ""; - case ObjectReplicationStatus::Complete: - return "complete"; - case ObjectReplicationStatus::Failed: - return "failed"; - default: - return std::string(); + switch (object_replication_status) + { + case ObjectReplicationStatus::Unknown: + return ""; + case ObjectReplicationStatus::Complete: + return "complete"; + case ObjectReplicationStatus::Failed: + return "failed"; + default: + return std::string(); + } } - } - inline ObjectReplicationStatus ObjectReplicationStatusFromString( - const std::string& object_replication_status) - { - if (object_replication_status == "") + inline ObjectReplicationStatus ObjectReplicationStatusFromString( + const std::string& object_replication_status) { - return ObjectReplicationStatus::Unknown; + if (object_replication_status == "") + { + return ObjectReplicationStatus::Unknown; + } + if (object_replication_status == "complete") + { + return ObjectReplicationStatus::Complete; + } + if (object_replication_status == "failed") + { + return ObjectReplicationStatus::Failed; + } + throw std::runtime_error( + "cannot convert " + object_replication_status + " to ObjectReplicationStatus"); } - if (object_replication_status == "complete") - { - return ObjectReplicationStatus::Complete; - } - if (object_replication_status == "failed") - { - return ObjectReplicationStatus::Failed; - } - throw std::runtime_error( - "cannot convert " + object_replication_status + " to ObjectReplicationStatus"); - } + } // namespace Details enum class PublicAccessType { @@ -1053,37 +1087,39 @@ namespace Azure { namespace Storage { namespace Blobs { Private, }; // enum class PublicAccessType - inline std::string PublicAccessTypeToString(const PublicAccessType& public_access_type) - { - switch (public_access_type) + namespace Details { + inline std::string PublicAccessTypeToString(const PublicAccessType& public_access_type) { - case PublicAccessType::Container: - return "container"; - case PublicAccessType::Blob: - return "blob"; - case PublicAccessType::Private: - return ""; - default: - return std::string(); + switch (public_access_type) + { + case PublicAccessType::Container: + return "container"; + case PublicAccessType::Blob: + return "blob"; + case PublicAccessType::Private: + return ""; + default: + return std::string(); + } } - } - inline PublicAccessType PublicAccessTypeFromString(const std::string& public_access_type) - { - if (public_access_type == "container") + inline PublicAccessType PublicAccessTypeFromString(const std::string& public_access_type) { - return PublicAccessType::Container; + if (public_access_type == "container") + { + return PublicAccessType::Container; + } + if (public_access_type == "blob") + { + return PublicAccessType::Blob; + } + if (public_access_type == "") + { + return PublicAccessType::Private; + } + throw std::runtime_error("cannot convert " + public_access_type + " to PublicAccessType"); } - if (public_access_type == "blob") - { - return PublicAccessType::Blob; - } - if (public_access_type == "") - { - return PublicAccessType::Private; - } - throw std::runtime_error("cannot convert " + public_access_type + " to PublicAccessType"); - } + } // namespace Details enum class RehydratePriority { @@ -1092,37 +1128,39 @@ namespace Azure { namespace Storage { namespace Blobs { Standard, }; // enum class RehydratePriority - inline std::string RehydratePriorityToString(const RehydratePriority& rehydrate_priority) - { - switch (rehydrate_priority) + namespace Details { + inline std::string RehydratePriorityToString(const RehydratePriority& rehydrate_priority) { - case RehydratePriority::Unknown: - return ""; - case RehydratePriority::High: - return "High"; - case RehydratePriority::Standard: - return "Standard"; - default: - return std::string(); + switch (rehydrate_priority) + { + case RehydratePriority::Unknown: + return ""; + case RehydratePriority::High: + return "High"; + case RehydratePriority::Standard: + return "Standard"; + default: + return std::string(); + } } - } - inline RehydratePriority RehydratePriorityFromString(const std::string& rehydrate_priority) - { - if (rehydrate_priority == "") + inline RehydratePriority RehydratePriorityFromString(const std::string& rehydrate_priority) { - return RehydratePriority::Unknown; + if (rehydrate_priority == "") + { + return RehydratePriority::Unknown; + } + if (rehydrate_priority == "High") + { + return RehydratePriority::High; + } + if (rehydrate_priority == "Standard") + { + return RehydratePriority::Standard; + } + throw std::runtime_error("cannot convert " + rehydrate_priority + " to RehydratePriority"); } - if (rehydrate_priority == "High") - { - return RehydratePriority::High; - } - if (rehydrate_priority == "Standard") - { - return RehydratePriority::Standard; - } - throw std::runtime_error("cannot convert " + rehydrate_priority + " to RehydratePriority"); - } + } // namespace Details struct ReleaseBlobLeaseResult { @@ -1167,52 +1205,55 @@ namespace Azure { namespace Storage { namespace Blobs { Absolute, }; // enum class ScheduleBlobExpiryOriginType - inline std::string ScheduleBlobExpiryOriginTypeToString( - const ScheduleBlobExpiryOriginType& schedule_blob_expiry_origin_type) - { - switch (schedule_blob_expiry_origin_type) + namespace Details { + inline std::string ScheduleBlobExpiryOriginTypeToString( + const ScheduleBlobExpiryOriginType& schedule_blob_expiry_origin_type) { - case ScheduleBlobExpiryOriginType::Unknown: - return ""; - case ScheduleBlobExpiryOriginType::NeverExpire: - return "NeverExpire"; - case ScheduleBlobExpiryOriginType::RelativeToCreation: - return "RelativeToCreation"; - case ScheduleBlobExpiryOriginType::RelativeToNow: - return "RelativeToNow"; - case ScheduleBlobExpiryOriginType::Absolute: - return "Absolute"; - default: - return std::string(); + switch (schedule_blob_expiry_origin_type) + { + case ScheduleBlobExpiryOriginType::Unknown: + return ""; + case ScheduleBlobExpiryOriginType::NeverExpire: + return "NeverExpire"; + case ScheduleBlobExpiryOriginType::RelativeToCreation: + return "RelativeToCreation"; + case ScheduleBlobExpiryOriginType::RelativeToNow: + return "RelativeToNow"; + case ScheduleBlobExpiryOriginType::Absolute: + return "Absolute"; + default: + return std::string(); + } } - } - inline ScheduleBlobExpiryOriginType ScheduleBlobExpiryOriginTypeFromString( - const std::string& schedule_blob_expiry_origin_type) - { - if (schedule_blob_expiry_origin_type == "") + inline ScheduleBlobExpiryOriginType ScheduleBlobExpiryOriginTypeFromString( + const std::string& schedule_blob_expiry_origin_type) { - return ScheduleBlobExpiryOriginType::Unknown; + if (schedule_blob_expiry_origin_type == "") + { + return ScheduleBlobExpiryOriginType::Unknown; + } + if (schedule_blob_expiry_origin_type == "NeverExpire") + { + return ScheduleBlobExpiryOriginType::NeverExpire; + } + if (schedule_blob_expiry_origin_type == "RelativeToCreation") + { + return ScheduleBlobExpiryOriginType::RelativeToCreation; + } + if (schedule_blob_expiry_origin_type == "RelativeToNow") + { + return ScheduleBlobExpiryOriginType::RelativeToNow; + } + if (schedule_blob_expiry_origin_type == "Absolute") + { + return ScheduleBlobExpiryOriginType::Absolute; + } + throw std::runtime_error( + "cannot convert " + schedule_blob_expiry_origin_type + + " to ScheduleBlobExpiryOriginType"); } - if (schedule_blob_expiry_origin_type == "NeverExpire") - { - return ScheduleBlobExpiryOriginType::NeverExpire; - } - if (schedule_blob_expiry_origin_type == "RelativeToCreation") - { - return ScheduleBlobExpiryOriginType::RelativeToCreation; - } - if (schedule_blob_expiry_origin_type == "RelativeToNow") - { - return ScheduleBlobExpiryOriginType::RelativeToNow; - } - if (schedule_blob_expiry_origin_type == "Absolute") - { - return ScheduleBlobExpiryOriginType::Absolute; - } - throw std::runtime_error( - "cannot convert " + schedule_blob_expiry_origin_type + " to ScheduleBlobExpiryOriginType"); - } + } // namespace Details struct SealAppendBlobResult { @@ -1276,73 +1317,75 @@ namespace Azure { namespace Storage { namespace Blobs { StandardRagzrs, }; // enum class SkuName - inline std::string SkuNameToString(const SkuName& sku_name) - { - switch (sku_name) + namespace Details { + inline std::string SkuNameToString(const SkuName& sku_name) { - case SkuName::Unknown: - return ""; - case SkuName::StandardLrs: - return "Standard_LRS"; - case SkuName::StandardGrs: - return "Standard_GRS"; - case SkuName::StandardRagrs: - return "Standard_RAGRS"; - case SkuName::StandardZrs: - return "Standard_ZRS"; - case SkuName::PremiumLrs: - return "Premium_LRS"; - case SkuName::PremiumZrs: - return "Premium_ZRS"; - case SkuName::StandardGzrs: - return "Standard_GZRS"; - case SkuName::StandardRagzrs: - return "Standard_RAGZRS"; - default: - return std::string(); + switch (sku_name) + { + case SkuName::Unknown: + return ""; + case SkuName::StandardLrs: + return "Standard_LRS"; + case SkuName::StandardGrs: + return "Standard_GRS"; + case SkuName::StandardRagrs: + return "Standard_RAGRS"; + case SkuName::StandardZrs: + return "Standard_ZRS"; + case SkuName::PremiumLrs: + return "Premium_LRS"; + case SkuName::PremiumZrs: + return "Premium_ZRS"; + case SkuName::StandardGzrs: + return "Standard_GZRS"; + case SkuName::StandardRagzrs: + return "Standard_RAGZRS"; + default: + return std::string(); + } } - } - inline SkuName SkuNameFromString(const std::string& sku_name) - { - if (sku_name == "") + inline SkuName SkuNameFromString(const std::string& sku_name) { - return SkuName::Unknown; + if (sku_name == "") + { + return SkuName::Unknown; + } + if (sku_name == "Standard_LRS") + { + return SkuName::StandardLrs; + } + if (sku_name == "Standard_GRS") + { + return SkuName::StandardGrs; + } + if (sku_name == "Standard_RAGRS") + { + return SkuName::StandardRagrs; + } + if (sku_name == "Standard_ZRS") + { + return SkuName::StandardZrs; + } + if (sku_name == "Premium_LRS") + { + return SkuName::PremiumLrs; + } + if (sku_name == "Premium_ZRS") + { + return SkuName::PremiumZrs; + } + if (sku_name == "Standard_GZRS") + { + return SkuName::StandardGzrs; + } + if (sku_name == "Standard_RAGZRS") + { + return SkuName::StandardRagzrs; + } + throw std::runtime_error("cannot convert " + sku_name + " to SkuName"); } - if (sku_name == "Standard_LRS") - { - return SkuName::StandardLrs; - } - if (sku_name == "Standard_GRS") - { - return SkuName::StandardGrs; - } - if (sku_name == "Standard_RAGRS") - { - return SkuName::StandardRagrs; - } - if (sku_name == "Standard_ZRS") - { - return SkuName::StandardZrs; - } - if (sku_name == "Premium_LRS") - { - return SkuName::PremiumLrs; - } - if (sku_name == "Premium_ZRS") - { - return SkuName::PremiumZrs; - } - if (sku_name == "Standard_GZRS") - { - return SkuName::StandardGzrs; - } - if (sku_name == "Standard_RAGZRS") - { - return SkuName::StandardRagzrs; - } - throw std::runtime_error("cannot convert " + sku_name + " to SkuName"); - } + } // namespace Details struct StageBlockFromUriResult { @@ -1685,7826 +1728,7852 @@ namespace Azure { namespace Storage { namespace Blobs { std::vector Items; }; // struct ListBlobsFlatSegmentResult - class BlobRestClient { - public: - class Service { + namespace Details { + class BlobRestClient { public: - struct ListContainersSegmentOptions - { - Azure::Core::Nullable Timeout; - Azure::Core::Nullable Prefix; - Azure::Core::Nullable ContinuationToken; - Azure::Core::Nullable MaxResults; - ListBlobContainersIncludeItem Include = ListBlobContainersIncludeItem::None; - }; // struct ListContainersSegmentOptions - - static Azure::Core::Response ListBlobContainers( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const ListContainersSegmentOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) + class Service { + public: + struct ListContainersSegmentOptions { + Azure::Core::Nullable Timeout; + Azure::Core::Nullable Prefix; + Azure::Core::Nullable ContinuationToken; + Azure::Core::Nullable MaxResults; + ListBlobContainersIncludeItem Include = ListBlobContainersIncludeItem::None; + }; // struct ListContainersSegmentOptions + + static Azure::Core::Response ListBlobContainers( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const ListContainersSegmentOptions& options) + { + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + request.GetUrl().AppendQueryParameter("comp", "list"); + if (options.Prefix.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "prefix", Storage::Details::UrlEncodeQueryParameter(options.Prefix.GetValue())); + } + if (options.ContinuationToken.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "marker", + Storage::Details::UrlEncodeQueryParameter(options.ContinuationToken.GetValue())); + } + if (options.MaxResults.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "maxresults", std::to_string(options.MaxResults.GetValue())); + } + std::string list_blob_containers_include_item + = ListBlobContainersIncludeItemToString(options.Include); + if (!list_blob_containers_include_item.empty()) + { + request.GetUrl().AppendQueryParameter( + "include", + Storage::Details::UrlEncodeQueryParameter(list_blob_containers_include_item)); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + ListContainersSegmentResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 200)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + { + const auto& httpResponseBody = httpResponse.GetBody(); + XmlReader reader( + reinterpret_cast(httpResponseBody.data()), httpResponseBody.size()); + response = ListContainersSegmentResultFromXml(reader); + } + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); + } + + struct GetUserDelegationKeyOptions + { + Azure::Core::Nullable Timeout; + std::string StartsOn; + std::string ExpiresOn; + }; // struct GetUserDelegationKeyOptions + + static Azure::Core::Response GetUserDelegationKey( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const GetUserDelegationKeyOptions& options) + { + unused(options); + std::string xml_body; + { + XmlWriter writer; + GetUserDelegationKeyOptionsToXml(writer, options); + xml_body = writer.GetDocument(); + writer.Write(XmlNode{XmlNodeType::End}); + } + Azure::Core::Http::MemoryBodyStream xml_body_stream( + reinterpret_cast(xml_body.data()), xml_body.length()); + auto request = Azure::Core::Http::Request( + Azure::Core::Http::HttpMethod::Post, url, &xml_body_stream); + request.AddHeader("Content-Length", std::to_string(xml_body_stream.Length())); + request.GetUrl().AppendQueryParameter("restype", "service"); + request.GetUrl().AppendQueryParameter("comp", "userdelegationkey"); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + GetUserDelegationKeyResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 200)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + { + const auto& httpResponseBody = httpResponse.GetBody(); + XmlReader reader( + reinterpret_cast(httpResponseBody.data()), httpResponseBody.size()); + response = GetUserDelegationKeyResultFromXml(reader); + } + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); + } + + struct GetServicePropertiesOptions + { + Azure::Core::Nullable Timeout; + }; // struct GetServicePropertiesOptions + + static Azure::Core::Response GetProperties( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const GetServicePropertiesOptions& options) + { + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url); + request.GetUrl().AppendQueryParameter("restype", "service"); + request.GetUrl().AppendQueryParameter("comp", "properties"); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + GetServicePropertiesResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 200)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + { + const auto& httpResponseBody = httpResponse.GetBody(); + XmlReader reader( + reinterpret_cast(httpResponseBody.data()), httpResponseBody.size()); + response = GetServicePropertiesResultFromXml(reader); + } + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); + } + + struct SetServicePropertiesOptions + { + Azure::Core::Nullable Timeout; + BlobServiceProperties Properties; + }; // struct SetServicePropertiesOptions + + static Azure::Core::Response SetProperties( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const SetServicePropertiesOptions& options) + { + unused(options); + std::string xml_body; + { + XmlWriter writer; + SetServicePropertiesOptionsToXml(writer, options); + xml_body = writer.GetDocument(); + writer.Write(XmlNode{XmlNodeType::End}); + } + Azure::Core::Http::MemoryBodyStream xml_body_stream( + reinterpret_cast(xml_body.data()), xml_body.length()); + auto request = Azure::Core::Http::Request( + Azure::Core::Http::HttpMethod::Put, url, &xml_body_stream); + request.AddHeader("Content-Length", std::to_string(xml_body_stream.Length())); + request.GetUrl().AppendQueryParameter("restype", "service"); + request.GetUrl().AppendQueryParameter("comp", "properties"); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + SetServicePropertiesResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 202)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); + } + + struct GetAccountInfoOptions + { + Azure::Core::Nullable Timeout; + }; // struct GetAccountInfoOptions + + static Azure::Core::Response GetAccountInfo( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const GetAccountInfoOptions& options) + { + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Head, url); + request.GetUrl().AppendQueryParameter("restype", "account"); + request.GetUrl().AppendQueryParameter("comp", "properties"); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + GetAccountInfoResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 200)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + response.SkuName = SkuNameFromString(httpResponse.GetHeaders().at("x-ms-sku-name")); + response.AccountKind + = AccountKindFromString(httpResponse.GetHeaders().at("x-ms-account-kind")); + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); + } + + struct GetServiceStatisticsOptions + { + Azure::Core::Nullable Timeout; + }; // struct GetServiceStatisticsOptions + + static Azure::Core::Response GetStatistics( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const GetServiceStatisticsOptions& options) + { + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url); + request.GetUrl().AppendQueryParameter("restype", "service"); + request.GetUrl().AppendQueryParameter("comp", "stats"); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + GetServiceStatisticsResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 200)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + { + const auto& httpResponseBody = httpResponse.GetBody(); + XmlReader reader( + reinterpret_cast(httpResponseBody.data()), httpResponseBody.size()); + response = GetServiceStatisticsResultFromXml(reader); + } + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); + } + + struct FilterBlobsSegmentOptions + { + Azure::Core::Nullable Timeout; + std::string Where; + Azure::Core::Nullable ContinuationToken; + Azure::Core::Nullable MaxResults; + }; // struct FilterBlobsSegmentOptions + + static Azure::Core::Response FilterBlobs( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const FilterBlobsSegmentOptions& options) + { + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + request.GetUrl().AppendQueryParameter("comp", "blobs"); request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - request.GetUrl().AppendQueryParameter("comp", "list"); - if (options.Prefix.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "prefix", Details::UrlEncodeQueryParameter(options.Prefix.GetValue())); - } - if (options.ContinuationToken.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "marker", Details::UrlEncodeQueryParameter(options.ContinuationToken.GetValue())); - } - if (options.MaxResults.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "maxresults", std::to_string(options.MaxResults.GetValue())); - } - std::string list_blob_containers_include_item - = ListBlobContainersIncludeItemToString(options.Include); - if (!list_blob_containers_include_item.empty()) - { - request.GetUrl().AppendQueryParameter( - "include", Details::UrlEncodeQueryParameter(list_blob_containers_include_item)); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - ListContainersSegmentResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 200)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - { - const auto& httpResponseBody = httpResponse.GetBody(); - XmlReader reader( - reinterpret_cast(httpResponseBody.data()), httpResponseBody.size()); - response = ListContainersSegmentResultFromXml(reader); - } - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct GetUserDelegationKeyOptions - { - Azure::Core::Nullable Timeout; - std::string StartsOn; - std::string ExpiresOn; - }; // struct GetUserDelegationKeyOptions - - static Azure::Core::Response GetUserDelegationKey( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const GetUserDelegationKeyOptions& options) - { - unused(options); - std::string xml_body; - { - XmlWriter writer; - GetUserDelegationKeyOptionsToXml(writer, options); - xml_body = writer.GetDocument(); - writer.Write(XmlNode{XmlNodeType::End}); - } - Azure::Core::Http::MemoryBodyStream xml_body_stream( - reinterpret_cast(xml_body.data()), xml_body.length()); - auto request = Azure::Core::Http::Request( - Azure::Core::Http::HttpMethod::Post, url, &xml_body_stream); - request.AddHeader("Content-Length", std::to_string(xml_body_stream.Length())); - request.GetUrl().AppendQueryParameter("restype", "service"); - request.GetUrl().AppendQueryParameter("comp", "userdelegationkey"); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - GetUserDelegationKeyResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 200)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - { - const auto& httpResponseBody = httpResponse.GetBody(); - XmlReader reader( - reinterpret_cast(httpResponseBody.data()), httpResponseBody.size()); - response = GetUserDelegationKeyResultFromXml(reader); - } - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct GetServicePropertiesOptions - { - Azure::Core::Nullable Timeout; - }; // struct GetServicePropertiesOptions - - static Azure::Core::Response GetProperties( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const GetServicePropertiesOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url); - request.GetUrl().AppendQueryParameter("restype", "service"); - request.GetUrl().AppendQueryParameter("comp", "properties"); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - GetServicePropertiesResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 200)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - { - const auto& httpResponseBody = httpResponse.GetBody(); - XmlReader reader( - reinterpret_cast(httpResponseBody.data()), httpResponseBody.size()); - response = GetServicePropertiesResultFromXml(reader); - } - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct SetServicePropertiesOptions - { - Azure::Core::Nullable Timeout; - BlobServiceProperties Properties; - }; // struct SetServicePropertiesOptions - - static Azure::Core::Response SetProperties( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const SetServicePropertiesOptions& options) - { - unused(options); - std::string xml_body; - { - XmlWriter writer; - SetServicePropertiesOptionsToXml(writer, options); - xml_body = writer.GetDocument(); - writer.Write(XmlNode{XmlNodeType::End}); - } - Azure::Core::Http::MemoryBodyStream xml_body_stream( - reinterpret_cast(xml_body.data()), xml_body.length()); - auto request - = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url, &xml_body_stream); - request.AddHeader("Content-Length", std::to_string(xml_body_stream.Length())); - request.GetUrl().AppendQueryParameter("restype", "service"); - request.GetUrl().AppendQueryParameter("comp", "properties"); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - SetServicePropertiesResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 202)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct GetAccountInfoOptions - { - Azure::Core::Nullable Timeout; - }; // struct GetAccountInfoOptions - - static Azure::Core::Response GetAccountInfo( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const GetAccountInfoOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Head, url); - request.GetUrl().AppendQueryParameter("restype", "account"); - request.GetUrl().AppendQueryParameter("comp", "properties"); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - GetAccountInfoResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 200)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - response.SkuName = SkuNameFromString(httpResponse.GetHeaders().at("x-ms-sku-name")); - response.AccountKind - = AccountKindFromString(httpResponse.GetHeaders().at("x-ms-account-kind")); - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct GetServiceStatisticsOptions - { - Azure::Core::Nullable Timeout; - }; // struct GetServiceStatisticsOptions - - static Azure::Core::Response GetStatistics( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const GetServiceStatisticsOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url); - request.GetUrl().AppendQueryParameter("restype", "service"); - request.GetUrl().AppendQueryParameter("comp", "stats"); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - GetServiceStatisticsResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 200)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - { - const auto& httpResponseBody = httpResponse.GetBody(); - XmlReader reader( - reinterpret_cast(httpResponseBody.data()), httpResponseBody.size()); - response = GetServiceStatisticsResultFromXml(reader); - } - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct FilterBlobsSegmentOptions - { - Azure::Core::Nullable Timeout; - std::string Where; - Azure::Core::Nullable ContinuationToken; - Azure::Core::Nullable MaxResults; - }; // struct FilterBlobsSegmentOptions - - static Azure::Core::Response FilterBlobs( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const FilterBlobsSegmentOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - request.GetUrl().AppendQueryParameter("comp", "blobs"); - request.GetUrl().AppendQueryParameter( - "where", Details::UrlEncodeQueryParameter(options.Where)); - if (options.ContinuationToken.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "marker", Details::UrlEncodeQueryParameter(options.ContinuationToken.GetValue())); - } - if (options.MaxResults.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "maxresults", std::to_string(options.MaxResults.GetValue())); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - FilterBlobsSegmentResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 200)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - { - const auto& httpResponseBody = httpResponse.GetBody(); - XmlReader reader( - reinterpret_cast(httpResponseBody.data()), httpResponseBody.size()); - response = FilterBlobsSegmentResultFromXml(reader); - } - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - private: - static FilterBlobsSegmentResult FilterBlobsSegmentResultFromXml(XmlReader& reader) - { - FilterBlobsSegmentResult ret; - enum class XmlTagName - { - k_EnumerationResults, - k_Where, - k_NextMarker, - k_Blobs, - k_Blob, - k_Unknown, - }; - std::vector path; - while (true) - { - auto node = reader.Read(); - if (node.Type == XmlNodeType::End) + "where", Storage::Details::UrlEncodeQueryParameter(options.Where)); + if (options.ContinuationToken.HasValue()) { - break; + request.GetUrl().AppendQueryParameter( + "marker", + Storage::Details::UrlEncodeQueryParameter(options.ContinuationToken.GetValue())); } - else if (node.Type == XmlNodeType::EndTag) + if (options.MaxResults.HasValue()) { - if (path.size() > 0) - { - path.pop_back(); - } - else + request.GetUrl().AppendQueryParameter( + "maxresults", std::to_string(options.MaxResults.GetValue())); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + FilterBlobsSegmentResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 200)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + { + const auto& httpResponseBody = httpResponse.GetBody(); + XmlReader reader( + reinterpret_cast(httpResponseBody.data()), httpResponseBody.size()); + response = FilterBlobsSegmentResultFromXml(reader); + } + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); + } + + private: + static FilterBlobsSegmentResult FilterBlobsSegmentResultFromXml(XmlReader& reader) + { + FilterBlobsSegmentResult ret; + enum class XmlTagName + { + k_EnumerationResults, + k_Where, + k_NextMarker, + k_Blobs, + k_Blob, + k_Unknown, + }; + std::vector path; + while (true) + { + auto node = reader.Read(); + if (node.Type == XmlNodeType::End) { break; } - } - else if (node.Type == XmlNodeType::StartTag) - { - if (std::strcmp(node.Name, "EnumerationResults") == 0) + else if (node.Type == XmlNodeType::EndTag) { - path.emplace_back(XmlTagName::k_EnumerationResults); + if (path.size() > 0) + { + path.pop_back(); + } + else + { + break; + } } - else if (std::strcmp(node.Name, "Where") == 0) + else if (node.Type == XmlNodeType::StartTag) { - path.emplace_back(XmlTagName::k_Where); + if (std::strcmp(node.Name, "EnumerationResults") == 0) + { + path.emplace_back(XmlTagName::k_EnumerationResults); + } + else if (std::strcmp(node.Name, "Where") == 0) + { + path.emplace_back(XmlTagName::k_Where); + } + else if (std::strcmp(node.Name, "NextMarker") == 0) + { + path.emplace_back(XmlTagName::k_NextMarker); + } + else if (std::strcmp(node.Name, "Blobs") == 0) + { + path.emplace_back(XmlTagName::k_Blobs); + } + else if (std::strcmp(node.Name, "Blob") == 0) + { + path.emplace_back(XmlTagName::k_Blob); + } + else + { + path.emplace_back(XmlTagName::k_Unknown); + } + if (path.size() == 3 && path[0] == XmlTagName::k_EnumerationResults + && path[1] == XmlTagName::k_Blobs && path[2] == XmlTagName::k_Blob) + { + ret.Items.emplace_back(FilterBlobItemFromXml(reader)); + path.pop_back(); + } } - else if (std::strcmp(node.Name, "NextMarker") == 0) + else if (node.Type == XmlNodeType::Text) { - path.emplace_back(XmlTagName::k_NextMarker); + if (path.size() == 2 && path[0] == XmlTagName::k_EnumerationResults + && path[1] == XmlTagName::k_Where) + { + ret.Where = node.Value; + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_EnumerationResults + && path[1] == XmlTagName::k_NextMarker) + { + ret.ContinuationToken = node.Value; + } } - else if (std::strcmp(node.Name, "Blobs") == 0) + else if (node.Type == XmlNodeType::Attribute) { - path.emplace_back(XmlTagName::k_Blobs); - } - else if (std::strcmp(node.Name, "Blob") == 0) - { - path.emplace_back(XmlTagName::k_Blob); - } - else - { - path.emplace_back(XmlTagName::k_Unknown); - } - if (path.size() == 3 && path[0] == XmlTagName::k_EnumerationResults - && path[1] == XmlTagName::k_Blobs && path[2] == XmlTagName::k_Blob) - { - ret.Items.emplace_back(FilterBlobItemFromXml(reader)); - path.pop_back(); - } - } - else if (node.Type == XmlNodeType::Text) - { - if (path.size() == 2 && path[0] == XmlTagName::k_EnumerationResults - && path[1] == XmlTagName::k_Where) - { - ret.Where = node.Value; - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_EnumerationResults - && path[1] == XmlTagName::k_NextMarker) - { - ret.ContinuationToken = node.Value; - } - } - else if (node.Type == XmlNodeType::Attribute) - { - if (path.size() == 1 && path[0] == XmlTagName::k_EnumerationResults - && std::strcmp(node.Name, "ServiceEndpoint") == 0) - { - ret.ServiceEndpoint = node.Value; + if (path.size() == 1 && path[0] == XmlTagName::k_EnumerationResults + && std::strcmp(node.Name, "ServiceEndpoint") == 0) + { + ret.ServiceEndpoint = node.Value; + } } } + return ret; } - return ret; - } - static GetServicePropertiesResult GetServicePropertiesResultFromXml(XmlReader& reader) - { - GetServicePropertiesResult ret; - enum class XmlTagName + static GetServicePropertiesResult GetServicePropertiesResultFromXml(XmlReader& reader) { - k_StorageServiceProperties, - k_Logging, - k_HourMetrics, - k_MinuteMetrics, - k_Cors, - k_CorsRule, - k_DefaultServiceVersion, - k_DeleteRetentionPolicy, - k_StaticWebsite, - k_Unknown, - }; - std::vector path; - while (true) - { - auto node = reader.Read(); - if (node.Type == XmlNodeType::End) + GetServicePropertiesResult ret; + enum class XmlTagName { - break; - } - else if (node.Type == XmlNodeType::EndTag) + k_StorageServiceProperties, + k_Logging, + k_HourMetrics, + k_MinuteMetrics, + k_Cors, + k_CorsRule, + k_DefaultServiceVersion, + k_DeleteRetentionPolicy, + k_StaticWebsite, + k_Unknown, + }; + std::vector path; + while (true) { - if (path.size() > 0) - { - path.pop_back(); - } - else + auto node = reader.Read(); + if (node.Type == XmlNodeType::End) { break; } - } - else if (node.Type == XmlNodeType::StartTag) - { - if (std::strcmp(node.Name, "StorageServiceProperties") == 0) + else if (node.Type == XmlNodeType::EndTag) { - path.emplace_back(XmlTagName::k_StorageServiceProperties); + if (path.size() > 0) + { + path.pop_back(); + } + else + { + break; + } } - else if (std::strcmp(node.Name, "Logging") == 0) + else if (node.Type == XmlNodeType::StartTag) { - path.emplace_back(XmlTagName::k_Logging); + if (std::strcmp(node.Name, "StorageServiceProperties") == 0) + { + path.emplace_back(XmlTagName::k_StorageServiceProperties); + } + else if (std::strcmp(node.Name, "Logging") == 0) + { + path.emplace_back(XmlTagName::k_Logging); + } + else if (std::strcmp(node.Name, "HourMetrics") == 0) + { + path.emplace_back(XmlTagName::k_HourMetrics); + } + else if (std::strcmp(node.Name, "MinuteMetrics") == 0) + { + path.emplace_back(XmlTagName::k_MinuteMetrics); + } + else if (std::strcmp(node.Name, "Cors") == 0) + { + path.emplace_back(XmlTagName::k_Cors); + } + else if (std::strcmp(node.Name, "CorsRule") == 0) + { + path.emplace_back(XmlTagName::k_CorsRule); + } + else if (std::strcmp(node.Name, "DefaultServiceVersion") == 0) + { + path.emplace_back(XmlTagName::k_DefaultServiceVersion); + } + else if (std::strcmp(node.Name, "DeleteRetentionPolicy") == 0) + { + path.emplace_back(XmlTagName::k_DeleteRetentionPolicy); + } + else if (std::strcmp(node.Name, "StaticWebsite") == 0) + { + path.emplace_back(XmlTagName::k_StaticWebsite); + } + else + { + path.emplace_back(XmlTagName::k_Unknown); + } + if (path.size() == 2 && path[0] == XmlTagName::k_StorageServiceProperties + && path[1] == XmlTagName::k_Logging) + { + ret.Logging = BlobAnalyticsLoggingFromXml(reader); + path.pop_back(); + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_StorageServiceProperties + && path[1] == XmlTagName::k_HourMetrics) + { + ret.HourMetrics = BlobMetricsFromXml(reader); + path.pop_back(); + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_StorageServiceProperties + && path[1] == XmlTagName::k_MinuteMetrics) + { + ret.MinuteMetrics = BlobMetricsFromXml(reader); + path.pop_back(); + } + else if ( + path.size() == 3 && path[0] == XmlTagName::k_StorageServiceProperties + && path[1] == XmlTagName::k_Cors && path[2] == XmlTagName::k_CorsRule) + { + ret.Cors.emplace_back(BlobCorsRuleFromXml(reader)); + path.pop_back(); + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_StorageServiceProperties + && path[1] == XmlTagName::k_DeleteRetentionPolicy) + { + ret.DeleteRetentionPolicy = BlobRetentionPolicyFromXml(reader); + path.pop_back(); + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_StorageServiceProperties + && path[1] == XmlTagName::k_StaticWebsite) + { + ret.StaticWebsite = BlobStaticWebsiteFromXml(reader); + path.pop_back(); + } } - else if (std::strcmp(node.Name, "HourMetrics") == 0) + else if (node.Type == XmlNodeType::Text) { - path.emplace_back(XmlTagName::k_HourMetrics); - } - else if (std::strcmp(node.Name, "MinuteMetrics") == 0) - { - path.emplace_back(XmlTagName::k_MinuteMetrics); - } - else if (std::strcmp(node.Name, "Cors") == 0) - { - path.emplace_back(XmlTagName::k_Cors); - } - else if (std::strcmp(node.Name, "CorsRule") == 0) - { - path.emplace_back(XmlTagName::k_CorsRule); - } - else if (std::strcmp(node.Name, "DefaultServiceVersion") == 0) - { - path.emplace_back(XmlTagName::k_DefaultServiceVersion); - } - else if (std::strcmp(node.Name, "DeleteRetentionPolicy") == 0) - { - path.emplace_back(XmlTagName::k_DeleteRetentionPolicy); - } - else if (std::strcmp(node.Name, "StaticWebsite") == 0) - { - path.emplace_back(XmlTagName::k_StaticWebsite); - } - else - { - path.emplace_back(XmlTagName::k_Unknown); - } - if (path.size() == 2 && path[0] == XmlTagName::k_StorageServiceProperties - && path[1] == XmlTagName::k_Logging) - { - ret.Logging = BlobAnalyticsLoggingFromXml(reader); - path.pop_back(); - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_StorageServiceProperties - && path[1] == XmlTagName::k_HourMetrics) - { - ret.HourMetrics = BlobMetricsFromXml(reader); - path.pop_back(); - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_StorageServiceProperties - && path[1] == XmlTagName::k_MinuteMetrics) - { - ret.MinuteMetrics = BlobMetricsFromXml(reader); - path.pop_back(); - } - else if ( - path.size() == 3 && path[0] == XmlTagName::k_StorageServiceProperties - && path[1] == XmlTagName::k_Cors && path[2] == XmlTagName::k_CorsRule) - { - ret.Cors.emplace_back(BlobCorsRuleFromXml(reader)); - path.pop_back(); - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_StorageServiceProperties - && path[1] == XmlTagName::k_DeleteRetentionPolicy) - { - ret.DeleteRetentionPolicy = BlobRetentionPolicyFromXml(reader); - path.pop_back(); - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_StorageServiceProperties - && path[1] == XmlTagName::k_StaticWebsite) - { - ret.StaticWebsite = BlobStaticWebsiteFromXml(reader); - path.pop_back(); - } - } - else if (node.Type == XmlNodeType::Text) - { - if (path.size() == 2 && path[0] == XmlTagName::k_StorageServiceProperties - && path[1] == XmlTagName::k_DefaultServiceVersion) - { - ret.DefaultServiceVersion = node.Value; + if (path.size() == 2 && path[0] == XmlTagName::k_StorageServiceProperties + && path[1] == XmlTagName::k_DefaultServiceVersion) + { + ret.DefaultServiceVersion = node.Value; + } } } + return ret; } - return ret; - } - static GetServiceStatisticsResult GetServiceStatisticsResultFromXml(XmlReader& reader) - { - GetServiceStatisticsResult ret; - enum class XmlTagName + static GetServiceStatisticsResult GetServiceStatisticsResultFromXml(XmlReader& reader) { - k_StorageServiceStats, - k_GeoReplication, - k_Unknown, - }; - std::vector path; - while (true) - { - auto node = reader.Read(); - if (node.Type == XmlNodeType::End) + GetServiceStatisticsResult ret; + enum class XmlTagName { - break; - } - else if (node.Type == XmlNodeType::EndTag) + k_StorageServiceStats, + k_GeoReplication, + k_Unknown, + }; + std::vector path; + while (true) { - if (path.size() > 0) - { - path.pop_back(); - } - else + auto node = reader.Read(); + if (node.Type == XmlNodeType::End) { break; } - } - else if (node.Type == XmlNodeType::StartTag) - { - if (std::strcmp(node.Name, "StorageServiceStats") == 0) + else if (node.Type == XmlNodeType::EndTag) { - path.emplace_back(XmlTagName::k_StorageServiceStats); + if (path.size() > 0) + { + path.pop_back(); + } + else + { + break; + } } - else if (std::strcmp(node.Name, "GeoReplication") == 0) + else if (node.Type == XmlNodeType::StartTag) { - path.emplace_back(XmlTagName::k_GeoReplication); + if (std::strcmp(node.Name, "StorageServiceStats") == 0) + { + path.emplace_back(XmlTagName::k_StorageServiceStats); + } + else if (std::strcmp(node.Name, "GeoReplication") == 0) + { + path.emplace_back(XmlTagName::k_GeoReplication); + } + else + { + path.emplace_back(XmlTagName::k_Unknown); + } + if (path.size() == 2 && path[0] == XmlTagName::k_StorageServiceStats + && path[1] == XmlTagName::k_GeoReplication) + { + ret.GeoReplication = BlobGeoReplicationFromXml(reader); + path.pop_back(); + } } - else + else if (node.Type == XmlNodeType::Text) { - path.emplace_back(XmlTagName::k_Unknown); - } - if (path.size() == 2 && path[0] == XmlTagName::k_StorageServiceStats - && path[1] == XmlTagName::k_GeoReplication) - { - ret.GeoReplication = BlobGeoReplicationFromXml(reader); - path.pop_back(); } } - else if (node.Type == XmlNodeType::Text) - { - } + return ret; } - return ret; - } - static GetUserDelegationKeyResult GetUserDelegationKeyResultFromXml(XmlReader& reader) - { - GetUserDelegationKeyResult ret; - enum class XmlTagName + static GetUserDelegationKeyResult GetUserDelegationKeyResultFromXml(XmlReader& reader) { - k_UserDelegationKey, - k_SignedOid, - k_SignedTid, - k_SignedStart, - k_SignedExpiry, - k_SignedService, - k_SignedVersion, - k_Value, - k_Unknown, - }; - std::vector path; - while (true) - { - auto node = reader.Read(); - if (node.Type == XmlNodeType::End) + GetUserDelegationKeyResult ret; + enum class XmlTagName { - break; - } - else if (node.Type == XmlNodeType::EndTag) + k_UserDelegationKey, + k_SignedOid, + k_SignedTid, + k_SignedStart, + k_SignedExpiry, + k_SignedService, + k_SignedVersion, + k_Value, + k_Unknown, + }; + std::vector path; + while (true) { - if (path.size() > 0) - { - path.pop_back(); - } - else + auto node = reader.Read(); + if (node.Type == XmlNodeType::End) { break; } - } - else if (node.Type == XmlNodeType::StartTag) - { - if (std::strcmp(node.Name, "UserDelegationKey") == 0) + else if (node.Type == XmlNodeType::EndTag) { - path.emplace_back(XmlTagName::k_UserDelegationKey); + if (path.size() > 0) + { + path.pop_back(); + } + else + { + break; + } } - else if (std::strcmp(node.Name, "SignedOid") == 0) + else if (node.Type == XmlNodeType::StartTag) { - path.emplace_back(XmlTagName::k_SignedOid); + if (std::strcmp(node.Name, "UserDelegationKey") == 0) + { + path.emplace_back(XmlTagName::k_UserDelegationKey); + } + else if (std::strcmp(node.Name, "SignedOid") == 0) + { + path.emplace_back(XmlTagName::k_SignedOid); + } + else if (std::strcmp(node.Name, "SignedTid") == 0) + { + path.emplace_back(XmlTagName::k_SignedTid); + } + else if (std::strcmp(node.Name, "SignedStart") == 0) + { + path.emplace_back(XmlTagName::k_SignedStart); + } + else if (std::strcmp(node.Name, "SignedExpiry") == 0) + { + path.emplace_back(XmlTagName::k_SignedExpiry); + } + else if (std::strcmp(node.Name, "SignedService") == 0) + { + path.emplace_back(XmlTagName::k_SignedService); + } + else if (std::strcmp(node.Name, "SignedVersion") == 0) + { + path.emplace_back(XmlTagName::k_SignedVersion); + } + else if (std::strcmp(node.Name, "Value") == 0) + { + path.emplace_back(XmlTagName::k_Value); + } + else + { + path.emplace_back(XmlTagName::k_Unknown); + } } - else if (std::strcmp(node.Name, "SignedTid") == 0) + else if (node.Type == XmlNodeType::Text) { - path.emplace_back(XmlTagName::k_SignedTid); - } - else if (std::strcmp(node.Name, "SignedStart") == 0) - { - path.emplace_back(XmlTagName::k_SignedStart); - } - else if (std::strcmp(node.Name, "SignedExpiry") == 0) - { - path.emplace_back(XmlTagName::k_SignedExpiry); - } - else if (std::strcmp(node.Name, "SignedService") == 0) - { - path.emplace_back(XmlTagName::k_SignedService); - } - else if (std::strcmp(node.Name, "SignedVersion") == 0) - { - path.emplace_back(XmlTagName::k_SignedVersion); - } - else if (std::strcmp(node.Name, "Value") == 0) - { - path.emplace_back(XmlTagName::k_Value); - } - else - { - path.emplace_back(XmlTagName::k_Unknown); - } - } - else if (node.Type == XmlNodeType::Text) - { - if (path.size() == 2 && path[0] == XmlTagName::k_UserDelegationKey - && path[1] == XmlTagName::k_SignedOid) - { - ret.SignedObjectId = node.Value; - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_UserDelegationKey - && path[1] == XmlTagName::k_SignedTid) - { - ret.SignedTenantId = node.Value; - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_UserDelegationKey - && path[1] == XmlTagName::k_SignedStart) - { - ret.SignedStartsOn = node.Value; - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_UserDelegationKey - && path[1] == XmlTagName::k_SignedExpiry) - { - ret.SignedExpiresOn = node.Value; - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_UserDelegationKey - && path[1] == XmlTagName::k_SignedService) - { - ret.SignedService = node.Value; - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_UserDelegationKey - && path[1] == XmlTagName::k_SignedVersion) - { - ret.SignedVersion = node.Value; - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_UserDelegationKey - && path[1] == XmlTagName::k_Value) - { - ret.Value = node.Value; + if (path.size() == 2 && path[0] == XmlTagName::k_UserDelegationKey + && path[1] == XmlTagName::k_SignedOid) + { + ret.SignedObjectId = node.Value; + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_UserDelegationKey + && path[1] == XmlTagName::k_SignedTid) + { + ret.SignedTenantId = node.Value; + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_UserDelegationKey + && path[1] == XmlTagName::k_SignedStart) + { + ret.SignedStartsOn = node.Value; + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_UserDelegationKey + && path[1] == XmlTagName::k_SignedExpiry) + { + ret.SignedExpiresOn = node.Value; + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_UserDelegationKey + && path[1] == XmlTagName::k_SignedService) + { + ret.SignedService = node.Value; + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_UserDelegationKey + && path[1] == XmlTagName::k_SignedVersion) + { + ret.SignedVersion = node.Value; + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_UserDelegationKey + && path[1] == XmlTagName::k_Value) + { + ret.Value = node.Value; + } } } + return ret; } - return ret; - } - static ListContainersSegmentResult ListContainersSegmentResultFromXml(XmlReader& reader) - { - ListContainersSegmentResult ret; - enum class XmlTagName + static ListContainersSegmentResult ListContainersSegmentResultFromXml(XmlReader& reader) { - k_EnumerationResults, - k_Prefix, - k_Marker, - k_NextMarker, - k_Containers, - k_Container, - k_Unknown, - }; - std::vector path; - while (true) - { - auto node = reader.Read(); - if (node.Type == XmlNodeType::End) + ListContainersSegmentResult ret; + enum class XmlTagName { - break; - } - else if (node.Type == XmlNodeType::EndTag) + k_EnumerationResults, + k_Prefix, + k_Marker, + k_NextMarker, + k_Containers, + k_Container, + k_Unknown, + }; + std::vector path; + while (true) { - if (path.size() > 0) - { - path.pop_back(); - } - else + auto node = reader.Read(); + if (node.Type == XmlNodeType::End) { break; } - } - else if (node.Type == XmlNodeType::StartTag) - { - if (std::strcmp(node.Name, "EnumerationResults") == 0) + else if (node.Type == XmlNodeType::EndTag) { - path.emplace_back(XmlTagName::k_EnumerationResults); + if (path.size() > 0) + { + path.pop_back(); + } + else + { + break; + } } - else if (std::strcmp(node.Name, "Prefix") == 0) + else if (node.Type == XmlNodeType::StartTag) { - path.emplace_back(XmlTagName::k_Prefix); + if (std::strcmp(node.Name, "EnumerationResults") == 0) + { + path.emplace_back(XmlTagName::k_EnumerationResults); + } + else if (std::strcmp(node.Name, "Prefix") == 0) + { + path.emplace_back(XmlTagName::k_Prefix); + } + else if (std::strcmp(node.Name, "Marker") == 0) + { + path.emplace_back(XmlTagName::k_Marker); + } + else if (std::strcmp(node.Name, "NextMarker") == 0) + { + path.emplace_back(XmlTagName::k_NextMarker); + } + else if (std::strcmp(node.Name, "Containers") == 0) + { + path.emplace_back(XmlTagName::k_Containers); + } + else if (std::strcmp(node.Name, "Container") == 0) + { + path.emplace_back(XmlTagName::k_Container); + } + else + { + path.emplace_back(XmlTagName::k_Unknown); + } + if (path.size() == 3 && path[0] == XmlTagName::k_EnumerationResults + && path[1] == XmlTagName::k_Containers && path[2] == XmlTagName::k_Container) + { + ret.Items.emplace_back(BlobContainerItemFromXml(reader)); + path.pop_back(); + } } - else if (std::strcmp(node.Name, "Marker") == 0) + else if (node.Type == XmlNodeType::Text) { - path.emplace_back(XmlTagName::k_Marker); + if (path.size() == 2 && path[0] == XmlTagName::k_EnumerationResults + && path[1] == XmlTagName::k_Prefix) + { + ret.Prefix = node.Value; + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_EnumerationResults + && path[1] == XmlTagName::k_Marker) + { + ret.PreviousContinuationToken = node.Value; + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_EnumerationResults + && path[1] == XmlTagName::k_NextMarker) + { + ret.ContinuationToken = node.Value; + } } - else if (std::strcmp(node.Name, "NextMarker") == 0) + else if (node.Type == XmlNodeType::Attribute) { - path.emplace_back(XmlTagName::k_NextMarker); - } - else if (std::strcmp(node.Name, "Containers") == 0) - { - path.emplace_back(XmlTagName::k_Containers); - } - else if (std::strcmp(node.Name, "Container") == 0) - { - path.emplace_back(XmlTagName::k_Container); - } - else - { - path.emplace_back(XmlTagName::k_Unknown); - } - if (path.size() == 3 && path[0] == XmlTagName::k_EnumerationResults - && path[1] == XmlTagName::k_Containers && path[2] == XmlTagName::k_Container) - { - ret.Items.emplace_back(BlobContainerItemFromXml(reader)); - path.pop_back(); - } - } - else if (node.Type == XmlNodeType::Text) - { - if (path.size() == 2 && path[0] == XmlTagName::k_EnumerationResults - && path[1] == XmlTagName::k_Prefix) - { - ret.Prefix = node.Value; - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_EnumerationResults - && path[1] == XmlTagName::k_Marker) - { - ret.PreviousContinuationToken = node.Value; - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_EnumerationResults - && path[1] == XmlTagName::k_NextMarker) - { - ret.ContinuationToken = node.Value; - } - } - else if (node.Type == XmlNodeType::Attribute) - { - if (path.size() == 1 && path[0] == XmlTagName::k_EnumerationResults - && std::strcmp(node.Name, "ServiceEndpoint") == 0) - { - ret.ServiceEndpoint = node.Value; + if (path.size() == 1 && path[0] == XmlTagName::k_EnumerationResults + && std::strcmp(node.Name, "ServiceEndpoint") == 0) + { + ret.ServiceEndpoint = node.Value; + } } } + return ret; } - return ret; - } - static BlobAnalyticsLogging BlobAnalyticsLoggingFromXml(XmlReader& reader) - { - BlobAnalyticsLogging ret; - enum class XmlTagName + static BlobAnalyticsLogging BlobAnalyticsLoggingFromXml(XmlReader& reader) { - k_Version, - k_Delete, - k_Read, - k_Write, - k_RetentionPolicy, - k_Unknown, - }; - std::vector path; - while (true) - { - auto node = reader.Read(); - if (node.Type == XmlNodeType::End) + BlobAnalyticsLogging ret; + enum class XmlTagName { - break; - } - else if (node.Type == XmlNodeType::EndTag) + k_Version, + k_Delete, + k_Read, + k_Write, + k_RetentionPolicy, + k_Unknown, + }; + std::vector path; + while (true) { - if (path.size() > 0) - { - path.pop_back(); - } - else + auto node = reader.Read(); + if (node.Type == XmlNodeType::End) { break; } - } - else if (node.Type == XmlNodeType::StartTag) - { - if (std::strcmp(node.Name, "Version") == 0) + else if (node.Type == XmlNodeType::EndTag) { - path.emplace_back(XmlTagName::k_Version); + if (path.size() > 0) + { + path.pop_back(); + } + else + { + break; + } } - else if (std::strcmp(node.Name, "Delete") == 0) + else if (node.Type == XmlNodeType::StartTag) { - path.emplace_back(XmlTagName::k_Delete); + if (std::strcmp(node.Name, "Version") == 0) + { + path.emplace_back(XmlTagName::k_Version); + } + else if (std::strcmp(node.Name, "Delete") == 0) + { + path.emplace_back(XmlTagName::k_Delete); + } + else if (std::strcmp(node.Name, "Read") == 0) + { + path.emplace_back(XmlTagName::k_Read); + } + else if (std::strcmp(node.Name, "Write") == 0) + { + path.emplace_back(XmlTagName::k_Write); + } + else if (std::strcmp(node.Name, "RetentionPolicy") == 0) + { + path.emplace_back(XmlTagName::k_RetentionPolicy); + } + else + { + path.emplace_back(XmlTagName::k_Unknown); + } + if (path.size() == 1 && path[0] == XmlTagName::k_RetentionPolicy) + { + ret.RetentionPolicy = BlobRetentionPolicyFromXml(reader); + path.pop_back(); + } } - else if (std::strcmp(node.Name, "Read") == 0) + else if (node.Type == XmlNodeType::Text) { - path.emplace_back(XmlTagName::k_Read); - } - else if (std::strcmp(node.Name, "Write") == 0) - { - path.emplace_back(XmlTagName::k_Write); - } - else if (std::strcmp(node.Name, "RetentionPolicy") == 0) - { - path.emplace_back(XmlTagName::k_RetentionPolicy); - } - else - { - path.emplace_back(XmlTagName::k_Unknown); - } - if (path.size() == 1 && path[0] == XmlTagName::k_RetentionPolicy) - { - ret.RetentionPolicy = BlobRetentionPolicyFromXml(reader); - path.pop_back(); - } - } - else if (node.Type == XmlNodeType::Text) - { - if (path.size() == 1 && path[0] == XmlTagName::k_Version) - { - ret.Version = node.Value; - } - else if (path.size() == 1 && path[0] == XmlTagName::k_Delete) - { - ret.Delete = std::strcmp(node.Value, "true") == 0; - } - else if (path.size() == 1 && path[0] == XmlTagName::k_Read) - { - ret.Read = std::strcmp(node.Value, "true") == 0; - } - else if (path.size() == 1 && path[0] == XmlTagName::k_Write) - { - ret.Write = std::strcmp(node.Value, "true") == 0; + if (path.size() == 1 && path[0] == XmlTagName::k_Version) + { + ret.Version = node.Value; + } + else if (path.size() == 1 && path[0] == XmlTagName::k_Delete) + { + ret.Delete = std::strcmp(node.Value, "true") == 0; + } + else if (path.size() == 1 && path[0] == XmlTagName::k_Read) + { + ret.Read = std::strcmp(node.Value, "true") == 0; + } + else if (path.size() == 1 && path[0] == XmlTagName::k_Write) + { + ret.Write = std::strcmp(node.Value, "true") == 0; + } } } + return ret; } - return ret; - } - static BlobContainerItem BlobContainerItemFromXml(XmlReader& reader) - { - BlobContainerItem ret; - enum class XmlTagName + static BlobContainerItem BlobContainerItemFromXml(XmlReader& reader) { - k_Name, - k_Properties, - k_Etag, - k_LastModified, - k_PublicAccess, - k_HasImmutabilityPolicy, - k_HasLegalHold, - k_LeaseStatus, - k_LeaseState, - k_LeaseDuration, - k_DefaultEncryptionScope, - k_DenyEncryptionScopeOverride, - k_Metadata, - k_Deleted, - k_Version, - k_DeletedTime, - k_RemainingRetentionDays, - k_Unknown, - }; - std::vector path; - while (true) - { - auto node = reader.Read(); - if (node.Type == XmlNodeType::End) + BlobContainerItem ret; + enum class XmlTagName { - break; - } - else if (node.Type == XmlNodeType::EndTag) + k_Name, + k_Properties, + k_Etag, + k_LastModified, + k_PublicAccess, + k_HasImmutabilityPolicy, + k_HasLegalHold, + k_LeaseStatus, + k_LeaseState, + k_LeaseDuration, + k_DefaultEncryptionScope, + k_DenyEncryptionScopeOverride, + k_Metadata, + k_Deleted, + k_Version, + k_DeletedTime, + k_RemainingRetentionDays, + k_Unknown, + }; + std::vector path; + while (true) { - if (path.size() > 0) - { - path.pop_back(); - } - else + auto node = reader.Read(); + if (node.Type == XmlNodeType::End) { break; } - } - else if (node.Type == XmlNodeType::StartTag) - { - if (std::strcmp(node.Name, "Name") == 0) + else if (node.Type == XmlNodeType::EndTag) { - path.emplace_back(XmlTagName::k_Name); + if (path.size() > 0) + { + path.pop_back(); + } + else + { + break; + } } - else if (std::strcmp(node.Name, "Properties") == 0) + else if (node.Type == XmlNodeType::StartTag) { - path.emplace_back(XmlTagName::k_Properties); + if (std::strcmp(node.Name, "Name") == 0) + { + path.emplace_back(XmlTagName::k_Name); + } + else if (std::strcmp(node.Name, "Properties") == 0) + { + path.emplace_back(XmlTagName::k_Properties); + } + else if (std::strcmp(node.Name, "Etag") == 0) + { + path.emplace_back(XmlTagName::k_Etag); + } + else if (std::strcmp(node.Name, "Last-Modified") == 0) + { + path.emplace_back(XmlTagName::k_LastModified); + } + else if (std::strcmp(node.Name, "PublicAccess") == 0) + { + path.emplace_back(XmlTagName::k_PublicAccess); + } + else if (std::strcmp(node.Name, "HasImmutabilityPolicy") == 0) + { + path.emplace_back(XmlTagName::k_HasImmutabilityPolicy); + } + else if (std::strcmp(node.Name, "HasLegalHold") == 0) + { + path.emplace_back(XmlTagName::k_HasLegalHold); + } + else if (std::strcmp(node.Name, "LeaseStatus") == 0) + { + path.emplace_back(XmlTagName::k_LeaseStatus); + } + else if (std::strcmp(node.Name, "LeaseState") == 0) + { + path.emplace_back(XmlTagName::k_LeaseState); + } + else if (std::strcmp(node.Name, "LeaseDuration") == 0) + { + path.emplace_back(XmlTagName::k_LeaseDuration); + } + else if (std::strcmp(node.Name, "DefaultEncryptionScope") == 0) + { + path.emplace_back(XmlTagName::k_DefaultEncryptionScope); + } + else if (std::strcmp(node.Name, "DenyEncryptionScopeOverride") == 0) + { + path.emplace_back(XmlTagName::k_DenyEncryptionScopeOverride); + } + else if (std::strcmp(node.Name, "Metadata") == 0) + { + path.emplace_back(XmlTagName::k_Metadata); + } + else if (std::strcmp(node.Name, "Deleted") == 0) + { + path.emplace_back(XmlTagName::k_Deleted); + } + else if (std::strcmp(node.Name, "Version") == 0) + { + path.emplace_back(XmlTagName::k_Version); + } + else if (std::strcmp(node.Name, "DeletedTime") == 0) + { + path.emplace_back(XmlTagName::k_DeletedTime); + } + else if (std::strcmp(node.Name, "RemainingRetentionDays") == 0) + { + path.emplace_back(XmlTagName::k_RemainingRetentionDays); + } + else + { + path.emplace_back(XmlTagName::k_Unknown); + } + if (path.size() == 1 && path[0] == XmlTagName::k_Metadata) + { + ret.Metadata = MetadataFromXml(reader); + path.pop_back(); + } } - else if (std::strcmp(node.Name, "Etag") == 0) + else if (node.Type == XmlNodeType::Text) { - path.emplace_back(XmlTagName::k_Etag); - } - else if (std::strcmp(node.Name, "Last-Modified") == 0) - { - path.emplace_back(XmlTagName::k_LastModified); - } - else if (std::strcmp(node.Name, "PublicAccess") == 0) - { - path.emplace_back(XmlTagName::k_PublicAccess); - } - else if (std::strcmp(node.Name, "HasImmutabilityPolicy") == 0) - { - path.emplace_back(XmlTagName::k_HasImmutabilityPolicy); - } - else if (std::strcmp(node.Name, "HasLegalHold") == 0) - { - path.emplace_back(XmlTagName::k_HasLegalHold); - } - else if (std::strcmp(node.Name, "LeaseStatus") == 0) - { - path.emplace_back(XmlTagName::k_LeaseStatus); - } - else if (std::strcmp(node.Name, "LeaseState") == 0) - { - path.emplace_back(XmlTagName::k_LeaseState); - } - else if (std::strcmp(node.Name, "LeaseDuration") == 0) - { - path.emplace_back(XmlTagName::k_LeaseDuration); - } - else if (std::strcmp(node.Name, "DefaultEncryptionScope") == 0) - { - path.emplace_back(XmlTagName::k_DefaultEncryptionScope); - } - else if (std::strcmp(node.Name, "DenyEncryptionScopeOverride") == 0) - { - path.emplace_back(XmlTagName::k_DenyEncryptionScopeOverride); - } - else if (std::strcmp(node.Name, "Metadata") == 0) - { - path.emplace_back(XmlTagName::k_Metadata); - } - else if (std::strcmp(node.Name, "Deleted") == 0) - { - path.emplace_back(XmlTagName::k_Deleted); - } - else if (std::strcmp(node.Name, "Version") == 0) - { - path.emplace_back(XmlTagName::k_Version); - } - else if (std::strcmp(node.Name, "DeletedTime") == 0) - { - path.emplace_back(XmlTagName::k_DeletedTime); - } - else if (std::strcmp(node.Name, "RemainingRetentionDays") == 0) - { - path.emplace_back(XmlTagName::k_RemainingRetentionDays); - } - else - { - path.emplace_back(XmlTagName::k_Unknown); - } - if (path.size() == 1 && path[0] == XmlTagName::k_Metadata) - { - ret.Metadata = MetadataFromXml(reader); - path.pop_back(); - } - } - else if (node.Type == XmlNodeType::Text) - { - if (path.size() == 1 && path[0] == XmlTagName::k_Name) - { - ret.Name = node.Value; - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_Properties - && path[1] == XmlTagName::k_Etag) - { - ret.ETag = node.Value; - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_Properties - && path[1] == XmlTagName::k_LastModified) - { - ret.LastModified = node.Value; - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_Properties - && path[1] == XmlTagName::k_PublicAccess) - { - ret.AccessType = PublicAccessTypeFromString(node.Value); - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_Properties - && path[1] == XmlTagName::k_HasImmutabilityPolicy) - { - ret.HasImmutabilityPolicy = std::strcmp(node.Value, "true") == 0; - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_Properties - && path[1] == XmlTagName::k_HasLegalHold) - { - ret.HasLegalHold = std::strcmp(node.Value, "true") == 0; - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_Properties - && path[1] == XmlTagName::k_LeaseStatus) - { - ret.LeaseStatus = BlobLeaseStatusFromString(node.Value); - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_Properties - && path[1] == XmlTagName::k_LeaseState) - { - ret.LeaseState = BlobLeaseStateFromString(node.Value); - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_Properties - && path[1] == XmlTagName::k_LeaseDuration) - { - ret.LeaseDuration = node.Value; - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_Properties - && path[1] == XmlTagName::k_DefaultEncryptionScope) - { - ret.DefaultEncryptionScope = node.Value; - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_Properties - && path[1] == XmlTagName::k_DenyEncryptionScopeOverride) - { - ret.PreventEncryptionScopeOverride = std::strcmp(node.Value, "true") == 0; - } - else if (path.size() == 1 && path[0] == XmlTagName::k_Deleted) - { - ret.IsDeleted = std::strcmp(node.Value, "true") == 0; - } - else if (path.size() == 1 && path[0] == XmlTagName::k_Version) - { - ret.VersionId = node.Value; - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_Properties - && path[1] == XmlTagName::k_DeletedTime) - { - ret.DeletedTime = node.Value; - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_Properties - && path[1] == XmlTagName::k_RemainingRetentionDays) - { - ret.RemainingRetentionDays = std::stoi(node.Value); + if (path.size() == 1 && path[0] == XmlTagName::k_Name) + { + ret.Name = node.Value; + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_Properties + && path[1] == XmlTagName::k_Etag) + { + ret.ETag = node.Value; + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_Properties + && path[1] == XmlTagName::k_LastModified) + { + ret.LastModified = node.Value; + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_Properties + && path[1] == XmlTagName::k_PublicAccess) + { + ret.AccessType = PublicAccessTypeFromString(node.Value); + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_Properties + && path[1] == XmlTagName::k_HasImmutabilityPolicy) + { + ret.HasImmutabilityPolicy = std::strcmp(node.Value, "true") == 0; + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_Properties + && path[1] == XmlTagName::k_HasLegalHold) + { + ret.HasLegalHold = std::strcmp(node.Value, "true") == 0; + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_Properties + && path[1] == XmlTagName::k_LeaseStatus) + { + ret.LeaseStatus = BlobLeaseStatusFromString(node.Value); + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_Properties + && path[1] == XmlTagName::k_LeaseState) + { + ret.LeaseState = BlobLeaseStateFromString(node.Value); + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_Properties + && path[1] == XmlTagName::k_LeaseDuration) + { + ret.LeaseDuration = node.Value; + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_Properties + && path[1] == XmlTagName::k_DefaultEncryptionScope) + { + ret.DefaultEncryptionScope = node.Value; + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_Properties + && path[1] == XmlTagName::k_DenyEncryptionScopeOverride) + { + ret.PreventEncryptionScopeOverride = std::strcmp(node.Value, "true") == 0; + } + else if (path.size() == 1 && path[0] == XmlTagName::k_Deleted) + { + ret.IsDeleted = std::strcmp(node.Value, "true") == 0; + } + else if (path.size() == 1 && path[0] == XmlTagName::k_Version) + { + ret.VersionId = node.Value; + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_Properties + && path[1] == XmlTagName::k_DeletedTime) + { + ret.DeletedTime = node.Value; + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_Properties + && path[1] == XmlTagName::k_RemainingRetentionDays) + { + ret.RemainingRetentionDays = std::stoi(node.Value); + } } } + return ret; } - return ret; - } - static BlobCorsRule BlobCorsRuleFromXml(XmlReader& reader) - { - BlobCorsRule ret; - enum class XmlTagName + static BlobCorsRule BlobCorsRuleFromXml(XmlReader& reader) { - k_AllowedOrigins, - k_AllowedMethods, - k_MaxAgeInSeconds, - k_ExposedHeaders, - k_AllowedHeaders, - k_Unknown, - }; - std::vector path; - while (true) - { - auto node = reader.Read(); - if (node.Type == XmlNodeType::End) + BlobCorsRule ret; + enum class XmlTagName { - break; - } - else if (node.Type == XmlNodeType::EndTag) + k_AllowedOrigins, + k_AllowedMethods, + k_MaxAgeInSeconds, + k_ExposedHeaders, + k_AllowedHeaders, + k_Unknown, + }; + std::vector path; + while (true) { - if (path.size() > 0) - { - path.pop_back(); - } - else + auto node = reader.Read(); + if (node.Type == XmlNodeType::End) { break; } - } - else if (node.Type == XmlNodeType::StartTag) - { - if (std::strcmp(node.Name, "AllowedOrigins") == 0) + else if (node.Type == XmlNodeType::EndTag) { - path.emplace_back(XmlTagName::k_AllowedOrigins); + if (path.size() > 0) + { + path.pop_back(); + } + else + { + break; + } } - else if (std::strcmp(node.Name, "AllowedMethods") == 0) + else if (node.Type == XmlNodeType::StartTag) { - path.emplace_back(XmlTagName::k_AllowedMethods); + if (std::strcmp(node.Name, "AllowedOrigins") == 0) + { + path.emplace_back(XmlTagName::k_AllowedOrigins); + } + else if (std::strcmp(node.Name, "AllowedMethods") == 0) + { + path.emplace_back(XmlTagName::k_AllowedMethods); + } + else if (std::strcmp(node.Name, "MaxAgeInSeconds") == 0) + { + path.emplace_back(XmlTagName::k_MaxAgeInSeconds); + } + else if (std::strcmp(node.Name, "ExposedHeaders") == 0) + { + path.emplace_back(XmlTagName::k_ExposedHeaders); + } + else if (std::strcmp(node.Name, "AllowedHeaders") == 0) + { + path.emplace_back(XmlTagName::k_AllowedHeaders); + } + else + { + path.emplace_back(XmlTagName::k_Unknown); + } } - else if (std::strcmp(node.Name, "MaxAgeInSeconds") == 0) + else if (node.Type == XmlNodeType::Text) { - path.emplace_back(XmlTagName::k_MaxAgeInSeconds); - } - else if (std::strcmp(node.Name, "ExposedHeaders") == 0) - { - path.emplace_back(XmlTagName::k_ExposedHeaders); - } - else if (std::strcmp(node.Name, "AllowedHeaders") == 0) - { - path.emplace_back(XmlTagName::k_AllowedHeaders); - } - else - { - path.emplace_back(XmlTagName::k_Unknown); - } - } - else if (node.Type == XmlNodeType::Text) - { - if (path.size() == 1 && path[0] == XmlTagName::k_AllowedOrigins) - { - ret.AllowedOrigins = node.Value; - } - else if (path.size() == 1 && path[0] == XmlTagName::k_AllowedMethods) - { - ret.AllowedMethods = node.Value; - } - else if (path.size() == 1 && path[0] == XmlTagName::k_MaxAgeInSeconds) - { - ret.MaxAgeInSeconds = std::stoi(node.Value); - } - else if (path.size() == 1 && path[0] == XmlTagName::k_ExposedHeaders) - { - ret.ExposedHeaders = node.Value; - } - else if (path.size() == 1 && path[0] == XmlTagName::k_AllowedHeaders) - { - ret.AllowedHeaders = node.Value; + if (path.size() == 1 && path[0] == XmlTagName::k_AllowedOrigins) + { + ret.AllowedOrigins = node.Value; + } + else if (path.size() == 1 && path[0] == XmlTagName::k_AllowedMethods) + { + ret.AllowedMethods = node.Value; + } + else if (path.size() == 1 && path[0] == XmlTagName::k_MaxAgeInSeconds) + { + ret.MaxAgeInSeconds = std::stoi(node.Value); + } + else if (path.size() == 1 && path[0] == XmlTagName::k_ExposedHeaders) + { + ret.ExposedHeaders = node.Value; + } + else if (path.size() == 1 && path[0] == XmlTagName::k_AllowedHeaders) + { + ret.AllowedHeaders = node.Value; + } } } + return ret; } - return ret; - } - static BlobGeoReplication BlobGeoReplicationFromXml(XmlReader& reader) - { - BlobGeoReplication ret; - enum class XmlTagName + static BlobGeoReplication BlobGeoReplicationFromXml(XmlReader& reader) { - k_Status, - k_LastSyncTime, - k_Unknown, - }; - std::vector path; - while (true) - { - auto node = reader.Read(); - if (node.Type == XmlNodeType::End) + BlobGeoReplication ret; + enum class XmlTagName { - break; - } - else if (node.Type == XmlNodeType::EndTag) + k_Status, + k_LastSyncTime, + k_Unknown, + }; + std::vector path; + while (true) { - if (path.size() > 0) - { - path.pop_back(); - } - else + auto node = reader.Read(); + if (node.Type == XmlNodeType::End) { break; } - } - else if (node.Type == XmlNodeType::StartTag) - { - if (std::strcmp(node.Name, "Status") == 0) + else if (node.Type == XmlNodeType::EndTag) { - path.emplace_back(XmlTagName::k_Status); + if (path.size() > 0) + { + path.pop_back(); + } + else + { + break; + } } - else if (std::strcmp(node.Name, "LastSyncTime") == 0) + else if (node.Type == XmlNodeType::StartTag) { - path.emplace_back(XmlTagName::k_LastSyncTime); + if (std::strcmp(node.Name, "Status") == 0) + { + path.emplace_back(XmlTagName::k_Status); + } + else if (std::strcmp(node.Name, "LastSyncTime") == 0) + { + path.emplace_back(XmlTagName::k_LastSyncTime); + } + else + { + path.emplace_back(XmlTagName::k_Unknown); + } } - else + else if (node.Type == XmlNodeType::Text) { - path.emplace_back(XmlTagName::k_Unknown); - } - } - else if (node.Type == XmlNodeType::Text) - { - if (path.size() == 1 && path[0] == XmlTagName::k_Status) - { - ret.Status = BlobGeoReplicationStatusFromString(node.Value); - } - else if (path.size() == 1 && path[0] == XmlTagName::k_LastSyncTime) - { - ret.LastSyncTime = node.Value; + if (path.size() == 1 && path[0] == XmlTagName::k_Status) + { + ret.Status = BlobGeoReplicationStatusFromString(node.Value); + } + else if (path.size() == 1 && path[0] == XmlTagName::k_LastSyncTime) + { + ret.LastSyncTime = node.Value; + } } } + return ret; } - return ret; - } - static BlobMetrics BlobMetricsFromXml(XmlReader& reader) - { - BlobMetrics ret; - enum class XmlTagName + static BlobMetrics BlobMetricsFromXml(XmlReader& reader) { - k_Version, - k_Enabled, - k_IncludeAPIs, - k_RetentionPolicy, - k_Unknown, - }; - std::vector path; - while (true) - { - auto node = reader.Read(); - if (node.Type == XmlNodeType::End) + BlobMetrics ret; + enum class XmlTagName { - break; - } - else if (node.Type == XmlNodeType::EndTag) + k_Version, + k_Enabled, + k_IncludeAPIs, + k_RetentionPolicy, + k_Unknown, + }; + std::vector path; + while (true) { - if (path.size() > 0) - { - path.pop_back(); - } - else + auto node = reader.Read(); + if (node.Type == XmlNodeType::End) { break; } - } - else if (node.Type == XmlNodeType::StartTag) - { - if (std::strcmp(node.Name, "Version") == 0) + else if (node.Type == XmlNodeType::EndTag) { - path.emplace_back(XmlTagName::k_Version); + if (path.size() > 0) + { + path.pop_back(); + } + else + { + break; + } } - else if (std::strcmp(node.Name, "Enabled") == 0) + else if (node.Type == XmlNodeType::StartTag) { - path.emplace_back(XmlTagName::k_Enabled); + if (std::strcmp(node.Name, "Version") == 0) + { + path.emplace_back(XmlTagName::k_Version); + } + else if (std::strcmp(node.Name, "Enabled") == 0) + { + path.emplace_back(XmlTagName::k_Enabled); + } + else if (std::strcmp(node.Name, "IncludeAPIs") == 0) + { + path.emplace_back(XmlTagName::k_IncludeAPIs); + } + else if (std::strcmp(node.Name, "RetentionPolicy") == 0) + { + path.emplace_back(XmlTagName::k_RetentionPolicy); + } + else + { + path.emplace_back(XmlTagName::k_Unknown); + } + if (path.size() == 1 && path[0] == XmlTagName::k_RetentionPolicy) + { + ret.RetentionPolicy = BlobRetentionPolicyFromXml(reader); + path.pop_back(); + } } - else if (std::strcmp(node.Name, "IncludeAPIs") == 0) + else if (node.Type == XmlNodeType::Text) { - path.emplace_back(XmlTagName::k_IncludeAPIs); - } - else if (std::strcmp(node.Name, "RetentionPolicy") == 0) - { - path.emplace_back(XmlTagName::k_RetentionPolicy); - } - else - { - path.emplace_back(XmlTagName::k_Unknown); - } - if (path.size() == 1 && path[0] == XmlTagName::k_RetentionPolicy) - { - ret.RetentionPolicy = BlobRetentionPolicyFromXml(reader); - path.pop_back(); - } - } - else if (node.Type == XmlNodeType::Text) - { - if (path.size() == 1 && path[0] == XmlTagName::k_Version) - { - ret.Version = node.Value; - } - else if (path.size() == 1 && path[0] == XmlTagName::k_Enabled) - { - ret.Enabled = std::strcmp(node.Value, "true") == 0; - } - else if (path.size() == 1 && path[0] == XmlTagName::k_IncludeAPIs) - { - ret.IncludeApis = std::strcmp(node.Value, "true") == 0; + if (path.size() == 1 && path[0] == XmlTagName::k_Version) + { + ret.Version = node.Value; + } + else if (path.size() == 1 && path[0] == XmlTagName::k_Enabled) + { + ret.Enabled = std::strcmp(node.Value, "true") == 0; + } + else if (path.size() == 1 && path[0] == XmlTagName::k_IncludeAPIs) + { + ret.IncludeApis = std::strcmp(node.Value, "true") == 0; + } } } + return ret; } - return ret; - } - static BlobRetentionPolicy BlobRetentionPolicyFromXml(XmlReader& reader) - { - BlobRetentionPolicy ret; - enum class XmlTagName + static BlobRetentionPolicy BlobRetentionPolicyFromXml(XmlReader& reader) { - k_Enabled, - k_Days, - k_Unknown, - }; - std::vector path; - while (true) - { - auto node = reader.Read(); - if (node.Type == XmlNodeType::End) + BlobRetentionPolicy ret; + enum class XmlTagName { - break; - } - else if (node.Type == XmlNodeType::EndTag) + k_Enabled, + k_Days, + k_Unknown, + }; + std::vector path; + while (true) { - if (path.size() > 0) - { - path.pop_back(); - } - else + auto node = reader.Read(); + if (node.Type == XmlNodeType::End) { break; } - } - else if (node.Type == XmlNodeType::StartTag) - { - if (std::strcmp(node.Name, "Enabled") == 0) + else if (node.Type == XmlNodeType::EndTag) { - path.emplace_back(XmlTagName::k_Enabled); + if (path.size() > 0) + { + path.pop_back(); + } + else + { + break; + } } - else if (std::strcmp(node.Name, "Days") == 0) + else if (node.Type == XmlNodeType::StartTag) { - path.emplace_back(XmlTagName::k_Days); + if (std::strcmp(node.Name, "Enabled") == 0) + { + path.emplace_back(XmlTagName::k_Enabled); + } + else if (std::strcmp(node.Name, "Days") == 0) + { + path.emplace_back(XmlTagName::k_Days); + } + else + { + path.emplace_back(XmlTagName::k_Unknown); + } } - else + else if (node.Type == XmlNodeType::Text) { - path.emplace_back(XmlTagName::k_Unknown); - } - } - else if (node.Type == XmlNodeType::Text) - { - if (path.size() == 1 && path[0] == XmlTagName::k_Enabled) - { - ret.Enabled = std::strcmp(node.Value, "true") == 0; - } - else if (path.size() == 1 && path[0] == XmlTagName::k_Days) - { - ret.Days = std::stoi(node.Value); + if (path.size() == 1 && path[0] == XmlTagName::k_Enabled) + { + ret.Enabled = std::strcmp(node.Value, "true") == 0; + } + else if (path.size() == 1 && path[0] == XmlTagName::k_Days) + { + ret.Days = std::stoi(node.Value); + } } } + return ret; } - return ret; - } - static BlobStaticWebsite BlobStaticWebsiteFromXml(XmlReader& reader) - { - BlobStaticWebsite ret; - enum class XmlTagName + static BlobStaticWebsite BlobStaticWebsiteFromXml(XmlReader& reader) { - k_Enabled, - k_IndexDocument, - k_DefaultIndexDocumentPath, - k_ErrorDocument404Path, - k_Unknown, - }; - std::vector path; - while (true) - { - auto node = reader.Read(); - if (node.Type == XmlNodeType::End) + BlobStaticWebsite ret; + enum class XmlTagName { - break; - } - else if (node.Type == XmlNodeType::EndTag) + k_Enabled, + k_IndexDocument, + k_DefaultIndexDocumentPath, + k_ErrorDocument404Path, + k_Unknown, + }; + std::vector path; + while (true) { - if (path.size() > 0) - { - path.pop_back(); - } - else + auto node = reader.Read(); + if (node.Type == XmlNodeType::End) { break; } - } - else if (node.Type == XmlNodeType::StartTag) - { - if (std::strcmp(node.Name, "Enabled") == 0) + else if (node.Type == XmlNodeType::EndTag) { - path.emplace_back(XmlTagName::k_Enabled); + if (path.size() > 0) + { + path.pop_back(); + } + else + { + break; + } } - else if (std::strcmp(node.Name, "IndexDocument") == 0) + else if (node.Type == XmlNodeType::StartTag) { - path.emplace_back(XmlTagName::k_IndexDocument); + if (std::strcmp(node.Name, "Enabled") == 0) + { + path.emplace_back(XmlTagName::k_Enabled); + } + else if (std::strcmp(node.Name, "IndexDocument") == 0) + { + path.emplace_back(XmlTagName::k_IndexDocument); + } + else if (std::strcmp(node.Name, "DefaultIndexDocumentPath") == 0) + { + path.emplace_back(XmlTagName::k_DefaultIndexDocumentPath); + } + else if (std::strcmp(node.Name, "ErrorDocument404Path") == 0) + { + path.emplace_back(XmlTagName::k_ErrorDocument404Path); + } + else + { + path.emplace_back(XmlTagName::k_Unknown); + } } - else if (std::strcmp(node.Name, "DefaultIndexDocumentPath") == 0) + else if (node.Type == XmlNodeType::Text) { - path.emplace_back(XmlTagName::k_DefaultIndexDocumentPath); - } - else if (std::strcmp(node.Name, "ErrorDocument404Path") == 0) - { - path.emplace_back(XmlTagName::k_ErrorDocument404Path); - } - else - { - path.emplace_back(XmlTagName::k_Unknown); - } - } - else if (node.Type == XmlNodeType::Text) - { - if (path.size() == 1 && path[0] == XmlTagName::k_Enabled) - { - ret.Enabled = std::strcmp(node.Value, "true") == 0; - } - else if (path.size() == 1 && path[0] == XmlTagName::k_IndexDocument) - { - ret.IndexDocument = node.Value; - } - else if (path.size() == 1 && path[0] == XmlTagName::k_DefaultIndexDocumentPath) - { - ret.DefaultIndexDocumentPath = node.Value; - } - else if (path.size() == 1 && path[0] == XmlTagName::k_ErrorDocument404Path) - { - ret.ErrorDocument404Path = node.Value; + if (path.size() == 1 && path[0] == XmlTagName::k_Enabled) + { + ret.Enabled = std::strcmp(node.Value, "true") == 0; + } + else if (path.size() == 1 && path[0] == XmlTagName::k_IndexDocument) + { + ret.IndexDocument = node.Value; + } + else if (path.size() == 1 && path[0] == XmlTagName::k_DefaultIndexDocumentPath) + { + ret.DefaultIndexDocumentPath = node.Value; + } + else if (path.size() == 1 && path[0] == XmlTagName::k_ErrorDocument404Path) + { + ret.ErrorDocument404Path = node.Value; + } } } + return ret; } - return ret; - } - static FilterBlobItem FilterBlobItemFromXml(XmlReader& reader) - { - FilterBlobItem ret; - enum class XmlTagName + static FilterBlobItem FilterBlobItemFromXml(XmlReader& reader) { - k_Name, - k_ContainerName, - k_TagValue, - k_Unknown, - }; - std::vector path; - while (true) - { - auto node = reader.Read(); - if (node.Type == XmlNodeType::End) + FilterBlobItem ret; + enum class XmlTagName { - break; - } - else if (node.Type == XmlNodeType::EndTag) + k_Name, + k_ContainerName, + k_TagValue, + k_Unknown, + }; + std::vector path; + while (true) { - if (path.size() > 0) - { - path.pop_back(); - } - else + auto node = reader.Read(); + if (node.Type == XmlNodeType::End) { break; } - } - else if (node.Type == XmlNodeType::StartTag) - { - if (std::strcmp(node.Name, "Name") == 0) + else if (node.Type == XmlNodeType::EndTag) { - path.emplace_back(XmlTagName::k_Name); + if (path.size() > 0) + { + path.pop_back(); + } + else + { + break; + } } - else if (std::strcmp(node.Name, "ContainerName") == 0) + else if (node.Type == XmlNodeType::StartTag) { - path.emplace_back(XmlTagName::k_ContainerName); + if (std::strcmp(node.Name, "Name") == 0) + { + path.emplace_back(XmlTagName::k_Name); + } + else if (std::strcmp(node.Name, "ContainerName") == 0) + { + path.emplace_back(XmlTagName::k_ContainerName); + } + else if (std::strcmp(node.Name, "TagValue") == 0) + { + path.emplace_back(XmlTagName::k_TagValue); + } + else + { + path.emplace_back(XmlTagName::k_Unknown); + } } - else if (std::strcmp(node.Name, "TagValue") == 0) + else if (node.Type == XmlNodeType::Text) { - path.emplace_back(XmlTagName::k_TagValue); - } - else - { - path.emplace_back(XmlTagName::k_Unknown); - } - } - else if (node.Type == XmlNodeType::Text) - { - if (path.size() == 1 && path[0] == XmlTagName::k_Name) - { - ret.BlobName = node.Value; - } - else if (path.size() == 1 && path[0] == XmlTagName::k_ContainerName) - { - ret.ContainerName = node.Value; - } - else if (path.size() == 1 && path[0] == XmlTagName::k_TagValue) - { - ret.TagValue = node.Value; + if (path.size() == 1 && path[0] == XmlTagName::k_Name) + { + ret.BlobName = node.Value; + } + else if (path.size() == 1 && path[0] == XmlTagName::k_ContainerName) + { + ret.ContainerName = node.Value; + } + else if (path.size() == 1 && path[0] == XmlTagName::k_TagValue) + { + ret.TagValue = node.Value; + } } } + return ret; } - return ret; - } - static std::map MetadataFromXml(XmlReader& reader) - { - std::map ret; - int depth = 0; - std::string key; - while (true) + static std::map MetadataFromXml(XmlReader& reader) { - auto node = reader.Read(); - if (node.Type == XmlNodeType::End) + std::map ret; + int depth = 0; + std::string key; + while (true) { - break; - } - else if (node.Type == XmlNodeType::StartTag) - { - if (depth++ == 0) - { - key = node.Name; - } - } - else if (node.Type == XmlNodeType::EndTag) - { - if (depth-- == 0) + auto node = reader.Read(); + if (node.Type == XmlNodeType::End) { break; } + else if (node.Type == XmlNodeType::StartTag) + { + if (depth++ == 0) + { + key = node.Name; + } + } + else if (node.Type == XmlNodeType::EndTag) + { + if (depth-- == 0) + { + break; + } + } + else if (depth == 1 && node.Type == XmlNodeType::Text) + { + ret.emplace(std::move(key), std::string(node.Value)); + } } - else if (depth == 1 && node.Type == XmlNodeType::Text) - { - ret.emplace(std::move(key), std::string(node.Value)); - } + return ret; } - return ret; - } - static void GetUserDelegationKeyOptionsToXml( - XmlWriter& writer, - const GetUserDelegationKeyOptions& options) - { - writer.Write(XmlNode{XmlNodeType::StartTag, "KeyInfo"}); - writer.Write(XmlNode{XmlNodeType::StartTag, "Start"}); - writer.Write(XmlNode{XmlNodeType::Text, nullptr, options.StartsOn.data()}); - writer.Write(XmlNode{XmlNodeType::EndTag}); - writer.Write(XmlNode{XmlNodeType::StartTag, "Expiry"}); - writer.Write(XmlNode{XmlNodeType::Text, nullptr, options.ExpiresOn.data()}); - writer.Write(XmlNode{XmlNodeType::EndTag}); - writer.Write(XmlNode{XmlNodeType::EndTag}); - } - - static void SetServicePropertiesOptionsToXml( - XmlWriter& writer, - const SetServicePropertiesOptions& options) - { - writer.Write(XmlNode{XmlNodeType::StartTag, "StorageServiceProperties"}); - BlobServicePropertiesToXml(writer, options.Properties); - writer.Write(XmlNode{XmlNodeType::EndTag}); - } - - static void BlobServicePropertiesToXml( - XmlWriter& writer, - const BlobServiceProperties& options) - { - writer.Write(XmlNode{XmlNodeType::StartTag, "Logging"}); - BlobAnalyticsLoggingToXml(writer, options.Logging); - writer.Write(XmlNode{XmlNodeType::EndTag}); - writer.Write(XmlNode{XmlNodeType::StartTag, "HourMetrics"}); - BlobMetricsToXml(writer, options.HourMetrics); - writer.Write(XmlNode{XmlNodeType::EndTag}); - writer.Write(XmlNode{XmlNodeType::StartTag, "MinuteMetrics"}); - BlobMetricsToXml(writer, options.MinuteMetrics); - writer.Write(XmlNode{XmlNodeType::EndTag}); - writer.Write(XmlNode{XmlNodeType::StartTag, "Cors"}); - for (const auto& i : options.Cors) + static void GetUserDelegationKeyOptionsToXml( + XmlWriter& writer, + const GetUserDelegationKeyOptions& options) { - BlobCorsRuleToXml(writer, i); - } - writer.Write(XmlNode{XmlNodeType::EndTag}); - writer.Write(XmlNode{XmlNodeType::StartTag, "DefaultServiceVersion"}); - writer.Write(XmlNode{XmlNodeType::Text, nullptr, options.DefaultServiceVersion.data()}); - writer.Write(XmlNode{XmlNodeType::EndTag}); - writer.Write(XmlNode{XmlNodeType::StartTag, "DeleteRetentionPolicy"}); - BlobRetentionPolicyToXml(writer, options.DeleteRetentionPolicy); - writer.Write(XmlNode{XmlNodeType::EndTag}); - writer.Write(XmlNode{XmlNodeType::StartTag, "StaticWebsite"}); - BlobStaticWebsiteToXml(writer, options.StaticWebsite); - writer.Write(XmlNode{XmlNodeType::EndTag}); - } - - static void BlobAnalyticsLoggingToXml(XmlWriter& writer, const BlobAnalyticsLogging& options) - { - writer.Write(XmlNode{XmlNodeType::StartTag, "Version"}); - writer.Write(XmlNode{XmlNodeType::Text, nullptr, options.Version.data()}); - writer.Write(XmlNode{XmlNodeType::EndTag}); - writer.Write(XmlNode{XmlNodeType::StartTag, "Delete"}); - writer.Write(XmlNode{XmlNodeType::Text, nullptr, options.Delete ? "true" : "false"}); - writer.Write(XmlNode{XmlNodeType::EndTag}); - writer.Write(XmlNode{XmlNodeType::StartTag, "Read"}); - writer.Write(XmlNode{XmlNodeType::Text, nullptr, options.Read ? "true" : "false"}); - writer.Write(XmlNode{XmlNodeType::EndTag}); - writer.Write(XmlNode{XmlNodeType::StartTag, "Write"}); - writer.Write(XmlNode{XmlNodeType::Text, nullptr, options.Write ? "true" : "false"}); - writer.Write(XmlNode{XmlNodeType::EndTag}); - writer.Write(XmlNode{XmlNodeType::StartTag, "RetentionPolicy"}); - BlobRetentionPolicyToXml(writer, options.RetentionPolicy); - writer.Write(XmlNode{XmlNodeType::EndTag}); - } - - static void BlobCorsRuleToXml(XmlWriter& writer, const BlobCorsRule& options) - { - writer.Write(XmlNode{XmlNodeType::StartTag, "CorsRule"}); - writer.Write(XmlNode{XmlNodeType::StartTag, "AllowedOrigins"}); - writer.Write(XmlNode{XmlNodeType::Text, nullptr, options.AllowedOrigins.data()}); - writer.Write(XmlNode{XmlNodeType::EndTag}); - writer.Write(XmlNode{XmlNodeType::StartTag, "AllowedMethods"}); - writer.Write(XmlNode{XmlNodeType::Text, nullptr, options.AllowedMethods.data()}); - writer.Write(XmlNode{XmlNodeType::EndTag}); - writer.Write(XmlNode{XmlNodeType::StartTag, "AllowedHeaders"}); - writer.Write(XmlNode{XmlNodeType::Text, nullptr, options.AllowedHeaders.data()}); - writer.Write(XmlNode{XmlNodeType::EndTag}); - writer.Write(XmlNode{XmlNodeType::StartTag, "ExposedHeaders"}); - writer.Write(XmlNode{XmlNodeType::Text, nullptr, options.ExposedHeaders.data()}); - writer.Write(XmlNode{XmlNodeType::EndTag}); - writer.Write(XmlNode{XmlNodeType::StartTag, "MaxAgeInSeconds"}); - writer.Write( - XmlNode{XmlNodeType::Text, nullptr, std::to_string(options.MaxAgeInSeconds).data()}); - writer.Write(XmlNode{XmlNodeType::EndTag}); - writer.Write(XmlNode{XmlNodeType::EndTag}); - } - - static void BlobMetricsToXml(XmlWriter& writer, const BlobMetrics& options) - { - writer.Write(XmlNode{XmlNodeType::StartTag, "Version"}); - writer.Write(XmlNode{XmlNodeType::Text, nullptr, options.Version.data()}); - writer.Write(XmlNode{XmlNodeType::EndTag}); - writer.Write(XmlNode{XmlNodeType::StartTag, "Enabled"}); - writer.Write(XmlNode{XmlNodeType::Text, nullptr, options.Enabled ? "true" : "false"}); - writer.Write(XmlNode{XmlNodeType::EndTag}); - if (options.IncludeApis.HasValue()) - { - writer.Write(XmlNode{XmlNodeType::StartTag, "IncludeAPIs"}); - writer.Write(XmlNode{ - XmlNodeType::Text, nullptr, options.IncludeApis.GetValue() ? "true" : "false"}); + writer.Write(XmlNode{XmlNodeType::StartTag, "KeyInfo"}); + writer.Write(XmlNode{XmlNodeType::StartTag, "Start"}); + writer.Write(XmlNode{XmlNodeType::Text, nullptr, options.StartsOn.data()}); + writer.Write(XmlNode{XmlNodeType::EndTag}); + writer.Write(XmlNode{XmlNodeType::StartTag, "Expiry"}); + writer.Write(XmlNode{XmlNodeType::Text, nullptr, options.ExpiresOn.data()}); + writer.Write(XmlNode{XmlNodeType::EndTag}); writer.Write(XmlNode{XmlNodeType::EndTag}); } - writer.Write(XmlNode{XmlNodeType::StartTag, "RetentionPolicy"}); - BlobRetentionPolicyToXml(writer, options.RetentionPolicy); - writer.Write(XmlNode{XmlNodeType::EndTag}); - } - static void BlobRetentionPolicyToXml(XmlWriter& writer, const BlobRetentionPolicy& options) - { - writer.Write(XmlNode{XmlNodeType::StartTag, "Enabled"}); - writer.Write(XmlNode{XmlNodeType::Text, nullptr, options.Enabled ? "true" : "false"}); - writer.Write(XmlNode{XmlNodeType::EndTag}); - if (options.Days.HasValue()) + static void SetServicePropertiesOptionsToXml( + XmlWriter& writer, + const SetServicePropertiesOptions& options) { - writer.Write(XmlNode{XmlNodeType::StartTag, "Days"}); + writer.Write(XmlNode{XmlNodeType::StartTag, "StorageServiceProperties"}); + BlobServicePropertiesToXml(writer, options.Properties); + writer.Write(XmlNode{XmlNodeType::EndTag}); + } + + static void BlobServicePropertiesToXml( + XmlWriter& writer, + const BlobServiceProperties& options) + { + writer.Write(XmlNode{XmlNodeType::StartTag, "Logging"}); + BlobAnalyticsLoggingToXml(writer, options.Logging); + writer.Write(XmlNode{XmlNodeType::EndTag}); + writer.Write(XmlNode{XmlNodeType::StartTag, "HourMetrics"}); + BlobMetricsToXml(writer, options.HourMetrics); + writer.Write(XmlNode{XmlNodeType::EndTag}); + writer.Write(XmlNode{XmlNodeType::StartTag, "MinuteMetrics"}); + BlobMetricsToXml(writer, options.MinuteMetrics); + writer.Write(XmlNode{XmlNodeType::EndTag}); + writer.Write(XmlNode{XmlNodeType::StartTag, "Cors"}); + for (const auto& i : options.Cors) + { + BlobCorsRuleToXml(writer, i); + } + writer.Write(XmlNode{XmlNodeType::EndTag}); + writer.Write(XmlNode{XmlNodeType::StartTag, "DefaultServiceVersion"}); + writer.Write(XmlNode{XmlNodeType::Text, nullptr, options.DefaultServiceVersion.data()}); + writer.Write(XmlNode{XmlNodeType::EndTag}); + writer.Write(XmlNode{XmlNodeType::StartTag, "DeleteRetentionPolicy"}); + BlobRetentionPolicyToXml(writer, options.DeleteRetentionPolicy); + writer.Write(XmlNode{XmlNodeType::EndTag}); + writer.Write(XmlNode{XmlNodeType::StartTag, "StaticWebsite"}); + BlobStaticWebsiteToXml(writer, options.StaticWebsite); + writer.Write(XmlNode{XmlNodeType::EndTag}); + } + + static void BlobAnalyticsLoggingToXml( + XmlWriter& writer, + const BlobAnalyticsLogging& options) + { + writer.Write(XmlNode{XmlNodeType::StartTag, "Version"}); + writer.Write(XmlNode{XmlNodeType::Text, nullptr, options.Version.data()}); + writer.Write(XmlNode{XmlNodeType::EndTag}); + writer.Write(XmlNode{XmlNodeType::StartTag, "Delete"}); + writer.Write(XmlNode{XmlNodeType::Text, nullptr, options.Delete ? "true" : "false"}); + writer.Write(XmlNode{XmlNodeType::EndTag}); + writer.Write(XmlNode{XmlNodeType::StartTag, "Read"}); + writer.Write(XmlNode{XmlNodeType::Text, nullptr, options.Read ? "true" : "false"}); + writer.Write(XmlNode{XmlNodeType::EndTag}); + writer.Write(XmlNode{XmlNodeType::StartTag, "Write"}); + writer.Write(XmlNode{XmlNodeType::Text, nullptr, options.Write ? "true" : "false"}); + writer.Write(XmlNode{XmlNodeType::EndTag}); + writer.Write(XmlNode{XmlNodeType::StartTag, "RetentionPolicy"}); + BlobRetentionPolicyToXml(writer, options.RetentionPolicy); + writer.Write(XmlNode{XmlNodeType::EndTag}); + } + + static void BlobCorsRuleToXml(XmlWriter& writer, const BlobCorsRule& options) + { + writer.Write(XmlNode{XmlNodeType::StartTag, "CorsRule"}); + writer.Write(XmlNode{XmlNodeType::StartTag, "AllowedOrigins"}); + writer.Write(XmlNode{XmlNodeType::Text, nullptr, options.AllowedOrigins.data()}); + writer.Write(XmlNode{XmlNodeType::EndTag}); + writer.Write(XmlNode{XmlNodeType::StartTag, "AllowedMethods"}); + writer.Write(XmlNode{XmlNodeType::Text, nullptr, options.AllowedMethods.data()}); + writer.Write(XmlNode{XmlNodeType::EndTag}); + writer.Write(XmlNode{XmlNodeType::StartTag, "AllowedHeaders"}); + writer.Write(XmlNode{XmlNodeType::Text, nullptr, options.AllowedHeaders.data()}); + writer.Write(XmlNode{XmlNodeType::EndTag}); + writer.Write(XmlNode{XmlNodeType::StartTag, "ExposedHeaders"}); + writer.Write(XmlNode{XmlNodeType::Text, nullptr, options.ExposedHeaders.data()}); + writer.Write(XmlNode{XmlNodeType::EndTag}); + writer.Write(XmlNode{XmlNodeType::StartTag, "MaxAgeInSeconds"}); writer.Write( - XmlNode{XmlNodeType::Text, nullptr, std::to_string(options.Days.GetValue()).data()}); + XmlNode{XmlNodeType::Text, nullptr, std::to_string(options.MaxAgeInSeconds).data()}); + writer.Write(XmlNode{XmlNodeType::EndTag}); writer.Write(XmlNode{XmlNodeType::EndTag}); } - } - static void BlobStaticWebsiteToXml(XmlWriter& writer, const BlobStaticWebsite& options) - { - writer.Write(XmlNode{XmlNodeType::StartTag, "Enabled"}); - writer.Write(XmlNode{XmlNodeType::Text, nullptr, options.Enabled ? "true" : "false"}); - writer.Write(XmlNode{XmlNodeType::EndTag}); - if (options.IndexDocument.HasValue()) + static void BlobMetricsToXml(XmlWriter& writer, const BlobMetrics& options) { - writer.Write(XmlNode{XmlNodeType::StartTag, "IndexDocument"}); - writer.Write( - XmlNode{XmlNodeType::Text, nullptr, options.IndexDocument.GetValue().data()}); + writer.Write(XmlNode{XmlNodeType::StartTag, "Version"}); + writer.Write(XmlNode{XmlNodeType::Text, nullptr, options.Version.data()}); + writer.Write(XmlNode{XmlNodeType::EndTag}); + writer.Write(XmlNode{XmlNodeType::StartTag, "Enabled"}); + writer.Write(XmlNode{XmlNodeType::Text, nullptr, options.Enabled ? "true" : "false"}); + writer.Write(XmlNode{XmlNodeType::EndTag}); + if (options.IncludeApis.HasValue()) + { + writer.Write(XmlNode{XmlNodeType::StartTag, "IncludeAPIs"}); + writer.Write(XmlNode{ + XmlNodeType::Text, nullptr, options.IncludeApis.GetValue() ? "true" : "false"}); + writer.Write(XmlNode{XmlNodeType::EndTag}); + } + writer.Write(XmlNode{XmlNodeType::StartTag, "RetentionPolicy"}); + BlobRetentionPolicyToXml(writer, options.RetentionPolicy); writer.Write(XmlNode{XmlNodeType::EndTag}); } - if (options.DefaultIndexDocumentPath.HasValue()) + + static void BlobRetentionPolicyToXml(XmlWriter& writer, const BlobRetentionPolicy& options) { - writer.Write(XmlNode{XmlNodeType::StartTag, "DefaultIndexDocumentPath"}); - writer.Write(XmlNode{ - XmlNodeType::Text, nullptr, options.DefaultIndexDocumentPath.GetValue().data()}); + writer.Write(XmlNode{XmlNodeType::StartTag, "Enabled"}); + writer.Write(XmlNode{XmlNodeType::Text, nullptr, options.Enabled ? "true" : "false"}); writer.Write(XmlNode{XmlNodeType::EndTag}); + if (options.Days.HasValue()) + { + writer.Write(XmlNode{XmlNodeType::StartTag, "Days"}); + writer.Write(XmlNode{ + XmlNodeType::Text, nullptr, std::to_string(options.Days.GetValue()).data()}); + writer.Write(XmlNode{XmlNodeType::EndTag}); + } } - if (options.ErrorDocument404Path.HasValue()) + + static void BlobStaticWebsiteToXml(XmlWriter& writer, const BlobStaticWebsite& options) { - writer.Write(XmlNode{XmlNodeType::StartTag, "ErrorDocument404Path"}); - writer.Write( - XmlNode{XmlNodeType::Text, nullptr, options.ErrorDocument404Path.GetValue().data()}); + writer.Write(XmlNode{XmlNodeType::StartTag, "Enabled"}); + writer.Write(XmlNode{XmlNodeType::Text, nullptr, options.Enabled ? "true" : "false"}); writer.Write(XmlNode{XmlNodeType::EndTag}); - } - } - - }; // class Service - - class Container { - public: - struct CreateContainerOptions - { - Azure::Core::Nullable Timeout; - Azure::Core::Nullable AccessType; - std::map Metadata; - Azure::Core::Nullable DefaultEncryptionScope; - Azure::Core::Nullable PreventEncryptionScopeOverride; - }; // struct CreateContainerOptions - - static Azure::Core::Response Create( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const CreateContainerOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); - request.AddHeader("Content-Length", "0"); - request.GetUrl().AppendQueryParameter("restype", "container"); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - std::set metadataKeys; - for (const auto& pair : options.Metadata) - { - if (metadataKeys.insert(Azure::Core::Strings::ToLower(pair.first)).second == false) + if (options.IndexDocument.HasValue()) { - throw std::runtime_error("duplicate keys in metadata"); + writer.Write(XmlNode{XmlNodeType::StartTag, "IndexDocument"}); + writer.Write( + XmlNode{XmlNodeType::Text, nullptr, options.IndexDocument.GetValue().data()}); + writer.Write(XmlNode{XmlNodeType::EndTag}); } - request.AddHeader("x-ms-meta-" + pair.first, pair.second); - } - metadataKeys.clear(); - if (options.AccessType.HasValue()) - { - request.AddHeader( - "x-ms-blob-public-access", PublicAccessTypeToString(options.AccessType.GetValue())); - } - if (options.DefaultEncryptionScope.HasValue()) - { - request.AddHeader( - "x-ms-default-encryption-scope", options.DefaultEncryptionScope.GetValue()); - } - if (options.PreventEncryptionScopeOverride.HasValue()) - { - request.AddHeader( - "x-ms-deny-encryption-scope-override", - options.PreventEncryptionScopeOverride.GetValue() ? "true" : "false"); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - CreateContainerResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 201)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - response.ETag = httpResponse.GetHeaders().at("etag"); - response.LastModified = httpResponse.GetHeaders().at("last-modified"); - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct DeleteContainerOptions - { - Azure::Core::Nullable Timeout; - Azure::Core::Nullable LeaseId; - Azure::Core::Nullable IfModifiedSince; - Azure::Core::Nullable IfUnmodifiedSince; - }; // struct DeleteContainerOptions - - static Azure::Core::Response Delete( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const DeleteContainerOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Delete, url); - request.GetUrl().AppendQueryParameter("restype", "container"); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - if (options.LeaseId.HasValue()) - { - request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); - } - if (options.IfModifiedSince.HasValue()) - { - request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); - } - if (options.IfUnmodifiedSince.HasValue()) - { - request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - DeleteContainerResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 202)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct UndeleteContainerOptions - { - Azure::Core::Nullable Timeout; - std::string DeletedContainerName; - std::string DeletedContainerVersion; - }; // struct UndeleteContainerOptions - - static Azure::Core::Response Undelete( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const UndeleteContainerOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); - request.AddHeader("Content-Length", "0"); - request.GetUrl().AppendQueryParameter("restype", "container"); - request.GetUrl().AppendQueryParameter("comp", "undelete"); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - request.AddHeader("x-ms-deleted-container-name", options.DeletedContainerName); - request.AddHeader("x-ms-deleted-container-version", options.DeletedContainerVersion); - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - UndeleteContainerResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 201)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct GetContainerPropertiesOptions - { - Azure::Core::Nullable Timeout; - Azure::Core::Nullable LeaseId; - }; // struct GetContainerPropertiesOptions - - static Azure::Core::Response GetProperties( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const GetContainerPropertiesOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Head, url); - request.GetUrl().AppendQueryParameter("restype", "container"); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - if (options.LeaseId.HasValue()) - { - request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - GetContainerPropertiesResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 200)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - response.ETag = httpResponse.GetHeaders().at("etag"); - response.LastModified = httpResponse.GetHeaders().at("last-modified"); - for (auto i = httpResponse.GetHeaders().lower_bound("x-ms-meta-"); - i != httpResponse.GetHeaders().end() && i->first.substr(0, 10) == "x-ms-meta-"; - ++i) - { - response.Metadata.emplace(i->first.substr(10), i->second); - } - auto response_access_type_iterator - = httpResponse.GetHeaders().find("x-ms-blob-public-access"); - if (response_access_type_iterator != httpResponse.GetHeaders().end()) - { - response.AccessType = PublicAccessTypeFromString(response_access_type_iterator->second); - } - response.HasImmutabilityPolicy - = httpResponse.GetHeaders().at("x-ms-has-immutability-policy") == "true"; - response.HasLegalHold = httpResponse.GetHeaders().at("x-ms-has-legal-hold") == "true"; - response.LeaseStatus - = BlobLeaseStatusFromString(httpResponse.GetHeaders().at("x-ms-lease-status")); - response.LeaseState - = BlobLeaseStateFromString(httpResponse.GetHeaders().at("x-ms-lease-state")); - auto response_lease_duration_iterator - = httpResponse.GetHeaders().find("x-ms-lease-duration"); - if (response_lease_duration_iterator != httpResponse.GetHeaders().end()) - { - response.LeaseDuration = response_lease_duration_iterator->second; - } - response.DefaultEncryptionScope - = httpResponse.GetHeaders().at("x-ms-default-encryption-scope"); - response.PreventEncryptionScopeOverride - = httpResponse.GetHeaders().at("x-ms-deny-encryption-scope-override") == "true"; - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct SetContainerMetadataOptions - { - Azure::Core::Nullable Timeout; - std::map Metadata; - Azure::Core::Nullable LeaseId; - Azure::Core::Nullable IfModifiedSince; - }; // struct SetContainerMetadataOptions - - static Azure::Core::Response SetMetadata( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const SetContainerMetadataOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); - request.AddHeader("Content-Length", "0"); - request.GetUrl().AppendQueryParameter("restype", "container"); - request.GetUrl().AppendQueryParameter("comp", "metadata"); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - std::set metadataKeys; - for (const auto& pair : options.Metadata) - { - if (metadataKeys.insert(Azure::Core::Strings::ToLower(pair.first)).second == false) + if (options.DefaultIndexDocumentPath.HasValue()) { - throw std::runtime_error("duplicate keys in metadata"); + writer.Write(XmlNode{XmlNodeType::StartTag, "DefaultIndexDocumentPath"}); + writer.Write(XmlNode{ + XmlNodeType::Text, nullptr, options.DefaultIndexDocumentPath.GetValue().data()}); + writer.Write(XmlNode{XmlNodeType::EndTag}); } - request.AddHeader("x-ms-meta-" + pair.first, pair.second); - } - metadataKeys.clear(); - if (options.LeaseId.HasValue()) - { - request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); - } - if (options.IfModifiedSince.HasValue()) - { - request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - SetContainerMetadataResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 200)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - response.ETag = httpResponse.GetHeaders().at("etag"); - response.LastModified = httpResponse.GetHeaders().at("last-modified"); - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct ListBlobsFlatSegmentOptions - { - Azure::Core::Nullable Timeout; - Azure::Core::Nullable Prefix; - Azure::Core::Nullable ContinuationToken; - Azure::Core::Nullable MaxResults; - ListBlobsIncludeItem Include = ListBlobsIncludeItem::None; - }; // struct ListBlobsFlatSegmentOptions - - static Azure::Core::Response ListBlobsFlat( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const ListBlobsFlatSegmentOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - request.GetUrl().AppendQueryParameter("restype", "container"); - request.GetUrl().AppendQueryParameter("comp", "list"); - if (options.Prefix.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "prefix", Details::UrlEncodeQueryParameter(options.Prefix.GetValue())); - } - if (options.ContinuationToken.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "marker", Details::UrlEncodeQueryParameter(options.ContinuationToken.GetValue())); - } - if (options.MaxResults.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "maxresults", std::to_string(options.MaxResults.GetValue())); - } - std::string list_blobs_include_item = ListBlobsIncludeItemToString(options.Include); - if (!list_blobs_include_item.empty()) - { - request.GetUrl().AppendQueryParameter( - "include", Details::UrlEncodeQueryParameter(list_blobs_include_item)); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - ListBlobsFlatSegmentResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 200)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - { - const auto& httpResponseBody = httpResponse.GetBody(); - XmlReader reader( - reinterpret_cast(httpResponseBody.data()), httpResponseBody.size()); - response = ListBlobsFlatSegmentResultFromXml(reader); - } - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct ListBlobsByHierarchySegmentOptions - { - Azure::Core::Nullable Timeout; - Azure::Core::Nullable Prefix; - Azure::Core::Nullable Delimiter; - Azure::Core::Nullable ContinuationToken; - Azure::Core::Nullable MaxResults; - ListBlobsIncludeItem Include = ListBlobsIncludeItem::None; - }; // struct ListBlobsByHierarchySegmentOptions - - static Azure::Core::Response ListBlobsByHierarchy( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const ListBlobsByHierarchySegmentOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - request.GetUrl().AppendQueryParameter("restype", "container"); - request.GetUrl().AppendQueryParameter("comp", "list"); - if (options.Prefix.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "prefix", Details::UrlEncodeQueryParameter(options.Prefix.GetValue())); - } - if (options.Delimiter.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "delimiter", Details::UrlEncodeQueryParameter(options.Delimiter.GetValue())); - } - if (options.ContinuationToken.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "marker", Details::UrlEncodeQueryParameter(options.ContinuationToken.GetValue())); - } - if (options.MaxResults.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "maxresults", std::to_string(options.MaxResults.GetValue())); - } - std::string list_blobs_include_item = ListBlobsIncludeItemToString(options.Include); - if (!list_blobs_include_item.empty()) - { - request.GetUrl().AppendQueryParameter( - "include", Details::UrlEncodeQueryParameter(list_blobs_include_item)); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - ListBlobsByHierarchySegmentResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 200)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - { - const auto& httpResponseBody = httpResponse.GetBody(); - XmlReader reader( - reinterpret_cast(httpResponseBody.data()), httpResponseBody.size()); - response = ListBlobsByHierarchySegmentResultFromXml(reader); - } - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct GetContainerAccessPolicyOptions - { - Azure::Core::Nullable Timeout; - Azure::Core::Nullable LeaseId; - }; // struct GetContainerAccessPolicyOptions - - static Azure::Core::Response GetAccessPolicy( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const GetContainerAccessPolicyOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - request.GetUrl().AppendQueryParameter("restype", "container"); - request.GetUrl().AppendQueryParameter("comp", "acl"); - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - GetContainerAccessPolicyResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 200)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - { - const auto& httpResponseBody = httpResponse.GetBody(); - XmlReader reader( - reinterpret_cast(httpResponseBody.data()), httpResponseBody.size()); - response = GetContainerAccessPolicyResultFromXml(reader); - } - response.ETag = httpResponse.GetHeaders().at("etag"); - response.LastModified = httpResponse.GetHeaders().at("last-modified"); - response.AccessType - = PublicAccessTypeFromString(httpResponse.GetHeaders().at("x-ms-blob-public-access")); - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct SetContainerAccessPolicyOptions - { - Azure::Core::Nullable Timeout; - Azure::Core::Nullable AccessType; - Azure::Core::Nullable LeaseId; - Azure::Core::Nullable IfModifiedSince; - Azure::Core::Nullable IfUnmodifiedSince; - std::vector SignedIdentifiers; - }; // struct SetContainerAccessPolicyOptions - - static Azure::Core::Response SetAccessPolicy( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const SetContainerAccessPolicyOptions& options) - { - unused(options); - std::string xml_body; - { - XmlWriter writer; - SetContainerAccessPolicyOptionsToXml(writer, options); - xml_body = writer.GetDocument(); - writer.Write(XmlNode{XmlNodeType::End}); - } - Azure::Core::Http::MemoryBodyStream xml_body_stream( - reinterpret_cast(xml_body.data()), xml_body.length()); - auto request - = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url, &xml_body_stream); - request.AddHeader("Content-Length", std::to_string(xml_body_stream.Length())); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - request.GetUrl().AppendQueryParameter("restype", "container"); - request.GetUrl().AppendQueryParameter("comp", "acl"); - if (options.AccessType.HasValue()) - { - request.AddHeader( - "x-ms-blob-public-access", PublicAccessTypeToString(options.AccessType.GetValue())); - } - if (options.LeaseId.HasValue()) - { - request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); - } - if (options.IfModifiedSince.HasValue()) - { - request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); - } - if (options.IfUnmodifiedSince.HasValue()) - { - request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - SetContainerAccessPolicyResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 200)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - response.ETag = httpResponse.GetHeaders().at("etag"); - response.LastModified = httpResponse.GetHeaders().at("last-modified"); - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct AcquireContainerLeaseOptions - { - Azure::Core::Nullable Timeout; - int32_t LeaseDuration = -1; - Azure::Core::Nullable ProposedLeaseId; - Azure::Core::Nullable IfModifiedSince; - Azure::Core::Nullable IfUnmodifiedSince; - }; // struct AcquireContainerLeaseOptions - - static Azure::Core::Response AcquireLease( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const AcquireContainerLeaseOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); - request.AddHeader("Content-Length", "0"); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - request.GetUrl().AppendQueryParameter("restype", "container"); - request.GetUrl().AppendQueryParameter("comp", "lease"); - request.AddHeader("x-ms-lease-action", "acquire"); - request.AddHeader("x-ms-lease-duration", std::to_string(options.LeaseDuration)); - if (options.ProposedLeaseId.HasValue()) - { - request.AddHeader("x-ms-proposed-lease-id", options.ProposedLeaseId.GetValue()); - } - if (options.IfModifiedSince.HasValue()) - { - request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); - } - if (options.IfUnmodifiedSince.HasValue()) - { - request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - AcquireContainerLeaseResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 201)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - response.ETag = httpResponse.GetHeaders().at("etag"); - response.LastModified = httpResponse.GetHeaders().at("last-modified"); - response.LeaseId = httpResponse.GetHeaders().at("x-ms-lease-id"); - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct RenewContainerLeaseOptions - { - Azure::Core::Nullable Timeout; - std::string LeaseId; - Azure::Core::Nullable IfModifiedSince; - Azure::Core::Nullable IfUnmodifiedSince; - }; // struct RenewContainerLeaseOptions - - static Azure::Core::Response RenewLease( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const RenewContainerLeaseOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); - request.AddHeader("Content-Length", "0"); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - request.GetUrl().AppendQueryParameter("restype", "container"); - request.GetUrl().AppendQueryParameter("comp", "lease"); - request.AddHeader("x-ms-lease-action", "renew"); - request.AddHeader("x-ms-lease-id", options.LeaseId); - if (options.IfModifiedSince.HasValue()) - { - request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); - } - if (options.IfUnmodifiedSince.HasValue()) - { - request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - RenewContainerLeaseResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 200)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - response.ETag = httpResponse.GetHeaders().at("etag"); - response.LastModified = httpResponse.GetHeaders().at("last-modified"); - response.LeaseId = httpResponse.GetHeaders().at("x-ms-lease-id"); - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct ChangeContainerLeaseOptions - { - Azure::Core::Nullable Timeout; - std::string LeaseId; - std::string ProposedLeaseId; - Azure::Core::Nullable IfModifiedSince; - Azure::Core::Nullable IfUnmodifiedSince; - }; // struct ChangeContainerLeaseOptions - - static Azure::Core::Response ChangeLease( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const ChangeContainerLeaseOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); - request.AddHeader("Content-Length", "0"); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - request.GetUrl().AppendQueryParameter("restype", "container"); - request.GetUrl().AppendQueryParameter("comp", "lease"); - request.AddHeader("x-ms-lease-action", "change"); - request.AddHeader("x-ms-lease-id", options.LeaseId); - request.AddHeader("x-ms-proposed-lease-id", options.ProposedLeaseId); - if (options.IfModifiedSince.HasValue()) - { - request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); - } - if (options.IfUnmodifiedSince.HasValue()) - { - request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - ChangeContainerLeaseResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 200)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - response.ETag = httpResponse.GetHeaders().at("etag"); - response.LastModified = httpResponse.GetHeaders().at("last-modified"); - response.LeaseId = httpResponse.GetHeaders().at("x-ms-lease-id"); - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct ReleaseContainerLeaseOptions - { - Azure::Core::Nullable Timeout; - std::string LeaseId; - Azure::Core::Nullable IfModifiedSince; - Azure::Core::Nullable IfUnmodifiedSince; - }; // struct ReleaseContainerLeaseOptions - - static Azure::Core::Response ReleaseLease( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const ReleaseContainerLeaseOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); - request.AddHeader("Content-Length", "0"); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - request.GetUrl().AppendQueryParameter("restype", "container"); - request.GetUrl().AppendQueryParameter("comp", "lease"); - request.AddHeader("x-ms-lease-action", "release"); - request.AddHeader("x-ms-lease-id", options.LeaseId); - if (options.IfModifiedSince.HasValue()) - { - request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); - } - if (options.IfUnmodifiedSince.HasValue()) - { - request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - ReleaseContainerLeaseResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 200)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - response.ETag = httpResponse.GetHeaders().at("etag"); - response.LastModified = httpResponse.GetHeaders().at("last-modified"); - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct BreakContainerLeaseOptions - { - Azure::Core::Nullable Timeout; - Azure::Core::Nullable BreakPeriod; - Azure::Core::Nullable IfModifiedSince; - Azure::Core::Nullable IfUnmodifiedSince; - }; // struct BreakContainerLeaseOptions - - static Azure::Core::Response BreakLease( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const BreakContainerLeaseOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); - request.AddHeader("Content-Length", "0"); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - request.GetUrl().AppendQueryParameter("restype", "container"); - request.GetUrl().AppendQueryParameter("comp", "lease"); - request.AddHeader("x-ms-lease-action", "break"); - if (options.BreakPeriod.HasValue()) - { - request.AddHeader( - "x-ms-lease-break-period", std::to_string(options.BreakPeriod.GetValue())); - } - if (options.IfModifiedSince.HasValue()) - { - request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); - } - if (options.IfUnmodifiedSince.HasValue()) - { - request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - BreakContainerLeaseResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 202)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - response.ETag = httpResponse.GetHeaders().at("etag"); - response.LastModified = httpResponse.GetHeaders().at("last-modified"); - response.LeaseTime = std::stoi(httpResponse.GetHeaders().at("x-ms-lease-time")); - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - private: - static GetContainerAccessPolicyResult GetContainerAccessPolicyResultFromXml(XmlReader& reader) - { - GetContainerAccessPolicyResult ret; - enum class XmlTagName - { - k_SignedIdentifiers, - k_SignedIdentifier, - k_Unknown, - }; - std::vector path; - while (true) - { - auto node = reader.Read(); - if (node.Type == XmlNodeType::End) - { - break; - } - else if (node.Type == XmlNodeType::EndTag) - { - if (path.size() > 0) - { - path.pop_back(); - } - else - { - break; - } - } - else if (node.Type == XmlNodeType::StartTag) - { - if (std::strcmp(node.Name, "SignedIdentifiers") == 0) - { - path.emplace_back(XmlTagName::k_SignedIdentifiers); - } - else if (std::strcmp(node.Name, "SignedIdentifier") == 0) - { - path.emplace_back(XmlTagName::k_SignedIdentifier); - } - else - { - path.emplace_back(XmlTagName::k_Unknown); - } - if (path.size() == 2 && path[0] == XmlTagName::k_SignedIdentifiers - && path[1] == XmlTagName::k_SignedIdentifier) - { - ret.SignedIdentifiers.emplace_back(BlobSignedIdentifierFromXml(reader)); - path.pop_back(); - } - } - else if (node.Type == XmlNodeType::Text) + if (options.ErrorDocument404Path.HasValue()) { + writer.Write(XmlNode{XmlNodeType::StartTag, "ErrorDocument404Path"}); + writer.Write(XmlNode{ + XmlNodeType::Text, nullptr, options.ErrorDocument404Path.GetValue().data()}); + writer.Write(XmlNode{XmlNodeType::EndTag}); } } - return ret; - } - static ListBlobsByHierarchySegmentResult ListBlobsByHierarchySegmentResultFromXml( - XmlReader& reader) - { - ListBlobsByHierarchySegmentResult ret; - enum class XmlTagName - { - k_EnumerationResults, - k_Prefix, - k_Delimiter, - k_Marker, - k_NextMarker, - k_Blobs, - k_Blob, - k_BlobPrefix, - k_Unknown, - }; - std::vector path; - while (true) - { - auto node = reader.Read(); - if (node.Type == XmlNodeType::End) - { - break; - } - else if (node.Type == XmlNodeType::EndTag) - { - if (path.size() > 0) - { - path.pop_back(); - } - else - { - break; - } - } - else if (node.Type == XmlNodeType::StartTag) - { - if (std::strcmp(node.Name, "EnumerationResults") == 0) - { - path.emplace_back(XmlTagName::k_EnumerationResults); - } - else if (std::strcmp(node.Name, "Prefix") == 0) - { - path.emplace_back(XmlTagName::k_Prefix); - } - else if (std::strcmp(node.Name, "Delimiter") == 0) - { - path.emplace_back(XmlTagName::k_Delimiter); - } - else if (std::strcmp(node.Name, "Marker") == 0) - { - path.emplace_back(XmlTagName::k_Marker); - } - else if (std::strcmp(node.Name, "NextMarker") == 0) - { - path.emplace_back(XmlTagName::k_NextMarker); - } - else if (std::strcmp(node.Name, "Blobs") == 0) - { - path.emplace_back(XmlTagName::k_Blobs); - } - else if (std::strcmp(node.Name, "Blob") == 0) - { - path.emplace_back(XmlTagName::k_Blob); - } - else if (std::strcmp(node.Name, "BlobPrefix") == 0) - { - path.emplace_back(XmlTagName::k_BlobPrefix); - } - else - { - path.emplace_back(XmlTagName::k_Unknown); - } - if (path.size() == 3 && path[0] == XmlTagName::k_EnumerationResults - && path[1] == XmlTagName::k_Blobs && path[2] == XmlTagName::k_Blob) - { - ret.Items.emplace_back(BlobItemFromXml(reader)); - path.pop_back(); - } - else if ( - path.size() == 3 && path[0] == XmlTagName::k_EnumerationResults - && path[1] == XmlTagName::k_Blobs && path[2] == XmlTagName::k_BlobPrefix) - { - ret.BlobPrefixes.emplace_back(BlobPrefixFromXml(reader)); - path.pop_back(); - } - } - else if (node.Type == XmlNodeType::Text) - { - if (path.size() == 2 && path[0] == XmlTagName::k_EnumerationResults - && path[1] == XmlTagName::k_Prefix) - { - ret.Prefix = node.Value; - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_EnumerationResults - && path[1] == XmlTagName::k_Delimiter) - { - ret.Delimiter = node.Value; - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_EnumerationResults - && path[1] == XmlTagName::k_Marker) - { - ret.PreviousContinuationToken = node.Value; - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_EnumerationResults - && path[1] == XmlTagName::k_NextMarker) - { - ret.ContinuationToken = node.Value; - } - } - else if (node.Type == XmlNodeType::Attribute) - { - if (path.size() == 1 && path[0] == XmlTagName::k_EnumerationResults - && std::strcmp(node.Name, "ServiceEndpoint") == 0) - { - ret.ServiceEndpoint = node.Value; - } - else if ( - path.size() == 1 && path[0] == XmlTagName::k_EnumerationResults - && std::strcmp(node.Name, "ContainerName") == 0) - { - ret.Container = node.Value; - } - } - } - return ret; - } + }; // class Service - static ListBlobsFlatSegmentResult ListBlobsFlatSegmentResultFromXml(XmlReader& reader) - { - ListBlobsFlatSegmentResult ret; - enum class XmlTagName + class Container { + public: + struct CreateContainerOptions { - k_EnumerationResults, - k_Prefix, - k_Marker, - k_NextMarker, - k_Blobs, - k_Blob, - k_Unknown, - }; - std::vector path; - while (true) - { - auto node = reader.Read(); - if (node.Type == XmlNodeType::End) - { - break; - } - else if (node.Type == XmlNodeType::EndTag) - { - if (path.size() > 0) - { - path.pop_back(); - } - else - { - break; - } - } - else if (node.Type == XmlNodeType::StartTag) - { - if (std::strcmp(node.Name, "EnumerationResults") == 0) - { - path.emplace_back(XmlTagName::k_EnumerationResults); - } - else if (std::strcmp(node.Name, "Prefix") == 0) - { - path.emplace_back(XmlTagName::k_Prefix); - } - else if (std::strcmp(node.Name, "Marker") == 0) - { - path.emplace_back(XmlTagName::k_Marker); - } - else if (std::strcmp(node.Name, "NextMarker") == 0) - { - path.emplace_back(XmlTagName::k_NextMarker); - } - else if (std::strcmp(node.Name, "Blobs") == 0) - { - path.emplace_back(XmlTagName::k_Blobs); - } - else if (std::strcmp(node.Name, "Blob") == 0) - { - path.emplace_back(XmlTagName::k_Blob); - } - else - { - path.emplace_back(XmlTagName::k_Unknown); - } - if (path.size() == 3 && path[0] == XmlTagName::k_EnumerationResults - && path[1] == XmlTagName::k_Blobs && path[2] == XmlTagName::k_Blob) - { - ret.Items.emplace_back(BlobItemFromXml(reader)); - path.pop_back(); - } - } - else if (node.Type == XmlNodeType::Text) - { - if (path.size() == 2 && path[0] == XmlTagName::k_EnumerationResults - && path[1] == XmlTagName::k_Prefix) - { - ret.Prefix = node.Value; - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_EnumerationResults - && path[1] == XmlTagName::k_Marker) - { - ret.PreviousContinuationToken = node.Value; - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_EnumerationResults - && path[1] == XmlTagName::k_NextMarker) - { - ret.ContinuationToken = node.Value; - } - } - else if (node.Type == XmlNodeType::Attribute) - { - if (path.size() == 1 && path[0] == XmlTagName::k_EnumerationResults - && std::strcmp(node.Name, "ServiceEndpoint") == 0) - { - ret.ServiceEndpoint = node.Value; - } - else if ( - path.size() == 1 && path[0] == XmlTagName::k_EnumerationResults - && std::strcmp(node.Name, "ContainerName") == 0) - { - ret.Container = node.Value; - } - } - } - return ret; - } + Azure::Core::Nullable Timeout; + Azure::Core::Nullable AccessType; + std::map Metadata; + Azure::Core::Nullable DefaultEncryptionScope; + Azure::Core::Nullable PreventEncryptionScopeOverride; + }; // struct CreateContainerOptions - static BlobItem BlobItemFromXml(XmlReader& reader) - { - BlobItem ret; - enum class XmlTagName + static Azure::Core::Response Create( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const CreateContainerOptions& options) { - k_Name, - k_Deleted, - k_Snapshot, - k_VersionId, - k_IsCurrentVersion, - k_Properties, - k_ContentType, - k_ContentEncoding, - k_ContentLanguage, - k_ContentMD5, - k_CacheControl, - k_ContentDisposition, - k_CreationTime, - k_ExpiryTime, - k_LastAccessTime, - k_LastModified, - k_Etag, - k_ContentLength, - k_BlobType, - k_AccessTier, - k_AccessTierInferred, - k_LeaseStatus, - k_LeaseState, - k_LeaseDuration, - k_ServerEncrypted, - k_EncryptionKeySHA256, - k_Sealed, - k_xmsblobsequencenumber, - k_Metadata, - k_OrMetadata, - k_Unknown, - }; - std::vector path; - while (true) - { - auto node = reader.Read(); - if (node.Type == XmlNodeType::End) + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); + request.AddHeader("Content-Length", "0"); + request.GetUrl().AppendQueryParameter("restype", "container"); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) { - break; + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); } - else if (node.Type == XmlNodeType::EndTag) + std::set metadataKeys; + for (const auto& pair : options.Metadata) { - if (path.size() > 0) + if (metadataKeys.insert(Azure::Core::Strings::ToLower(pair.first)).second == false) { - path.pop_back(); - } - else - { - break; + throw std::runtime_error("duplicate keys in metadata"); } + request.AddHeader("x-ms-meta-" + pair.first, pair.second); } - else if (node.Type == XmlNodeType::StartTag) - { - if (std::strcmp(node.Name, "Name") == 0) - { - path.emplace_back(XmlTagName::k_Name); - } - else if (std::strcmp(node.Name, "Deleted") == 0) - { - path.emplace_back(XmlTagName::k_Deleted); - } - else if (std::strcmp(node.Name, "Snapshot") == 0) - { - path.emplace_back(XmlTagName::k_Snapshot); - } - else if (std::strcmp(node.Name, "VersionId") == 0) - { - path.emplace_back(XmlTagName::k_VersionId); - } - else if (std::strcmp(node.Name, "IsCurrentVersion") == 0) - { - path.emplace_back(XmlTagName::k_IsCurrentVersion); - } - else if (std::strcmp(node.Name, "Properties") == 0) - { - path.emplace_back(XmlTagName::k_Properties); - } - else if (std::strcmp(node.Name, "Content-Type") == 0) - { - path.emplace_back(XmlTagName::k_ContentType); - } - else if (std::strcmp(node.Name, "Content-Encoding") == 0) - { - path.emplace_back(XmlTagName::k_ContentEncoding); - } - else if (std::strcmp(node.Name, "Content-Language") == 0) - { - path.emplace_back(XmlTagName::k_ContentLanguage); - } - else if (std::strcmp(node.Name, "Content-MD5") == 0) - { - path.emplace_back(XmlTagName::k_ContentMD5); - } - else if (std::strcmp(node.Name, "Cache-Control") == 0) - { - path.emplace_back(XmlTagName::k_CacheControl); - } - else if (std::strcmp(node.Name, "Content-Disposition") == 0) - { - path.emplace_back(XmlTagName::k_ContentDisposition); - } - else if (std::strcmp(node.Name, "Creation-Time") == 0) - { - path.emplace_back(XmlTagName::k_CreationTime); - } - else if (std::strcmp(node.Name, "Expiry-Time") == 0) - { - path.emplace_back(XmlTagName::k_ExpiryTime); - } - else if (std::strcmp(node.Name, "LastAccessTime") == 0) - { - path.emplace_back(XmlTagName::k_LastAccessTime); - } - else if (std::strcmp(node.Name, "Last-Modified") == 0) - { - path.emplace_back(XmlTagName::k_LastModified); - } - else if (std::strcmp(node.Name, "Etag") == 0) - { - path.emplace_back(XmlTagName::k_Etag); - } - else if (std::strcmp(node.Name, "Content-Length") == 0) - { - path.emplace_back(XmlTagName::k_ContentLength); - } - else if (std::strcmp(node.Name, "BlobType") == 0) - { - path.emplace_back(XmlTagName::k_BlobType); - } - else if (std::strcmp(node.Name, "AccessTier") == 0) - { - path.emplace_back(XmlTagName::k_AccessTier); - } - else if (std::strcmp(node.Name, "AccessTierInferred") == 0) - { - path.emplace_back(XmlTagName::k_AccessTierInferred); - } - else if (std::strcmp(node.Name, "LeaseStatus") == 0) - { - path.emplace_back(XmlTagName::k_LeaseStatus); - } - else if (std::strcmp(node.Name, "LeaseState") == 0) - { - path.emplace_back(XmlTagName::k_LeaseState); - } - else if (std::strcmp(node.Name, "LeaseDuration") == 0) - { - path.emplace_back(XmlTagName::k_LeaseDuration); - } - else if (std::strcmp(node.Name, "ServerEncrypted") == 0) - { - path.emplace_back(XmlTagName::k_ServerEncrypted); - } - else if (std::strcmp(node.Name, "EncryptionKeySHA256") == 0) - { - path.emplace_back(XmlTagName::k_EncryptionKeySHA256); - } - else if (std::strcmp(node.Name, "Sealed") == 0) - { - path.emplace_back(XmlTagName::k_Sealed); - } - else if (std::strcmp(node.Name, "x-ms-blob-sequence-number") == 0) - { - path.emplace_back(XmlTagName::k_xmsblobsequencenumber); - } - else if (std::strcmp(node.Name, "Metadata") == 0) - { - path.emplace_back(XmlTagName::k_Metadata); - } - else if (std::strcmp(node.Name, "OrMetadata") == 0) - { - path.emplace_back(XmlTagName::k_OrMetadata); - } - else - { - path.emplace_back(XmlTagName::k_Unknown); - } - if (path.size() == 1 && path[0] == XmlTagName::k_Metadata) - { - ret.Metadata = MetadataFromXml(reader); - path.pop_back(); - } - else if (path.size() == 1 && path[0] == XmlTagName::k_OrMetadata) - { - ret.ObjectReplicationSourceProperties - = ObjectReplicationSourcePropertiesFromXml(reader); - path.pop_back(); - } - } - else if (node.Type == XmlNodeType::Text) - { - if (path.size() == 1 && path[0] == XmlTagName::k_Name) - { - ret.Name = node.Value; - } - else if (path.size() == 1 && path[0] == XmlTagName::k_Deleted) - { - ret.Deleted = std::strcmp(node.Value, "true") == 0; - } - else if (path.size() == 1 && path[0] == XmlTagName::k_Snapshot) - { - ret.Snapshot = node.Value; - } - else if (path.size() == 1 && path[0] == XmlTagName::k_VersionId) - { - ret.VersionId = node.Value; - } - else if (path.size() == 1 && path[0] == XmlTagName::k_IsCurrentVersion) - { - ret.IsCurrentVersion = std::strcmp(node.Value, "true") == 0; - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_Properties - && path[1] == XmlTagName::k_ContentType) - { - ret.HttpHeaders.ContentType = node.Value; - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_Properties - && path[1] == XmlTagName::k_ContentEncoding) - { - ret.HttpHeaders.ContentEncoding = node.Value; - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_Properties - && path[1] == XmlTagName::k_ContentLanguage) - { - ret.HttpHeaders.ContentLanguage = node.Value; - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_Properties - && path[1] == XmlTagName::k_ContentMD5) - { - ret.HttpHeaders.ContentMd5 = node.Value; - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_Properties - && path[1] == XmlTagName::k_CacheControl) - { - ret.HttpHeaders.CacheControl = node.Value; - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_Properties - && path[1] == XmlTagName::k_ContentDisposition) - { - ret.HttpHeaders.ContentDisposition = node.Value; - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_Properties - && path[1] == XmlTagName::k_CreationTime) - { - ret.CreationTime = node.Value; - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_Properties - && path[1] == XmlTagName::k_ExpiryTime) - { - ret.ExpiryTime = node.Value; - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_Properties - && path[1] == XmlTagName::k_LastAccessTime) - { - ret.LastAccessTime = node.Value; - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_Properties - && path[1] == XmlTagName::k_LastModified) - { - ret.LastModified = node.Value; - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_Properties - && path[1] == XmlTagName::k_Etag) - { - ret.ETag = node.Value; - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_Properties - && path[1] == XmlTagName::k_ContentLength) - { - ret.ContentLength = std::stoll(node.Value); - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_Properties - && path[1] == XmlTagName::k_BlobType) - { - ret.BlobType = BlobTypeFromString(node.Value); - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_Properties - && path[1] == XmlTagName::k_AccessTier) - { - ret.Tier = AccessTierFromString(node.Value); - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_Properties - && path[1] == XmlTagName::k_AccessTierInferred) - { - ret.AccessTierInferred = std::strcmp(node.Value, "true") == 0; - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_Properties - && path[1] == XmlTagName::k_LeaseStatus) - { - ret.LeaseStatus = BlobLeaseStatusFromString(node.Value); - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_Properties - && path[1] == XmlTagName::k_LeaseState) - { - ret.LeaseState = BlobLeaseStateFromString(node.Value); - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_Properties - && path[1] == XmlTagName::k_LeaseDuration) - { - ret.LeaseDuration = node.Value; - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_Properties - && path[1] == XmlTagName::k_ServerEncrypted) - { - ret.ServerEncrypted = std::strcmp(node.Value, "true") == 0; - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_Properties - && path[1] == XmlTagName::k_EncryptionKeySHA256) - { - ret.EncryptionKeySha256 = node.Value; - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_Properties - && path[1] == XmlTagName::k_Sealed) - { - ret.IsSealed = std::strcmp(node.Value, "true") == 0; - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_Properties - && path[1] == XmlTagName::k_xmsblobsequencenumber) - { - ret.SequenceNumber = std::stoll(node.Value); - } - } - } - return ret; - } - - static BlobPrefix BlobPrefixFromXml(XmlReader& reader) - { - BlobPrefix ret; - enum class XmlTagName - { - k_Name, - k_Unknown, - }; - std::vector path; - while (true) - { - auto node = reader.Read(); - if (node.Type == XmlNodeType::End) - { - break; - } - else if (node.Type == XmlNodeType::EndTag) - { - if (path.size() > 0) - { - path.pop_back(); - } - else - { - break; - } - } - else if (node.Type == XmlNodeType::StartTag) - { - if (std::strcmp(node.Name, "Name") == 0) - { - path.emplace_back(XmlTagName::k_Name); - } - else - { - path.emplace_back(XmlTagName::k_Unknown); - } - } - else if (node.Type == XmlNodeType::Text) - { - if (path.size() == 1 && path[0] == XmlTagName::k_Name) - { - ret.Name = node.Value; - } - } - } - return ret; - } - - static BlobSignedIdentifier BlobSignedIdentifierFromXml(XmlReader& reader) - { - BlobSignedIdentifier ret; - enum class XmlTagName - { - k_Id, - k_AccessPolicy, - k_Start, - k_Expiry, - k_Permission, - k_Unknown, - }; - std::vector path; - while (true) - { - auto node = reader.Read(); - if (node.Type == XmlNodeType::End) - { - break; - } - else if (node.Type == XmlNodeType::EndTag) - { - if (path.size() > 0) - { - path.pop_back(); - } - else - { - break; - } - } - else if (node.Type == XmlNodeType::StartTag) - { - if (std::strcmp(node.Name, "Id") == 0) - { - path.emplace_back(XmlTagName::k_Id); - } - else if (std::strcmp(node.Name, "AccessPolicy") == 0) - { - path.emplace_back(XmlTagName::k_AccessPolicy); - } - else if (std::strcmp(node.Name, "Start") == 0) - { - path.emplace_back(XmlTagName::k_Start); - } - else if (std::strcmp(node.Name, "Expiry") == 0) - { - path.emplace_back(XmlTagName::k_Expiry); - } - else if (std::strcmp(node.Name, "Permission") == 0) - { - path.emplace_back(XmlTagName::k_Permission); - } - else - { - path.emplace_back(XmlTagName::k_Unknown); - } - } - else if (node.Type == XmlNodeType::Text) - { - if (path.size() == 1 && path[0] == XmlTagName::k_Id) - { - ret.Id = node.Value; - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_AccessPolicy - && path[1] == XmlTagName::k_Start) - { - ret.StartsOn = node.Value; - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_AccessPolicy - && path[1] == XmlTagName::k_Expiry) - { - ret.ExpiresOn = node.Value; - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_AccessPolicy - && path[1] == XmlTagName::k_Permission) - { - ret.Permissions = node.Value; - } - } - } - return ret; - } - - static std::map MetadataFromXml(XmlReader& reader) - { - std::map ret; - int depth = 0; - std::string key; - while (true) - { - auto node = reader.Read(); - if (node.Type == XmlNodeType::End) - { - break; - } - else if (node.Type == XmlNodeType::StartTag) - { - if (depth++ == 0) - { - key = node.Name; - } - } - else if (node.Type == XmlNodeType::EndTag) - { - if (depth-- == 0) - { - break; - } - } - else if (depth == 1 && node.Type == XmlNodeType::Text) - { - ret.emplace(std::move(key), std::string(node.Value)); - } - } - return ret; - } - - static std::vector ObjectReplicationSourcePropertiesFromXml( - XmlReader& reader) - { - int depth = 0; - std::map> orPropertiesMap; - std::string policyId; - std::string ruleId; - while (true) - { - auto node = reader.Read(); - if (node.Type == XmlNodeType::End) - { - break; - } - else if (node.Type == XmlNodeType::StartTag) - { - ++depth; - std::string startTagName = node.Name; - if (startTagName.substr(0, 3) == "or-") - { - auto underscorePos = startTagName.find('_', 3); - policyId - = std::string(startTagName.begin() + 3, startTagName.begin() + underscorePos); - ruleId = startTagName.substr(underscorePos + 1); - } - } - else if (node.Type == XmlNodeType::EndTag) - { - if (depth-- == 0) - { - break; - } - } - if (depth == 1 && node.Type == XmlNodeType::Text) - { - ObjectReplicationRule rule; - rule.RuleId = std::move(ruleId); - rule.ReplicationStatus = ObjectReplicationStatusFromString(node.Value); - orPropertiesMap[policyId].emplace_back(std::move(rule)); - } - } - std::vector ret; - for (auto& property : orPropertiesMap) - { - ObjectReplicationPolicy policy; - policy.PolicyId = property.first; - policy.Rules = std::move(property.second); - ret.emplace_back(std::move(policy)); - } - return ret; - } - - static void SetContainerAccessPolicyOptionsToXml( - XmlWriter& writer, - const SetContainerAccessPolicyOptions& options) - { - writer.Write(XmlNode{XmlNodeType::StartTag, "SignedIdentifiers"}); - for (const auto& i : options.SignedIdentifiers) - { - BlobSignedIdentifierToXml(writer, i); - } - writer.Write(XmlNode{XmlNodeType::EndTag}); - } - - static void BlobSignedIdentifierToXml(XmlWriter& writer, const BlobSignedIdentifier& options) - { - writer.Write(XmlNode{XmlNodeType::StartTag, "SignedIdentifier"}); - writer.Write(XmlNode{XmlNodeType::StartTag, "Id"}); - writer.Write(XmlNode{XmlNodeType::Text, nullptr, options.Id.data()}); - writer.Write(XmlNode{XmlNodeType::EndTag}); - writer.Write(XmlNode{XmlNodeType::StartTag, "AccessPolicy"}); - writer.Write(XmlNode{XmlNodeType::StartTag, "Start"}); - writer.Write(XmlNode{XmlNodeType::Text, nullptr, options.StartsOn.data()}); - writer.Write(XmlNode{XmlNodeType::EndTag}); - writer.Write(XmlNode{XmlNodeType::StartTag, "Expiry"}); - writer.Write(XmlNode{XmlNodeType::Text, nullptr, options.ExpiresOn.data()}); - writer.Write(XmlNode{XmlNodeType::EndTag}); - writer.Write(XmlNode{XmlNodeType::StartTag, "Permission"}); - writer.Write(XmlNode{XmlNodeType::Text, nullptr, options.Permissions.data()}); - writer.Write(XmlNode{XmlNodeType::EndTag}); - writer.Write(XmlNode{XmlNodeType::EndTag}); - writer.Write(XmlNode{XmlNodeType::EndTag}); - } - - }; // class Container - - class Blob { - public: - struct DownloadBlobOptions - { - Azure::Core::Nullable Timeout; - Azure::Core::Nullable> Range; - Azure::Core::Nullable EncryptionKey; - Azure::Core::Nullable EncryptionKeySha256; - Azure::Core::Nullable EncryptionAlgorithm; - Azure::Core::Nullable LeaseId; - Azure::Core::Nullable IfModifiedSince; - Azure::Core::Nullable IfUnmodifiedSince; - Azure::Core::Nullable IfMatch; - Azure::Core::Nullable IfNoneMatch; - Azure::Core::Nullable IfTags; - }; // struct DownloadBlobOptions - - static Azure::Core::Response Download( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const DownloadBlobOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url, true); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - if (options.Range.HasValue()) - { - auto startOffset = options.Range.GetValue().first; - auto endOffset = options.Range.GetValue().second; - if (endOffset != std::numeric_limits::max()) + metadataKeys.clear(); + if (options.AccessType.HasValue()) { request.AddHeader( - "x-ms-range", - "bytes=" + std::to_string(startOffset) + "-" + std::to_string(endOffset)); + "x-ms-blob-public-access", PublicAccessTypeToString(options.AccessType.GetValue())); } - else + if (options.DefaultEncryptionScope.HasValue()) { - request.AddHeader("x-ms-range", "bytes=" + std::to_string(startOffset) + "-"); + request.AddHeader( + "x-ms-default-encryption-scope", options.DefaultEncryptionScope.GetValue()); } + if (options.PreventEncryptionScopeOverride.HasValue()) + { + request.AddHeader( + "x-ms-deny-encryption-scope-override", + options.PreventEncryptionScopeOverride.GetValue() ? "true" : "false"); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + CreateContainerResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 201)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + response.ETag = httpResponse.GetHeaders().at("etag"); + response.LastModified = httpResponse.GetHeaders().at("last-modified"); + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); } - if (options.EncryptionKey.HasValue()) + + struct DeleteContainerOptions { - request.AddHeader("x-ms-encryption-key", options.EncryptionKey.GetValue()); + Azure::Core::Nullable Timeout; + Azure::Core::Nullable LeaseId; + Azure::Core::Nullable IfModifiedSince; + Azure::Core::Nullable IfUnmodifiedSince; + }; // struct DeleteContainerOptions + + static Azure::Core::Response Delete( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const DeleteContainerOptions& options) + { + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Delete, url); + request.GetUrl().AppendQueryParameter("restype", "container"); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + if (options.LeaseId.HasValue()) + { + request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); + } + if (options.IfModifiedSince.HasValue()) + { + request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); + } + if (options.IfUnmodifiedSince.HasValue()) + { + request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + DeleteContainerResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 202)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); } - if (options.EncryptionKeySha256.HasValue()) + + struct UndeleteContainerOptions { - request.AddHeader("x-ms-encryption-key-sha256", options.EncryptionKeySha256.GetValue()); + Azure::Core::Nullable Timeout; + std::string DeletedContainerName; + std::string DeletedContainerVersion; + }; // struct UndeleteContainerOptions + + static Azure::Core::Response Undelete( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const UndeleteContainerOptions& options) + { + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); + request.AddHeader("Content-Length", "0"); + request.GetUrl().AppendQueryParameter("restype", "container"); + request.GetUrl().AppendQueryParameter("comp", "undelete"); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + request.AddHeader("x-ms-deleted-container-name", options.DeletedContainerName); + request.AddHeader("x-ms-deleted-container-version", options.DeletedContainerVersion); + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + UndeleteContainerResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 201)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); } - if (options.EncryptionAlgorithm.HasValue()) + + struct GetContainerPropertiesOptions { + Azure::Core::Nullable Timeout; + Azure::Core::Nullable LeaseId; + }; // struct GetContainerPropertiesOptions + + static Azure::Core::Response GetProperties( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const GetContainerPropertiesOptions& options) + { + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Head, url); + request.GetUrl().AppendQueryParameter("restype", "container"); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + if (options.LeaseId.HasValue()) + { + request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + GetContainerPropertiesResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 200)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + response.ETag = httpResponse.GetHeaders().at("etag"); + response.LastModified = httpResponse.GetHeaders().at("last-modified"); + for (auto i = httpResponse.GetHeaders().lower_bound("x-ms-meta-"); + i != httpResponse.GetHeaders().end() && i->first.substr(0, 10) == "x-ms-meta-"; + ++i) + { + response.Metadata.emplace(i->first.substr(10), i->second); + } + auto response_access_type_iterator + = httpResponse.GetHeaders().find("x-ms-blob-public-access"); + if (response_access_type_iterator != httpResponse.GetHeaders().end()) + { + response.AccessType = PublicAccessTypeFromString(response_access_type_iterator->second); + } + response.HasImmutabilityPolicy + = httpResponse.GetHeaders().at("x-ms-has-immutability-policy") == "true"; + response.HasLegalHold = httpResponse.GetHeaders().at("x-ms-has-legal-hold") == "true"; + response.LeaseStatus + = BlobLeaseStatusFromString(httpResponse.GetHeaders().at("x-ms-lease-status")); + response.LeaseState + = BlobLeaseStateFromString(httpResponse.GetHeaders().at("x-ms-lease-state")); + auto response_lease_duration_iterator + = httpResponse.GetHeaders().find("x-ms-lease-duration"); + if (response_lease_duration_iterator != httpResponse.GetHeaders().end()) + { + response.LeaseDuration = response_lease_duration_iterator->second; + } + response.DefaultEncryptionScope + = httpResponse.GetHeaders().at("x-ms-default-encryption-scope"); + response.PreventEncryptionScopeOverride + = httpResponse.GetHeaders().at("x-ms-deny-encryption-scope-override") == "true"; + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); + } + + struct SetContainerMetadataOptions + { + Azure::Core::Nullable Timeout; + std::map Metadata; + Azure::Core::Nullable LeaseId; + Azure::Core::Nullable IfModifiedSince; + }; // struct SetContainerMetadataOptions + + static Azure::Core::Response SetMetadata( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const SetContainerMetadataOptions& options) + { + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); + request.AddHeader("Content-Length", "0"); + request.GetUrl().AppendQueryParameter("restype", "container"); + request.GetUrl().AppendQueryParameter("comp", "metadata"); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + std::set metadataKeys; + for (const auto& pair : options.Metadata) + { + if (metadataKeys.insert(Azure::Core::Strings::ToLower(pair.first)).second == false) + { + throw std::runtime_error("duplicate keys in metadata"); + } + request.AddHeader("x-ms-meta-" + pair.first, pair.second); + } + metadataKeys.clear(); + if (options.LeaseId.HasValue()) + { + request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); + } + if (options.IfModifiedSince.HasValue()) + { + request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + SetContainerMetadataResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 200)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + response.ETag = httpResponse.GetHeaders().at("etag"); + response.LastModified = httpResponse.GetHeaders().at("last-modified"); + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); + } + + struct ListBlobsFlatSegmentOptions + { + Azure::Core::Nullable Timeout; + Azure::Core::Nullable Prefix; + Azure::Core::Nullable ContinuationToken; + Azure::Core::Nullable MaxResults; + ListBlobsIncludeItem Include = ListBlobsIncludeItem::None; + }; // struct ListBlobsFlatSegmentOptions + + static Azure::Core::Response ListBlobsFlat( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const ListBlobsFlatSegmentOptions& options) + { + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + request.GetUrl().AppendQueryParameter("restype", "container"); + request.GetUrl().AppendQueryParameter("comp", "list"); + if (options.Prefix.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "prefix", Storage::Details::UrlEncodeQueryParameter(options.Prefix.GetValue())); + } + if (options.ContinuationToken.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "marker", + Storage::Details::UrlEncodeQueryParameter(options.ContinuationToken.GetValue())); + } + if (options.MaxResults.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "maxresults", std::to_string(options.MaxResults.GetValue())); + } + std::string list_blobs_include_item = ListBlobsIncludeItemToString(options.Include); + if (!list_blobs_include_item.empty()) + { + request.GetUrl().AppendQueryParameter( + "include", Storage::Details::UrlEncodeQueryParameter(list_blobs_include_item)); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + ListBlobsFlatSegmentResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 200)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + { + const auto& httpResponseBody = httpResponse.GetBody(); + XmlReader reader( + reinterpret_cast(httpResponseBody.data()), httpResponseBody.size()); + response = ListBlobsFlatSegmentResultFromXml(reader); + } + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); + } + + struct ListBlobsByHierarchySegmentOptions + { + Azure::Core::Nullable Timeout; + Azure::Core::Nullable Prefix; + Azure::Core::Nullable Delimiter; + Azure::Core::Nullable ContinuationToken; + Azure::Core::Nullable MaxResults; + ListBlobsIncludeItem Include = ListBlobsIncludeItem::None; + }; // struct ListBlobsByHierarchySegmentOptions + + static Azure::Core::Response ListBlobsByHierarchy( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const ListBlobsByHierarchySegmentOptions& options) + { + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + request.GetUrl().AppendQueryParameter("restype", "container"); + request.GetUrl().AppendQueryParameter("comp", "list"); + if (options.Prefix.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "prefix", Storage::Details::UrlEncodeQueryParameter(options.Prefix.GetValue())); + } + if (options.Delimiter.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "delimiter", + Storage::Details::UrlEncodeQueryParameter(options.Delimiter.GetValue())); + } + if (options.ContinuationToken.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "marker", + Storage::Details::UrlEncodeQueryParameter(options.ContinuationToken.GetValue())); + } + if (options.MaxResults.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "maxresults", std::to_string(options.MaxResults.GetValue())); + } + std::string list_blobs_include_item = ListBlobsIncludeItemToString(options.Include); + if (!list_blobs_include_item.empty()) + { + request.GetUrl().AppendQueryParameter( + "include", Storage::Details::UrlEncodeQueryParameter(list_blobs_include_item)); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + ListBlobsByHierarchySegmentResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 200)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + { + const auto& httpResponseBody = httpResponse.GetBody(); + XmlReader reader( + reinterpret_cast(httpResponseBody.data()), httpResponseBody.size()); + response = ListBlobsByHierarchySegmentResultFromXml(reader); + } + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); + } + + struct GetContainerAccessPolicyOptions + { + Azure::Core::Nullable Timeout; + Azure::Core::Nullable LeaseId; + }; // struct GetContainerAccessPolicyOptions + + static Azure::Core::Response GetAccessPolicy( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const GetContainerAccessPolicyOptions& options) + { + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + request.GetUrl().AppendQueryParameter("restype", "container"); + request.GetUrl().AppendQueryParameter("comp", "acl"); + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + GetContainerAccessPolicyResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 200)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + { + const auto& httpResponseBody = httpResponse.GetBody(); + XmlReader reader( + reinterpret_cast(httpResponseBody.data()), httpResponseBody.size()); + response = GetContainerAccessPolicyResultFromXml(reader); + } + response.ETag = httpResponse.GetHeaders().at("etag"); + response.LastModified = httpResponse.GetHeaders().at("last-modified"); + response.AccessType + = PublicAccessTypeFromString(httpResponse.GetHeaders().at("x-ms-blob-public-access")); + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); + } + + struct SetContainerAccessPolicyOptions + { + Azure::Core::Nullable Timeout; + Azure::Core::Nullable AccessType; + Azure::Core::Nullable LeaseId; + Azure::Core::Nullable IfModifiedSince; + Azure::Core::Nullable IfUnmodifiedSince; + std::vector SignedIdentifiers; + }; // struct SetContainerAccessPolicyOptions + + static Azure::Core::Response SetAccessPolicy( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const SetContainerAccessPolicyOptions& options) + { + unused(options); + std::string xml_body; + { + XmlWriter writer; + SetContainerAccessPolicyOptionsToXml(writer, options); + xml_body = writer.GetDocument(); + writer.Write(XmlNode{XmlNodeType::End}); + } + Azure::Core::Http::MemoryBodyStream xml_body_stream( + reinterpret_cast(xml_body.data()), xml_body.length()); + auto request = Azure::Core::Http::Request( + Azure::Core::Http::HttpMethod::Put, url, &xml_body_stream); + request.AddHeader("Content-Length", std::to_string(xml_body_stream.Length())); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + request.GetUrl().AppendQueryParameter("restype", "container"); + request.GetUrl().AppendQueryParameter("comp", "acl"); + if (options.AccessType.HasValue()) + { + request.AddHeader( + "x-ms-blob-public-access", PublicAccessTypeToString(options.AccessType.GetValue())); + } + if (options.LeaseId.HasValue()) + { + request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); + } + if (options.IfModifiedSince.HasValue()) + { + request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); + } + if (options.IfUnmodifiedSince.HasValue()) + { + request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + SetContainerAccessPolicyResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 200)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + response.ETag = httpResponse.GetHeaders().at("etag"); + response.LastModified = httpResponse.GetHeaders().at("last-modified"); + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); + } + + struct AcquireContainerLeaseOptions + { + Azure::Core::Nullable Timeout; + int32_t LeaseDuration = -1; + Azure::Core::Nullable ProposedLeaseId; + Azure::Core::Nullable IfModifiedSince; + Azure::Core::Nullable IfUnmodifiedSince; + }; // struct AcquireContainerLeaseOptions + + static Azure::Core::Response AcquireLease( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const AcquireContainerLeaseOptions& options) + { + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); + request.AddHeader("Content-Length", "0"); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + request.GetUrl().AppendQueryParameter("restype", "container"); + request.GetUrl().AppendQueryParameter("comp", "lease"); + request.AddHeader("x-ms-lease-action", "acquire"); + request.AddHeader("x-ms-lease-duration", std::to_string(options.LeaseDuration)); + if (options.ProposedLeaseId.HasValue()) + { + request.AddHeader("x-ms-proposed-lease-id", options.ProposedLeaseId.GetValue()); + } + if (options.IfModifiedSince.HasValue()) + { + request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); + } + if (options.IfUnmodifiedSince.HasValue()) + { + request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + AcquireContainerLeaseResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 201)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + response.ETag = httpResponse.GetHeaders().at("etag"); + response.LastModified = httpResponse.GetHeaders().at("last-modified"); + response.LeaseId = httpResponse.GetHeaders().at("x-ms-lease-id"); + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); + } + + struct RenewContainerLeaseOptions + { + Azure::Core::Nullable Timeout; + std::string LeaseId; + Azure::Core::Nullable IfModifiedSince; + Azure::Core::Nullable IfUnmodifiedSince; + }; // struct RenewContainerLeaseOptions + + static Azure::Core::Response RenewLease( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const RenewContainerLeaseOptions& options) + { + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); + request.AddHeader("Content-Length", "0"); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + request.GetUrl().AppendQueryParameter("restype", "container"); + request.GetUrl().AppendQueryParameter("comp", "lease"); + request.AddHeader("x-ms-lease-action", "renew"); + request.AddHeader("x-ms-lease-id", options.LeaseId); + if (options.IfModifiedSince.HasValue()) + { + request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); + } + if (options.IfUnmodifiedSince.HasValue()) + { + request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + RenewContainerLeaseResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 200)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + response.ETag = httpResponse.GetHeaders().at("etag"); + response.LastModified = httpResponse.GetHeaders().at("last-modified"); + response.LeaseId = httpResponse.GetHeaders().at("x-ms-lease-id"); + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); + } + + struct ChangeContainerLeaseOptions + { + Azure::Core::Nullable Timeout; + std::string LeaseId; + std::string ProposedLeaseId; + Azure::Core::Nullable IfModifiedSince; + Azure::Core::Nullable IfUnmodifiedSince; + }; // struct ChangeContainerLeaseOptions + + static Azure::Core::Response ChangeLease( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const ChangeContainerLeaseOptions& options) + { + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); + request.AddHeader("Content-Length", "0"); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + request.GetUrl().AppendQueryParameter("restype", "container"); + request.GetUrl().AppendQueryParameter("comp", "lease"); + request.AddHeader("x-ms-lease-action", "change"); + request.AddHeader("x-ms-lease-id", options.LeaseId); + request.AddHeader("x-ms-proposed-lease-id", options.ProposedLeaseId); + if (options.IfModifiedSince.HasValue()) + { + request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); + } + if (options.IfUnmodifiedSince.HasValue()) + { + request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + ChangeContainerLeaseResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 200)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + response.ETag = httpResponse.GetHeaders().at("etag"); + response.LastModified = httpResponse.GetHeaders().at("last-modified"); + response.LeaseId = httpResponse.GetHeaders().at("x-ms-lease-id"); + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); + } + + struct ReleaseContainerLeaseOptions + { + Azure::Core::Nullable Timeout; + std::string LeaseId; + Azure::Core::Nullable IfModifiedSince; + Azure::Core::Nullable IfUnmodifiedSince; + }; // struct ReleaseContainerLeaseOptions + + static Azure::Core::Response ReleaseLease( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const ReleaseContainerLeaseOptions& options) + { + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); + request.AddHeader("Content-Length", "0"); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + request.GetUrl().AppendQueryParameter("restype", "container"); + request.GetUrl().AppendQueryParameter("comp", "lease"); + request.AddHeader("x-ms-lease-action", "release"); + request.AddHeader("x-ms-lease-id", options.LeaseId); + if (options.IfModifiedSince.HasValue()) + { + request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); + } + if (options.IfUnmodifiedSince.HasValue()) + { + request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + ReleaseContainerLeaseResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 200)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + response.ETag = httpResponse.GetHeaders().at("etag"); + response.LastModified = httpResponse.GetHeaders().at("last-modified"); + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); + } + + struct BreakContainerLeaseOptions + { + Azure::Core::Nullable Timeout; + Azure::Core::Nullable BreakPeriod; + Azure::Core::Nullable IfModifiedSince; + Azure::Core::Nullable IfUnmodifiedSince; + }; // struct BreakContainerLeaseOptions + + static Azure::Core::Response BreakLease( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const BreakContainerLeaseOptions& options) + { + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); + request.AddHeader("Content-Length", "0"); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + request.GetUrl().AppendQueryParameter("restype", "container"); + request.GetUrl().AppendQueryParameter("comp", "lease"); + request.AddHeader("x-ms-lease-action", "break"); + if (options.BreakPeriod.HasValue()) + { + request.AddHeader( + "x-ms-lease-break-period", std::to_string(options.BreakPeriod.GetValue())); + } + if (options.IfModifiedSince.HasValue()) + { + request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); + } + if (options.IfUnmodifiedSince.HasValue()) + { + request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + BreakContainerLeaseResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 202)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + response.ETag = httpResponse.GetHeaders().at("etag"); + response.LastModified = httpResponse.GetHeaders().at("last-modified"); + response.LeaseTime = std::stoi(httpResponse.GetHeaders().at("x-ms-lease-time")); + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); + } + + private: + static GetContainerAccessPolicyResult GetContainerAccessPolicyResultFromXml( + XmlReader& reader) + { + GetContainerAccessPolicyResult ret; + enum class XmlTagName + { + k_SignedIdentifiers, + k_SignedIdentifier, + k_Unknown, + }; + std::vector path; + while (true) + { + auto node = reader.Read(); + if (node.Type == XmlNodeType::End) + { + break; + } + else if (node.Type == XmlNodeType::EndTag) + { + if (path.size() > 0) + { + path.pop_back(); + } + else + { + break; + } + } + else if (node.Type == XmlNodeType::StartTag) + { + if (std::strcmp(node.Name, "SignedIdentifiers") == 0) + { + path.emplace_back(XmlTagName::k_SignedIdentifiers); + } + else if (std::strcmp(node.Name, "SignedIdentifier") == 0) + { + path.emplace_back(XmlTagName::k_SignedIdentifier); + } + else + { + path.emplace_back(XmlTagName::k_Unknown); + } + if (path.size() == 2 && path[0] == XmlTagName::k_SignedIdentifiers + && path[1] == XmlTagName::k_SignedIdentifier) + { + ret.SignedIdentifiers.emplace_back(BlobSignedIdentifierFromXml(reader)); + path.pop_back(); + } + } + else if (node.Type == XmlNodeType::Text) + { + } + } + return ret; + } + + static ListBlobsByHierarchySegmentResult ListBlobsByHierarchySegmentResultFromXml( + XmlReader& reader) + { + ListBlobsByHierarchySegmentResult ret; + enum class XmlTagName + { + k_EnumerationResults, + k_Prefix, + k_Delimiter, + k_Marker, + k_NextMarker, + k_Blobs, + k_Blob, + k_BlobPrefix, + k_Unknown, + }; + std::vector path; + while (true) + { + auto node = reader.Read(); + if (node.Type == XmlNodeType::End) + { + break; + } + else if (node.Type == XmlNodeType::EndTag) + { + if (path.size() > 0) + { + path.pop_back(); + } + else + { + break; + } + } + else if (node.Type == XmlNodeType::StartTag) + { + if (std::strcmp(node.Name, "EnumerationResults") == 0) + { + path.emplace_back(XmlTagName::k_EnumerationResults); + } + else if (std::strcmp(node.Name, "Prefix") == 0) + { + path.emplace_back(XmlTagName::k_Prefix); + } + else if (std::strcmp(node.Name, "Delimiter") == 0) + { + path.emplace_back(XmlTagName::k_Delimiter); + } + else if (std::strcmp(node.Name, "Marker") == 0) + { + path.emplace_back(XmlTagName::k_Marker); + } + else if (std::strcmp(node.Name, "NextMarker") == 0) + { + path.emplace_back(XmlTagName::k_NextMarker); + } + else if (std::strcmp(node.Name, "Blobs") == 0) + { + path.emplace_back(XmlTagName::k_Blobs); + } + else if (std::strcmp(node.Name, "Blob") == 0) + { + path.emplace_back(XmlTagName::k_Blob); + } + else if (std::strcmp(node.Name, "BlobPrefix") == 0) + { + path.emplace_back(XmlTagName::k_BlobPrefix); + } + else + { + path.emplace_back(XmlTagName::k_Unknown); + } + if (path.size() == 3 && path[0] == XmlTagName::k_EnumerationResults + && path[1] == XmlTagName::k_Blobs && path[2] == XmlTagName::k_Blob) + { + ret.Items.emplace_back(BlobItemFromXml(reader)); + path.pop_back(); + } + else if ( + path.size() == 3 && path[0] == XmlTagName::k_EnumerationResults + && path[1] == XmlTagName::k_Blobs && path[2] == XmlTagName::k_BlobPrefix) + { + ret.BlobPrefixes.emplace_back(BlobPrefixFromXml(reader)); + path.pop_back(); + } + } + else if (node.Type == XmlNodeType::Text) + { + if (path.size() == 2 && path[0] == XmlTagName::k_EnumerationResults + && path[1] == XmlTagName::k_Prefix) + { + ret.Prefix = node.Value; + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_EnumerationResults + && path[1] == XmlTagName::k_Delimiter) + { + ret.Delimiter = node.Value; + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_EnumerationResults + && path[1] == XmlTagName::k_Marker) + { + ret.PreviousContinuationToken = node.Value; + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_EnumerationResults + && path[1] == XmlTagName::k_NextMarker) + { + ret.ContinuationToken = node.Value; + } + } + else if (node.Type == XmlNodeType::Attribute) + { + if (path.size() == 1 && path[0] == XmlTagName::k_EnumerationResults + && std::strcmp(node.Name, "ServiceEndpoint") == 0) + { + ret.ServiceEndpoint = node.Value; + } + else if ( + path.size() == 1 && path[0] == XmlTagName::k_EnumerationResults + && std::strcmp(node.Name, "ContainerName") == 0) + { + ret.Container = node.Value; + } + } + } + return ret; + } + + static ListBlobsFlatSegmentResult ListBlobsFlatSegmentResultFromXml(XmlReader& reader) + { + ListBlobsFlatSegmentResult ret; + enum class XmlTagName + { + k_EnumerationResults, + k_Prefix, + k_Marker, + k_NextMarker, + k_Blobs, + k_Blob, + k_Unknown, + }; + std::vector path; + while (true) + { + auto node = reader.Read(); + if (node.Type == XmlNodeType::End) + { + break; + } + else if (node.Type == XmlNodeType::EndTag) + { + if (path.size() > 0) + { + path.pop_back(); + } + else + { + break; + } + } + else if (node.Type == XmlNodeType::StartTag) + { + if (std::strcmp(node.Name, "EnumerationResults") == 0) + { + path.emplace_back(XmlTagName::k_EnumerationResults); + } + else if (std::strcmp(node.Name, "Prefix") == 0) + { + path.emplace_back(XmlTagName::k_Prefix); + } + else if (std::strcmp(node.Name, "Marker") == 0) + { + path.emplace_back(XmlTagName::k_Marker); + } + else if (std::strcmp(node.Name, "NextMarker") == 0) + { + path.emplace_back(XmlTagName::k_NextMarker); + } + else if (std::strcmp(node.Name, "Blobs") == 0) + { + path.emplace_back(XmlTagName::k_Blobs); + } + else if (std::strcmp(node.Name, "Blob") == 0) + { + path.emplace_back(XmlTagName::k_Blob); + } + else + { + path.emplace_back(XmlTagName::k_Unknown); + } + if (path.size() == 3 && path[0] == XmlTagName::k_EnumerationResults + && path[1] == XmlTagName::k_Blobs && path[2] == XmlTagName::k_Blob) + { + ret.Items.emplace_back(BlobItemFromXml(reader)); + path.pop_back(); + } + } + else if (node.Type == XmlNodeType::Text) + { + if (path.size() == 2 && path[0] == XmlTagName::k_EnumerationResults + && path[1] == XmlTagName::k_Prefix) + { + ret.Prefix = node.Value; + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_EnumerationResults + && path[1] == XmlTagName::k_Marker) + { + ret.PreviousContinuationToken = node.Value; + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_EnumerationResults + && path[1] == XmlTagName::k_NextMarker) + { + ret.ContinuationToken = node.Value; + } + } + else if (node.Type == XmlNodeType::Attribute) + { + if (path.size() == 1 && path[0] == XmlTagName::k_EnumerationResults + && std::strcmp(node.Name, "ServiceEndpoint") == 0) + { + ret.ServiceEndpoint = node.Value; + } + else if ( + path.size() == 1 && path[0] == XmlTagName::k_EnumerationResults + && std::strcmp(node.Name, "ContainerName") == 0) + { + ret.Container = node.Value; + } + } + } + return ret; + } + + static BlobItem BlobItemFromXml(XmlReader& reader) + { + BlobItem ret; + enum class XmlTagName + { + k_Name, + k_Deleted, + k_Snapshot, + k_VersionId, + k_IsCurrentVersion, + k_Properties, + k_ContentType, + k_ContentEncoding, + k_ContentLanguage, + k_ContentMD5, + k_CacheControl, + k_ContentDisposition, + k_CreationTime, + k_ExpiryTime, + k_LastAccessTime, + k_LastModified, + k_Etag, + k_ContentLength, + k_BlobType, + k_AccessTier, + k_AccessTierInferred, + k_LeaseStatus, + k_LeaseState, + k_LeaseDuration, + k_ServerEncrypted, + k_EncryptionKeySHA256, + k_Sealed, + k_xmsblobsequencenumber, + k_Metadata, + k_OrMetadata, + k_Unknown, + }; + std::vector path; + while (true) + { + auto node = reader.Read(); + if (node.Type == XmlNodeType::End) + { + break; + } + else if (node.Type == XmlNodeType::EndTag) + { + if (path.size() > 0) + { + path.pop_back(); + } + else + { + break; + } + } + else if (node.Type == XmlNodeType::StartTag) + { + if (std::strcmp(node.Name, "Name") == 0) + { + path.emplace_back(XmlTagName::k_Name); + } + else if (std::strcmp(node.Name, "Deleted") == 0) + { + path.emplace_back(XmlTagName::k_Deleted); + } + else if (std::strcmp(node.Name, "Snapshot") == 0) + { + path.emplace_back(XmlTagName::k_Snapshot); + } + else if (std::strcmp(node.Name, "VersionId") == 0) + { + path.emplace_back(XmlTagName::k_VersionId); + } + else if (std::strcmp(node.Name, "IsCurrentVersion") == 0) + { + path.emplace_back(XmlTagName::k_IsCurrentVersion); + } + else if (std::strcmp(node.Name, "Properties") == 0) + { + path.emplace_back(XmlTagName::k_Properties); + } + else if (std::strcmp(node.Name, "Content-Type") == 0) + { + path.emplace_back(XmlTagName::k_ContentType); + } + else if (std::strcmp(node.Name, "Content-Encoding") == 0) + { + path.emplace_back(XmlTagName::k_ContentEncoding); + } + else if (std::strcmp(node.Name, "Content-Language") == 0) + { + path.emplace_back(XmlTagName::k_ContentLanguage); + } + else if (std::strcmp(node.Name, "Content-MD5") == 0) + { + path.emplace_back(XmlTagName::k_ContentMD5); + } + else if (std::strcmp(node.Name, "Cache-Control") == 0) + { + path.emplace_back(XmlTagName::k_CacheControl); + } + else if (std::strcmp(node.Name, "Content-Disposition") == 0) + { + path.emplace_back(XmlTagName::k_ContentDisposition); + } + else if (std::strcmp(node.Name, "Creation-Time") == 0) + { + path.emplace_back(XmlTagName::k_CreationTime); + } + else if (std::strcmp(node.Name, "Expiry-Time") == 0) + { + path.emplace_back(XmlTagName::k_ExpiryTime); + } + else if (std::strcmp(node.Name, "LastAccessTime") == 0) + { + path.emplace_back(XmlTagName::k_LastAccessTime); + } + else if (std::strcmp(node.Name, "Last-Modified") == 0) + { + path.emplace_back(XmlTagName::k_LastModified); + } + else if (std::strcmp(node.Name, "Etag") == 0) + { + path.emplace_back(XmlTagName::k_Etag); + } + else if (std::strcmp(node.Name, "Content-Length") == 0) + { + path.emplace_back(XmlTagName::k_ContentLength); + } + else if (std::strcmp(node.Name, "BlobType") == 0) + { + path.emplace_back(XmlTagName::k_BlobType); + } + else if (std::strcmp(node.Name, "AccessTier") == 0) + { + path.emplace_back(XmlTagName::k_AccessTier); + } + else if (std::strcmp(node.Name, "AccessTierInferred") == 0) + { + path.emplace_back(XmlTagName::k_AccessTierInferred); + } + else if (std::strcmp(node.Name, "LeaseStatus") == 0) + { + path.emplace_back(XmlTagName::k_LeaseStatus); + } + else if (std::strcmp(node.Name, "LeaseState") == 0) + { + path.emplace_back(XmlTagName::k_LeaseState); + } + else if (std::strcmp(node.Name, "LeaseDuration") == 0) + { + path.emplace_back(XmlTagName::k_LeaseDuration); + } + else if (std::strcmp(node.Name, "ServerEncrypted") == 0) + { + path.emplace_back(XmlTagName::k_ServerEncrypted); + } + else if (std::strcmp(node.Name, "EncryptionKeySHA256") == 0) + { + path.emplace_back(XmlTagName::k_EncryptionKeySHA256); + } + else if (std::strcmp(node.Name, "Sealed") == 0) + { + path.emplace_back(XmlTagName::k_Sealed); + } + else if (std::strcmp(node.Name, "x-ms-blob-sequence-number") == 0) + { + path.emplace_back(XmlTagName::k_xmsblobsequencenumber); + } + else if (std::strcmp(node.Name, "Metadata") == 0) + { + path.emplace_back(XmlTagName::k_Metadata); + } + else if (std::strcmp(node.Name, "OrMetadata") == 0) + { + path.emplace_back(XmlTagName::k_OrMetadata); + } + else + { + path.emplace_back(XmlTagName::k_Unknown); + } + if (path.size() == 1 && path[0] == XmlTagName::k_Metadata) + { + ret.Metadata = MetadataFromXml(reader); + path.pop_back(); + } + else if (path.size() == 1 && path[0] == XmlTagName::k_OrMetadata) + { + ret.ObjectReplicationSourceProperties + = ObjectReplicationSourcePropertiesFromXml(reader); + path.pop_back(); + } + } + else if (node.Type == XmlNodeType::Text) + { + if (path.size() == 1 && path[0] == XmlTagName::k_Name) + { + ret.Name = node.Value; + } + else if (path.size() == 1 && path[0] == XmlTagName::k_Deleted) + { + ret.Deleted = std::strcmp(node.Value, "true") == 0; + } + else if (path.size() == 1 && path[0] == XmlTagName::k_Snapshot) + { + ret.Snapshot = node.Value; + } + else if (path.size() == 1 && path[0] == XmlTagName::k_VersionId) + { + ret.VersionId = node.Value; + } + else if (path.size() == 1 && path[0] == XmlTagName::k_IsCurrentVersion) + { + ret.IsCurrentVersion = std::strcmp(node.Value, "true") == 0; + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_Properties + && path[1] == XmlTagName::k_ContentType) + { + ret.HttpHeaders.ContentType = node.Value; + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_Properties + && path[1] == XmlTagName::k_ContentEncoding) + { + ret.HttpHeaders.ContentEncoding = node.Value; + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_Properties + && path[1] == XmlTagName::k_ContentLanguage) + { + ret.HttpHeaders.ContentLanguage = node.Value; + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_Properties + && path[1] == XmlTagName::k_ContentMD5) + { + ret.HttpHeaders.ContentMd5 = node.Value; + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_Properties + && path[1] == XmlTagName::k_CacheControl) + { + ret.HttpHeaders.CacheControl = node.Value; + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_Properties + && path[1] == XmlTagName::k_ContentDisposition) + { + ret.HttpHeaders.ContentDisposition = node.Value; + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_Properties + && path[1] == XmlTagName::k_CreationTime) + { + ret.CreationTime = node.Value; + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_Properties + && path[1] == XmlTagName::k_ExpiryTime) + { + ret.ExpiryTime = node.Value; + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_Properties + && path[1] == XmlTagName::k_LastAccessTime) + { + ret.LastAccessTime = node.Value; + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_Properties + && path[1] == XmlTagName::k_LastModified) + { + ret.LastModified = node.Value; + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_Properties + && path[1] == XmlTagName::k_Etag) + { + ret.ETag = node.Value; + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_Properties + && path[1] == XmlTagName::k_ContentLength) + { + ret.ContentLength = std::stoll(node.Value); + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_Properties + && path[1] == XmlTagName::k_BlobType) + { + ret.BlobType = BlobTypeFromString(node.Value); + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_Properties + && path[1] == XmlTagName::k_AccessTier) + { + ret.Tier = AccessTierFromString(node.Value); + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_Properties + && path[1] == XmlTagName::k_AccessTierInferred) + { + ret.AccessTierInferred = std::strcmp(node.Value, "true") == 0; + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_Properties + && path[1] == XmlTagName::k_LeaseStatus) + { + ret.LeaseStatus = BlobLeaseStatusFromString(node.Value); + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_Properties + && path[1] == XmlTagName::k_LeaseState) + { + ret.LeaseState = BlobLeaseStateFromString(node.Value); + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_Properties + && path[1] == XmlTagName::k_LeaseDuration) + { + ret.LeaseDuration = node.Value; + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_Properties + && path[1] == XmlTagName::k_ServerEncrypted) + { + ret.ServerEncrypted = std::strcmp(node.Value, "true") == 0; + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_Properties + && path[1] == XmlTagName::k_EncryptionKeySHA256) + { + ret.EncryptionKeySha256 = node.Value; + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_Properties + && path[1] == XmlTagName::k_Sealed) + { + ret.IsSealed = std::strcmp(node.Value, "true") == 0; + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_Properties + && path[1] == XmlTagName::k_xmsblobsequencenumber) + { + ret.SequenceNumber = std::stoll(node.Value); + } + } + } + return ret; + } + + static BlobPrefix BlobPrefixFromXml(XmlReader& reader) + { + BlobPrefix ret; + enum class XmlTagName + { + k_Name, + k_Unknown, + }; + std::vector path; + while (true) + { + auto node = reader.Read(); + if (node.Type == XmlNodeType::End) + { + break; + } + else if (node.Type == XmlNodeType::EndTag) + { + if (path.size() > 0) + { + path.pop_back(); + } + else + { + break; + } + } + else if (node.Type == XmlNodeType::StartTag) + { + if (std::strcmp(node.Name, "Name") == 0) + { + path.emplace_back(XmlTagName::k_Name); + } + else + { + path.emplace_back(XmlTagName::k_Unknown); + } + } + else if (node.Type == XmlNodeType::Text) + { + if (path.size() == 1 && path[0] == XmlTagName::k_Name) + { + ret.Name = node.Value; + } + } + } + return ret; + } + + static BlobSignedIdentifier BlobSignedIdentifierFromXml(XmlReader& reader) + { + BlobSignedIdentifier ret; + enum class XmlTagName + { + k_Id, + k_AccessPolicy, + k_Start, + k_Expiry, + k_Permission, + k_Unknown, + }; + std::vector path; + while (true) + { + auto node = reader.Read(); + if (node.Type == XmlNodeType::End) + { + break; + } + else if (node.Type == XmlNodeType::EndTag) + { + if (path.size() > 0) + { + path.pop_back(); + } + else + { + break; + } + } + else if (node.Type == XmlNodeType::StartTag) + { + if (std::strcmp(node.Name, "Id") == 0) + { + path.emplace_back(XmlTagName::k_Id); + } + else if (std::strcmp(node.Name, "AccessPolicy") == 0) + { + path.emplace_back(XmlTagName::k_AccessPolicy); + } + else if (std::strcmp(node.Name, "Start") == 0) + { + path.emplace_back(XmlTagName::k_Start); + } + else if (std::strcmp(node.Name, "Expiry") == 0) + { + path.emplace_back(XmlTagName::k_Expiry); + } + else if (std::strcmp(node.Name, "Permission") == 0) + { + path.emplace_back(XmlTagName::k_Permission); + } + else + { + path.emplace_back(XmlTagName::k_Unknown); + } + } + else if (node.Type == XmlNodeType::Text) + { + if (path.size() == 1 && path[0] == XmlTagName::k_Id) + { + ret.Id = node.Value; + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_AccessPolicy + && path[1] == XmlTagName::k_Start) + { + ret.StartsOn = node.Value; + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_AccessPolicy + && path[1] == XmlTagName::k_Expiry) + { + ret.ExpiresOn = node.Value; + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_AccessPolicy + && path[1] == XmlTagName::k_Permission) + { + ret.Permissions = node.Value; + } + } + } + return ret; + } + + static std::map MetadataFromXml(XmlReader& reader) + { + std::map ret; + int depth = 0; + std::string key; + while (true) + { + auto node = reader.Read(); + if (node.Type == XmlNodeType::End) + { + break; + } + else if (node.Type == XmlNodeType::StartTag) + { + if (depth++ == 0) + { + key = node.Name; + } + } + else if (node.Type == XmlNodeType::EndTag) + { + if (depth-- == 0) + { + break; + } + } + else if (depth == 1 && node.Type == XmlNodeType::Text) + { + ret.emplace(std::move(key), std::string(node.Value)); + } + } + return ret; + } + + static std::vector ObjectReplicationSourcePropertiesFromXml( + XmlReader& reader) + { + int depth = 0; + std::map> orPropertiesMap; + std::string policyId; + std::string ruleId; + while (true) + { + auto node = reader.Read(); + if (node.Type == XmlNodeType::End) + { + break; + } + else if (node.Type == XmlNodeType::StartTag) + { + ++depth; + std::string startTagName = node.Name; + if (startTagName.substr(0, 3) == "or-") + { + auto underscorePos = startTagName.find('_', 3); + policyId + = std::string(startTagName.begin() + 3, startTagName.begin() + underscorePos); + ruleId = startTagName.substr(underscorePos + 1); + } + } + else if (node.Type == XmlNodeType::EndTag) + { + if (depth-- == 0) + { + break; + } + } + if (depth == 1 && node.Type == XmlNodeType::Text) + { + ObjectReplicationRule rule; + rule.RuleId = std::move(ruleId); + rule.ReplicationStatus = ObjectReplicationStatusFromString(node.Value); + orPropertiesMap[policyId].emplace_back(std::move(rule)); + } + } + std::vector ret; + for (auto& property : orPropertiesMap) + { + ObjectReplicationPolicy policy; + policy.PolicyId = property.first; + policy.Rules = std::move(property.second); + ret.emplace_back(std::move(policy)); + } + return ret; + } + + static void SetContainerAccessPolicyOptionsToXml( + XmlWriter& writer, + const SetContainerAccessPolicyOptions& options) + { + writer.Write(XmlNode{XmlNodeType::StartTag, "SignedIdentifiers"}); + for (const auto& i : options.SignedIdentifiers) + { + BlobSignedIdentifierToXml(writer, i); + } + writer.Write(XmlNode{XmlNodeType::EndTag}); + } + + static void BlobSignedIdentifierToXml( + XmlWriter& writer, + const BlobSignedIdentifier& options) + { + writer.Write(XmlNode{XmlNodeType::StartTag, "SignedIdentifier"}); + writer.Write(XmlNode{XmlNodeType::StartTag, "Id"}); + writer.Write(XmlNode{XmlNodeType::Text, nullptr, options.Id.data()}); + writer.Write(XmlNode{XmlNodeType::EndTag}); + writer.Write(XmlNode{XmlNodeType::StartTag, "AccessPolicy"}); + writer.Write(XmlNode{XmlNodeType::StartTag, "Start"}); + writer.Write(XmlNode{XmlNodeType::Text, nullptr, options.StartsOn.data()}); + writer.Write(XmlNode{XmlNodeType::EndTag}); + writer.Write(XmlNode{XmlNodeType::StartTag, "Expiry"}); + writer.Write(XmlNode{XmlNodeType::Text, nullptr, options.ExpiresOn.data()}); + writer.Write(XmlNode{XmlNodeType::EndTag}); + writer.Write(XmlNode{XmlNodeType::StartTag, "Permission"}); + writer.Write(XmlNode{XmlNodeType::Text, nullptr, options.Permissions.data()}); + writer.Write(XmlNode{XmlNodeType::EndTag}); + writer.Write(XmlNode{XmlNodeType::EndTag}); + writer.Write(XmlNode{XmlNodeType::EndTag}); + } + + }; // class Container + + class Blob { + public: + struct DownloadBlobOptions + { + Azure::Core::Nullable Timeout; + Azure::Core::Nullable> Range; + Azure::Core::Nullable EncryptionKey; + Azure::Core::Nullable EncryptionKeySha256; + Azure::Core::Nullable EncryptionAlgorithm; + Azure::Core::Nullable LeaseId; + Azure::Core::Nullable IfModifiedSince; + Azure::Core::Nullable IfUnmodifiedSince; + Azure::Core::Nullable IfMatch; + Azure::Core::Nullable IfNoneMatch; + Azure::Core::Nullable IfTags; + }; // struct DownloadBlobOptions + + static Azure::Core::Response Download( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const DownloadBlobOptions& options) + { + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url, true); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + if (options.Range.HasValue()) + { + auto startOffset = options.Range.GetValue().first; + auto endOffset = options.Range.GetValue().second; + if (endOffset != std::numeric_limits::max()) + { + request.AddHeader( + "x-ms-range", + "bytes=" + std::to_string(startOffset) + "-" + std::to_string(endOffset)); + } + else + { + request.AddHeader("x-ms-range", "bytes=" + std::to_string(startOffset) + "-"); + } + } + if (options.EncryptionKey.HasValue()) + { + request.AddHeader("x-ms-encryption-key", options.EncryptionKey.GetValue()); + } + if (options.EncryptionKeySha256.HasValue()) + { + request.AddHeader("x-ms-encryption-key-sha256", options.EncryptionKeySha256.GetValue()); + } + if (options.EncryptionAlgorithm.HasValue()) + { + request.AddHeader( + "x-ms-encryption-algorithm", + EncryptionAlgorithmTypeToString(options.EncryptionAlgorithm.GetValue())); + } + if (options.IfModifiedSince.HasValue()) + { + request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); + } + if (options.IfUnmodifiedSince.HasValue()) + { + request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); + } + if (options.IfMatch.HasValue()) + { + request.AddHeader("If-Match", options.IfMatch.GetValue()); + } + if (options.IfNoneMatch.HasValue()) + { + request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); + } + if (options.IfTags.HasValue()) + { + request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); + } + if (options.LeaseId.HasValue()) + { + request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + DownloadBlobResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 200 || http_status_code == 206)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + response.BodyStream = httpResponse.GetBodyStream(); + response.ETag = httpResponse.GetHeaders().at("etag"); + response.LastModified = httpResponse.GetHeaders().at("last-modified"); + auto response_transactional_content_md5_iterator + = httpResponse.GetHeaders().find("content-md5"); + if (response_transactional_content_md5_iterator != httpResponse.GetHeaders().end()) + { + response.TransactionalContentMd5 = response_transactional_content_md5_iterator->second; + } + auto response_transactional_content_crc64_iterator + = httpResponse.GetHeaders().find("x-ms-content-crc64"); + if (response_transactional_content_crc64_iterator != httpResponse.GetHeaders().end()) + { + response.TransactionalContentCrc64 + = response_transactional_content_crc64_iterator->second; + } + auto response_http_headers_content_type_iterator + = httpResponse.GetHeaders().find("content-type"); + if (response_http_headers_content_type_iterator != httpResponse.GetHeaders().end()) + { + response.HttpHeaders.ContentType = response_http_headers_content_type_iterator->second; + } + auto response_http_headers_content_encoding_iterator + = httpResponse.GetHeaders().find("content-encoding"); + if (response_http_headers_content_encoding_iterator != httpResponse.GetHeaders().end()) + { + response.HttpHeaders.ContentEncoding + = response_http_headers_content_encoding_iterator->second; + } + auto response_http_headers_content_language_iterator + = httpResponse.GetHeaders().find("content-language"); + if (response_http_headers_content_language_iterator != httpResponse.GetHeaders().end()) + { + response.HttpHeaders.ContentLanguage + = response_http_headers_content_language_iterator->second; + } + auto response_http_headers_cache_control_iterator + = httpResponse.GetHeaders().find("cache-control"); + if (response_http_headers_cache_control_iterator != httpResponse.GetHeaders().end()) + { + response.HttpHeaders.CacheControl + = response_http_headers_cache_control_iterator->second; + } + auto response_http_headers_content_md5_iterator + = httpResponse.GetHeaders().find("content-md5"); + if (response_http_headers_content_md5_iterator != httpResponse.GetHeaders().end()) + { + response.HttpHeaders.ContentMd5 = response_http_headers_content_md5_iterator->second; + } + auto x_ms_blob_content_md5_iterator + = httpResponse.GetHeaders().find("x-ms-blob-content-md5"); + if (x_ms_blob_content_md5_iterator != httpResponse.GetHeaders().end()) + { + response.HttpHeaders.ContentMd5 = x_ms_blob_content_md5_iterator->second; + } + auto response_http_headers_content_disposition_iterator + = httpResponse.GetHeaders().find("content-disposition"); + if (response_http_headers_content_disposition_iterator != httpResponse.GetHeaders().end()) + { + response.HttpHeaders.ContentDisposition + = response_http_headers_content_disposition_iterator->second; + } + for (auto i = httpResponse.GetHeaders().lower_bound("x-ms-meta-"); + i != httpResponse.GetHeaders().end() && i->first.substr(0, 10) == "x-ms-meta-"; + ++i) + { + response.Metadata.emplace(i->first.substr(10), i->second); + } + auto response_server_encrypted_iterator + = httpResponse.GetHeaders().find("x-ms-server-encrypted"); + if (response_server_encrypted_iterator != httpResponse.GetHeaders().end()) + { + response.ServerEncrypted = response_server_encrypted_iterator->second == "true"; + } + auto response_encryption_key_sha256_iterator + = httpResponse.GetHeaders().find("x-ms-encryption-key-sha256"); + if (response_encryption_key_sha256_iterator != httpResponse.GetHeaders().end()) + { + response.EncryptionKeySha256 = response_encryption_key_sha256_iterator->second; + } + auto response_encryption_scope_iterator + = httpResponse.GetHeaders().find("x-ms-encryption-scope"); + if (response_encryption_scope_iterator != httpResponse.GetHeaders().end()) + { + response.EncryptionScope = response_encryption_scope_iterator->second; + } + auto response_lease_status_iterator = httpResponse.GetHeaders().find("x-ms-lease-status"); + if (response_lease_status_iterator != httpResponse.GetHeaders().end()) + { + response.LeaseStatus + = BlobLeaseStatusFromString(response_lease_status_iterator->second); + } + auto response_lease_state_iterator = httpResponse.GetHeaders().find("x-ms-lease-state"); + if (response_lease_state_iterator != httpResponse.GetHeaders().end()) + { + response.LeaseState = BlobLeaseStateFromString(response_lease_state_iterator->second); + } + auto response_lease_duration_iterator + = httpResponse.GetHeaders().find("x-ms-lease-duration"); + if (response_lease_duration_iterator != httpResponse.GetHeaders().end()) + { + response.LeaseDuration = response_lease_duration_iterator->second; + } + response.CreationTime = httpResponse.GetHeaders().at("x-ms-creation-time"); + auto response_expiry_time_iterator = httpResponse.GetHeaders().find("x-ms-expiry-time"); + if (response_expiry_time_iterator != httpResponse.GetHeaders().end()) + { + response.ExpiryTime = response_expiry_time_iterator->second; + } + auto response_last_access_time_iterator + = httpResponse.GetHeaders().find("x-ms-last-access-time"); + if (response_last_access_time_iterator != httpResponse.GetHeaders().end()) + { + response.LastAccessTime = response_last_access_time_iterator->second; + } + auto response_content_range_iterator = httpResponse.GetHeaders().find("content-range"); + if (response_content_range_iterator != httpResponse.GetHeaders().end()) + { + response.ContentRange = response_content_range_iterator->second; + } + auto response_sequence_number_iterator + = httpResponse.GetHeaders().find("x-ms-blob-sequence-number"); + if (response_sequence_number_iterator != httpResponse.GetHeaders().end()) + { + response.SequenceNumber = std::stoll(response_sequence_number_iterator->second); + } + auto response_committed_block_count_iterator + = httpResponse.GetHeaders().find("x-ms-blob-committed-block-count"); + if (response_committed_block_count_iterator != httpResponse.GetHeaders().end()) + { + response.CommittedBlockCount + = std::stoll(response_committed_block_count_iterator->second); + } + auto response_is_sealed_iterator = httpResponse.GetHeaders().find("x-ms-blob-sealed"); + if (response_is_sealed_iterator != httpResponse.GetHeaders().end()) + { + response.IsSealed = response_is_sealed_iterator->second == "true"; + } + response.BlobType = BlobTypeFromString(httpResponse.GetHeaders().at("x-ms-blob-type")); + auto response_object_replication_destination_policy_id_iterator + = httpResponse.GetHeaders().find("x-ms-or-policy-id"); + if (response_object_replication_destination_policy_id_iterator + != httpResponse.GetHeaders().end()) + { + response.ObjectReplicationDestinationPolicyId + = response_object_replication_destination_policy_id_iterator->second; + } + { + std::map> orPropertiesMap; + for (auto i = httpResponse.GetHeaders().lower_bound("x-ms-or-"); + i != httpResponse.GetHeaders().end() && i->first.substr(0, 8) == "x-ms-or-"; + ++i) + { + const std::string& header = i->first; + auto underscorePos = header.find('_', 8); + if (underscorePos == std::string::npos) + { + continue; + } + std::string policyId + = std::string(header.begin() + 8, header.begin() + underscorePos); + std::string ruleId = header.substr(underscorePos + 1); + + ObjectReplicationRule rule; + rule.RuleId = std::move(ruleId); + rule.ReplicationStatus = ObjectReplicationStatusFromString(i->second); + orPropertiesMap[policyId].emplace_back(std::move(rule)); + } + for (auto& property : orPropertiesMap) + { + ObjectReplicationPolicy policy; + policy.PolicyId = property.first; + policy.Rules = std::move(property.second); + response.ObjectReplicationSourceProperties.emplace_back(std::move(policy)); + } + } + auto response_tag_count_iterator = httpResponse.GetHeaders().find("x-ms-tag-count"); + if (response_tag_count_iterator != httpResponse.GetHeaders().end()) + { + response.TagCount = std::stoi(response_tag_count_iterator->second); + } + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); + } + + struct DeleteBlobOptions + { + Azure::Core::Nullable Timeout; + Azure::Core::Nullable DeleteSnapshots; + Azure::Core::Nullable LeaseId; + Azure::Core::Nullable IfModifiedSince; + Azure::Core::Nullable IfUnmodifiedSince; + Azure::Core::Nullable IfMatch; + Azure::Core::Nullable IfNoneMatch; + Azure::Core::Nullable IfTags; + }; // struct DeleteBlobOptions + + static Azure::Core::Http::Request DeleteCreateMessage( + const Azure::Core::Http::Url& url, + const DeleteBlobOptions& options) + { + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Delete, url); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + if (options.DeleteSnapshots.HasValue()) + { + request.AddHeader( + "x-ms-delete-snapshots", + DeleteSnapshotsOptionToString(options.DeleteSnapshots.GetValue())); + } + if (options.LeaseId.HasValue()) + { + request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); + } + if (options.IfModifiedSince.HasValue()) + { + request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); + } + if (options.IfUnmodifiedSince.HasValue()) + { + request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); + } + if (options.IfMatch.HasValue()) + { + request.AddHeader("If-Match", options.IfMatch.GetValue()); + } + if (options.IfNoneMatch.HasValue()) + { + request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); + } + if (options.IfTags.HasValue()) + { + request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); + } + return request; + } + + static Azure::Core::Response DeleteCreateResponse( + const Azure::Core::Context& context, + std::unique_ptr pHttpResponse) + { + unused(context); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + DeleteBlobResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 202)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); + } + + static Azure::Core::Response Delete( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const DeleteBlobOptions& options) + { + auto request = DeleteCreateMessage(url, options); + auto pHttpResponse = pipeline.Send(context, request); + return DeleteCreateResponse(context, std::move(pHttpResponse)); + } + + struct SetBlobExpiryOptions + { + Azure::Core::Nullable Timeout; + ScheduleBlobExpiryOriginType ExpiryOrigin; + Azure::Core::Nullable ExpiryTime; + }; // struct SetBlobExpiryOptions + + static Azure::Core::Response ScheduleDeletion( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const SetBlobExpiryOptions& options) + { + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); + request.AddHeader("Content-Length", "0"); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + request.GetUrl().AppendQueryParameter("comp", "expiry"); request.AddHeader( - "x-ms-encryption-algorithm", - EncryptionAlgorithmTypeToString(options.EncryptionAlgorithm.GetValue())); + "x-ms-expiry-option", ScheduleBlobExpiryOriginTypeToString(options.ExpiryOrigin)); + if (options.ExpiryTime.HasValue()) + { + request.AddHeader("x-ms-expiry-time", options.ExpiryTime.GetValue()); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + SetBlobExpiryResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 200)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); } - if (options.IfModifiedSince.HasValue()) + + struct UndeleteBlobOptions { - request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); + Azure::Core::Nullable Timeout; + }; // struct UndeleteBlobOptions + + static Azure::Core::Response Undelete( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const UndeleteBlobOptions& options) + { + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); + request.AddHeader("Content-Length", "0"); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + request.GetUrl().AppendQueryParameter("comp", "undelete"); + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + UndeleteBlobResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 200)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); } - if (options.IfUnmodifiedSince.HasValue()) + + struct GetBlobPropertiesOptions { - request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); + Azure::Core::Nullable Timeout; + Azure::Core::Nullable EncryptionKey; + Azure::Core::Nullable EncryptionKeySha256; + Azure::Core::Nullable EncryptionAlgorithm; + Azure::Core::Nullable LeaseId; + Azure::Core::Nullable IfModifiedSince; + Azure::Core::Nullable IfUnmodifiedSince; + Azure::Core::Nullable IfMatch; + Azure::Core::Nullable IfNoneMatch; + Azure::Core::Nullable IfTags; + }; // struct GetBlobPropertiesOptions + + static Azure::Core::Response GetProperties( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const GetBlobPropertiesOptions& options) + { + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Head, url); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + if (options.EncryptionKey.HasValue()) + { + request.AddHeader("x-ms-encryption-key", options.EncryptionKey.GetValue()); + } + if (options.EncryptionKeySha256.HasValue()) + { + request.AddHeader("x-ms-encryption-key-sha256", options.EncryptionKeySha256.GetValue()); + } + if (options.EncryptionAlgorithm.HasValue()) + { + request.AddHeader( + "x-ms-encryption-algorithm", + EncryptionAlgorithmTypeToString(options.EncryptionAlgorithm.GetValue())); + } + if (options.LeaseId.HasValue()) + { + request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); + } + if (options.IfModifiedSince.HasValue()) + { + request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); + } + if (options.IfUnmodifiedSince.HasValue()) + { + request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); + } + if (options.IfMatch.HasValue()) + { + request.AddHeader("If-Match", options.IfMatch.GetValue()); + } + if (options.IfNoneMatch.HasValue()) + { + request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); + } + if (options.IfTags.HasValue()) + { + request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + GetBlobPropertiesResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 200)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + response.ETag = httpResponse.GetHeaders().at("etag"); + response.LastModified = httpResponse.GetHeaders().at("last-modified"); + response.CreationTime = httpResponse.GetHeaders().at("x-ms-creation-time"); + auto response_expiry_time_iterator = httpResponse.GetHeaders().find("x-ms-expiry-time"); + if (response_expiry_time_iterator != httpResponse.GetHeaders().end()) + { + response.ExpiryTime = response_expiry_time_iterator->second; + } + auto response_last_access_time_iterator + = httpResponse.GetHeaders().find("x-ms-last-access-time"); + if (response_last_access_time_iterator != httpResponse.GetHeaders().end()) + { + response.LastAccessTime = response_last_access_time_iterator->second; + } + for (auto i = httpResponse.GetHeaders().lower_bound("x-ms-meta-"); + i != httpResponse.GetHeaders().end() && i->first.substr(0, 10) == "x-ms-meta-"; + ++i) + { + response.Metadata.emplace(i->first.substr(10), i->second); + } + response.BlobType = BlobTypeFromString(httpResponse.GetHeaders().at("x-ms-blob-type")); + auto response_lease_status_iterator = httpResponse.GetHeaders().find("x-ms-lease-status"); + if (response_lease_status_iterator != httpResponse.GetHeaders().end()) + { + response.LeaseStatus + = BlobLeaseStatusFromString(response_lease_status_iterator->second); + } + auto response_lease_state_iterator = httpResponse.GetHeaders().find("x-ms-lease-state"); + if (response_lease_state_iterator != httpResponse.GetHeaders().end()) + { + response.LeaseState = BlobLeaseStateFromString(response_lease_state_iterator->second); + } + auto response_lease_duration_iterator + = httpResponse.GetHeaders().find("x-ms-lease-duration"); + if (response_lease_duration_iterator != httpResponse.GetHeaders().end()) + { + response.LeaseDuration = response_lease_duration_iterator->second; + } + response.ContentLength = std::stoll(httpResponse.GetHeaders().at("content-length")); + auto response_http_headers_content_type_iterator + = httpResponse.GetHeaders().find("content-type"); + if (response_http_headers_content_type_iterator != httpResponse.GetHeaders().end()) + { + response.HttpHeaders.ContentType = response_http_headers_content_type_iterator->second; + } + auto response_http_headers_content_encoding_iterator + = httpResponse.GetHeaders().find("content-encoding"); + if (response_http_headers_content_encoding_iterator != httpResponse.GetHeaders().end()) + { + response.HttpHeaders.ContentEncoding + = response_http_headers_content_encoding_iterator->second; + } + auto response_http_headers_content_language_iterator + = httpResponse.GetHeaders().find("content-language"); + if (response_http_headers_content_language_iterator != httpResponse.GetHeaders().end()) + { + response.HttpHeaders.ContentLanguage + = response_http_headers_content_language_iterator->second; + } + auto response_http_headers_cache_control_iterator + = httpResponse.GetHeaders().find("cache-control"); + if (response_http_headers_cache_control_iterator != httpResponse.GetHeaders().end()) + { + response.HttpHeaders.CacheControl + = response_http_headers_cache_control_iterator->second; + } + auto response_http_headers_content_md5_iterator + = httpResponse.GetHeaders().find("content-md5"); + if (response_http_headers_content_md5_iterator != httpResponse.GetHeaders().end()) + { + response.HttpHeaders.ContentMd5 = response_http_headers_content_md5_iterator->second; + } + auto x_ms_blob_content_md5_iterator + = httpResponse.GetHeaders().find("x-ms-blob-content-md5"); + if (x_ms_blob_content_md5_iterator != httpResponse.GetHeaders().end()) + { + response.HttpHeaders.ContentMd5 = x_ms_blob_content_md5_iterator->second; + } + auto response_http_headers_content_disposition_iterator + = httpResponse.GetHeaders().find("content-disposition"); + if (response_http_headers_content_disposition_iterator != httpResponse.GetHeaders().end()) + { + response.HttpHeaders.ContentDisposition + = response_http_headers_content_disposition_iterator->second; + } + auto response_sequence_number_iterator + = httpResponse.GetHeaders().find("x-ms-blob-sequence-number"); + if (response_sequence_number_iterator != httpResponse.GetHeaders().end()) + { + response.SequenceNumber = std::stoll(response_sequence_number_iterator->second); + } + auto response_committed_block_count_iterator + = httpResponse.GetHeaders().find("x-ms-blob-committed-block-count"); + if (response_committed_block_count_iterator != httpResponse.GetHeaders().end()) + { + response.CommittedBlockCount + = std::stoi(response_committed_block_count_iterator->second); + } + auto response_is_sealed_iterator = httpResponse.GetHeaders().find("x-ms-blob-sealed"); + if (response_is_sealed_iterator != httpResponse.GetHeaders().end()) + { + response.IsSealed = response_is_sealed_iterator->second == "true"; + } + auto response_server_encrypted_iterator + = httpResponse.GetHeaders().find("x-ms-server-encrypted"); + if (response_server_encrypted_iterator != httpResponse.GetHeaders().end()) + { + response.ServerEncrypted = response_server_encrypted_iterator->second == "true"; + } + auto response_encryption_key_sha256_iterator + = httpResponse.GetHeaders().find("x-ms-encryption-key-sha256"); + if (response_encryption_key_sha256_iterator != httpResponse.GetHeaders().end()) + { + response.EncryptionKeySha256 = response_encryption_key_sha256_iterator->second; + } + auto response_encryption_scope_iterator + = httpResponse.GetHeaders().find("x-ms-encryption-scope"); + if (response_encryption_scope_iterator != httpResponse.GetHeaders().end()) + { + response.EncryptionScope = response_encryption_scope_iterator->second; + } + auto response_tier_iterator = httpResponse.GetHeaders().find("x-ms-access-tier"); + if (response_tier_iterator != httpResponse.GetHeaders().end()) + { + response.Tier = AccessTierFromString(response_tier_iterator->second); + } + auto response_access_tier_inferred_iterator + = httpResponse.GetHeaders().find("x-ms-access-tier-inferred"); + if (response_access_tier_inferred_iterator != httpResponse.GetHeaders().end()) + { + response.AccessTierInferred = response_access_tier_inferred_iterator->second == "true"; + } + auto response_archive_status_iterator + = httpResponse.GetHeaders().find("x-ms-archive-status"); + if (response_archive_status_iterator != httpResponse.GetHeaders().end()) + { + response.ArchiveStatus + = BlobArchiveStatusFromString(response_archive_status_iterator->second); + } + auto response_access_tier_change_time_iterator + = httpResponse.GetHeaders().find("x-ms-access-tier-change-time"); + if (response_access_tier_change_time_iterator != httpResponse.GetHeaders().end()) + { + response.AccessTierChangeTime = response_access_tier_change_time_iterator->second; + } + auto response_copy_id_iterator = httpResponse.GetHeaders().find("x-ms-copy-id"); + if (response_copy_id_iterator != httpResponse.GetHeaders().end()) + { + response.CopyId = response_copy_id_iterator->second; + } + auto response_copy_source_iterator = httpResponse.GetHeaders().find("x-ms-copy-source"); + if (response_copy_source_iterator != httpResponse.GetHeaders().end()) + { + response.CopySource = response_copy_source_iterator->second; + } + auto response_copy_status_iterator = httpResponse.GetHeaders().find("x-ms-copy-status"); + if (response_copy_status_iterator != httpResponse.GetHeaders().end()) + { + response.CopyStatus = CopyStatusFromString(response_copy_status_iterator->second); + } + auto response_copy_progress_iterator + = httpResponse.GetHeaders().find("x-ms-copy-progress"); + if (response_copy_progress_iterator != httpResponse.GetHeaders().end()) + { + response.CopyProgress = response_copy_progress_iterator->second; + } + auto response_copy_completion_time_iterator + = httpResponse.GetHeaders().find("x-ms-copy-completion-time"); + if (response_copy_completion_time_iterator != httpResponse.GetHeaders().end()) + { + response.CopyCompletionTime = response_copy_completion_time_iterator->second; + } + auto response_object_replication_destination_policy_id_iterator + = httpResponse.GetHeaders().find("x-ms-or-policy-id"); + if (response_object_replication_destination_policy_id_iterator + != httpResponse.GetHeaders().end()) + { + response.ObjectReplicationDestinationPolicyId + = response_object_replication_destination_policy_id_iterator->second; + } + { + std::map> orPropertiesMap; + for (auto i = httpResponse.GetHeaders().lower_bound("x-ms-or-"); + i != httpResponse.GetHeaders().end() && i->first.substr(0, 8) == "x-ms-or-"; + ++i) + { + const std::string& header = i->first; + auto underscorePos = header.find('_', 8); + if (underscorePos == std::string::npos) + { + continue; + } + std::string policyId + = std::string(header.begin() + 8, header.begin() + underscorePos); + std::string ruleId = header.substr(underscorePos + 1); + + ObjectReplicationRule rule; + rule.RuleId = std::move(ruleId); + rule.ReplicationStatus = ObjectReplicationStatusFromString(i->second); + orPropertiesMap[policyId].emplace_back(std::move(rule)); + } + for (auto& property : orPropertiesMap) + { + ObjectReplicationPolicy policy; + policy.PolicyId = property.first; + policy.Rules = std::move(property.second); + response.ObjectReplicationSourceProperties.emplace_back(std::move(policy)); + } + } + auto response_tag_count_iterator = httpResponse.GetHeaders().find("x-ms-tag-count"); + if (response_tag_count_iterator != httpResponse.GetHeaders().end()) + { + response.TagCount = std::stoi(response_tag_count_iterator->second); + } + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); } - if (options.IfMatch.HasValue()) + + struct SetBlobHttpHeadersOptions { - request.AddHeader("If-Match", options.IfMatch.GetValue()); + Azure::Core::Nullable Timeout; + BlobHttpHeaders HttpHeaders; + Azure::Core::Nullable LeaseId; + Azure::Core::Nullable IfModifiedSince; + Azure::Core::Nullable IfUnmodifiedSince; + Azure::Core::Nullable IfMatch; + Azure::Core::Nullable IfNoneMatch; + Azure::Core::Nullable IfTags; + }; // struct SetBlobHttpHeadersOptions + + static Azure::Core::Response SetHttpHeaders( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const SetBlobHttpHeadersOptions& options) + { + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); + request.AddHeader("Content-Length", "0"); + request.GetUrl().AppendQueryParameter("comp", "properties"); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + if (!options.HttpHeaders.ContentType.empty()) + { + request.AddHeader("x-ms-blob-content-type", options.HttpHeaders.ContentType); + } + if (!options.HttpHeaders.ContentEncoding.empty()) + { + request.AddHeader("x-ms-blob-content-encoding", options.HttpHeaders.ContentEncoding); + } + if (!options.HttpHeaders.ContentLanguage.empty()) + { + request.AddHeader("x-ms-blob-content-language", options.HttpHeaders.ContentLanguage); + } + if (!options.HttpHeaders.CacheControl.empty()) + { + request.AddHeader("x-ms-blob-cache-control", options.HttpHeaders.CacheControl); + } + if (!options.HttpHeaders.ContentMd5.empty()) + { + request.AddHeader("x-ms-blob-content-md5", options.HttpHeaders.ContentMd5); + } + if (!options.HttpHeaders.ContentDisposition.empty()) + { + request.AddHeader( + "x-ms-blob-content-disposition", options.HttpHeaders.ContentDisposition); + } + if (options.LeaseId.HasValue()) + { + request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); + } + if (options.IfModifiedSince.HasValue()) + { + request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); + } + if (options.IfUnmodifiedSince.HasValue()) + { + request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); + } + if (options.IfMatch.HasValue()) + { + request.AddHeader("If-Match", options.IfMatch.GetValue()); + } + if (options.IfNoneMatch.HasValue()) + { + request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); + } + if (options.IfTags.HasValue()) + { + request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + SetBlobHttpHeadersResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 200)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + response.ETag = httpResponse.GetHeaders().at("etag"); + response.LastModified = httpResponse.GetHeaders().at("last-modified"); + auto response_sequence_number_iterator + = httpResponse.GetHeaders().find("x-ms-blob-sequence-number"); + if (response_sequence_number_iterator != httpResponse.GetHeaders().end()) + { + response.SequenceNumber = std::stoll(response_sequence_number_iterator->second); + } + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); } - if (options.IfNoneMatch.HasValue()) + + struct SetBlobMetadataOptions { - request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); + Azure::Core::Nullable Timeout; + std::map Metadata; + Azure::Core::Nullable EncryptionKey; + Azure::Core::Nullable EncryptionKeySha256; + Azure::Core::Nullable EncryptionAlgorithm; + Azure::Core::Nullable EncryptionScope; + Azure::Core::Nullable LeaseId; + Azure::Core::Nullable IfModifiedSince; + Azure::Core::Nullable IfUnmodifiedSince; + Azure::Core::Nullable IfMatch; + Azure::Core::Nullable IfNoneMatch; + Azure::Core::Nullable IfTags; + }; // struct SetBlobMetadataOptions + + static Azure::Core::Response SetMetadata( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const SetBlobMetadataOptions& options) + { + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); + request.AddHeader("Content-Length", "0"); + request.GetUrl().AppendQueryParameter("comp", "metadata"); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + std::set metadataKeys; + for (const auto& pair : options.Metadata) + { + if (metadataKeys.insert(Azure::Core::Strings::ToLower(pair.first)).second == false) + { + throw std::runtime_error("duplicate keys in metadata"); + } + request.AddHeader("x-ms-meta-" + pair.first, pair.second); + } + metadataKeys.clear(); + if (options.EncryptionKey.HasValue()) + { + request.AddHeader("x-ms-encryption-key", options.EncryptionKey.GetValue()); + } + if (options.EncryptionKeySha256.HasValue()) + { + request.AddHeader("x-ms-encryption-key-sha256", options.EncryptionKeySha256.GetValue()); + } + if (options.EncryptionAlgorithm.HasValue()) + { + request.AddHeader( + "x-ms-encryption-algorithm", + EncryptionAlgorithmTypeToString(options.EncryptionAlgorithm.GetValue())); + } + if (options.EncryptionScope.HasValue()) + { + request.AddHeader("x-ms-encryption-scope", options.EncryptionScope.GetValue()); + } + if (options.LeaseId.HasValue()) + { + request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); + } + if (options.IfModifiedSince.HasValue()) + { + request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); + } + if (options.IfUnmodifiedSince.HasValue()) + { + request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); + } + if (options.IfMatch.HasValue()) + { + request.AddHeader("If-Match", options.IfMatch.GetValue()); + } + if (options.IfNoneMatch.HasValue()) + { + request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); + } + if (options.IfTags.HasValue()) + { + request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + SetBlobMetadataResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 200)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + response.ETag = httpResponse.GetHeaders().at("etag"); + response.LastModified = httpResponse.GetHeaders().at("last-modified"); + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); } - if (options.IfTags.HasValue()) + + struct SetBlobAccessTierOptions { - request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); + Azure::Core::Nullable Timeout; + AccessTier Tier = AccessTier::Unknown; + Azure::Core::Nullable RehydratePriority; + Azure::Core::Nullable IfTags; + }; // struct SetBlobAccessTierOptions + + static Azure::Core::Http::Request SetAccessTierCreateMessage( + const Azure::Core::Http::Url& url, + const SetBlobAccessTierOptions& options) + { + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); + request.AddHeader("Content-Length", "0"); + request.GetUrl().AppendQueryParameter("comp", "tier"); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + request.AddHeader("x-ms-access-tier", AccessTierToString(options.Tier)); + if (options.RehydratePriority.HasValue()) + { + request.AddHeader( + "x-ms-rehydrate-priority", + RehydratePriorityToString(options.RehydratePriority.GetValue())); + } + if (options.IfTags.HasValue()) + { + request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); + } + return request; } - if (options.LeaseId.HasValue()) + + static Azure::Core::Response SetAccessTierCreateResponse( + const Azure::Core::Context& context, + std::unique_ptr pHttpResponse) { - request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); + unused(context); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + SetBlobAccessTierResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 200 || http_status_code == 202)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - DownloadBlobResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 200 || http_status_code == 206)) + + static Azure::Core::Response SetAccessTier( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const SetBlobAccessTierOptions& options) { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + auto request = SetAccessTierCreateMessage(url, options); + auto pHttpResponse = pipeline.Send(context, request); + return SetAccessTierCreateResponse(context, std::move(pHttpResponse)); } - response.BodyStream = httpResponse.GetBodyStream(); - response.ETag = httpResponse.GetHeaders().at("etag"); - response.LastModified = httpResponse.GetHeaders().at("last-modified"); - auto response_transactional_content_md5_iterator - = httpResponse.GetHeaders().find("content-md5"); - if (response_transactional_content_md5_iterator != httpResponse.GetHeaders().end()) + + struct StartCopyBlobFromUriOptions { - response.TransactionalContentMd5 = response_transactional_content_md5_iterator->second; + Azure::Core::Nullable Timeout; + std::map Metadata; + std::string SourceUri; + Azure::Core::Nullable LeaseId; + Azure::Core::Nullable SourceLeaseId; + Azure::Core::Nullable Tier; + Azure::Core::Nullable RehydratePriority; + Azure::Core::Nullable IfModifiedSince; + Azure::Core::Nullable IfUnmodifiedSince; + Azure::Core::Nullable IfMatch; + Azure::Core::Nullable IfNoneMatch; + Azure::Core::Nullable IfTags; + Azure::Core::Nullable SourceIfModifiedSince; + Azure::Core::Nullable SourceIfUnmodifiedSince; + Azure::Core::Nullable SourceIfMatch; + Azure::Core::Nullable SourceIfNoneMatch; + Azure::Core::Nullable SourceIfTags; + Azure::Core::Nullable ShouldSealDestination; + }; // struct StartCopyBlobFromUriOptions + + static Azure::Core::Response StartCopyFromUri( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const StartCopyBlobFromUriOptions& options) + { + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); + request.AddHeader("Content-Length", "0"); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + std::set metadataKeys; + for (const auto& pair : options.Metadata) + { + if (metadataKeys.insert(Azure::Core::Strings::ToLower(pair.first)).second == false) + { + throw std::runtime_error("duplicate keys in metadata"); + } + request.AddHeader("x-ms-meta-" + pair.first, pair.second); + } + metadataKeys.clear(); + request.AddHeader("x-ms-copy-source", options.SourceUri); + if (options.LeaseId.HasValue()) + { + request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); + } + if (options.SourceLeaseId.HasValue()) + { + request.AddHeader("x-ms-source-lease-id", options.SourceLeaseId.GetValue()); + } + if (options.Tier.HasValue()) + { + request.AddHeader("x-ms-access-tier", AccessTierToString(options.Tier.GetValue())); + } + if (options.RehydratePriority.HasValue()) + { + request.AddHeader( + "x-ms-rehydrate-priority", + RehydratePriorityToString(options.RehydratePriority.GetValue())); + } + if (options.ShouldSealDestination.HasValue()) + { + request.AddHeader( + "x-ms-seal-blob", options.ShouldSealDestination.GetValue() ? "true" : "false"); + } + if (options.IfModifiedSince.HasValue()) + { + request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); + } + if (options.IfUnmodifiedSince.HasValue()) + { + request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); + } + if (options.IfMatch.HasValue()) + { + request.AddHeader("If-Match", options.IfMatch.GetValue()); + } + if (options.IfNoneMatch.HasValue()) + { + request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); + } + if (options.IfTags.HasValue()) + { + request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); + } + if (options.SourceIfModifiedSince.HasValue()) + { + request.AddHeader( + "x-ms-source-if-modified-since", options.SourceIfModifiedSince.GetValue()); + } + if (options.SourceIfUnmodifiedSince.HasValue()) + { + request.AddHeader( + "x-ms-source-if-unmodified-since", options.SourceIfUnmodifiedSince.GetValue()); + } + if (options.SourceIfMatch.HasValue()) + { + request.AddHeader("x-ms-source-if-match", options.SourceIfMatch.GetValue()); + } + if (options.SourceIfNoneMatch.HasValue()) + { + request.AddHeader("x-ms-source-if-none-match", options.SourceIfNoneMatch.GetValue()); + } + if (options.SourceIfTags.HasValue()) + { + request.AddHeader("x-ms-source-if-tags", options.SourceIfTags.GetValue()); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + StartCopyBlobFromUriResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 202)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + response.ETag = httpResponse.GetHeaders().at("etag"); + response.LastModified = httpResponse.GetHeaders().at("last-modified"); + response.CopyId = httpResponse.GetHeaders().at("x-ms-copy-id"); + response.CopyStatus + = CopyStatusFromString(httpResponse.GetHeaders().at("x-ms-copy-status")); + auto response_version_id_iterator = httpResponse.GetHeaders().find("x-ms-version-id"); + if (response_version_id_iterator != httpResponse.GetHeaders().end()) + { + response.VersionId = response_version_id_iterator->second; + } + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); } - auto response_transactional_content_crc64_iterator - = httpResponse.GetHeaders().find("x-ms-content-crc64"); - if (response_transactional_content_crc64_iterator != httpResponse.GetHeaders().end()) + + struct AbortCopyBlobFromUriOptions { - response.TransactionalContentCrc64 - = response_transactional_content_crc64_iterator->second; + Azure::Core::Nullable Timeout; + std::string CopyId; + Azure::Core::Nullable LeaseId; + }; // struct AbortCopyBlobFromUriOptions + + static Azure::Core::Response AbortCopyFromUri( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const AbortCopyBlobFromUriOptions& options) + { + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); + request.AddHeader("Content-Length", "0"); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + request.GetUrl().AppendQueryParameter("comp", "copy"); + request.GetUrl().AppendQueryParameter( + "copyid", Storage::Details::UrlEncodeQueryParameter(options.CopyId)); + request.AddHeader("x-ms-copy-action", "abort"); + if (options.LeaseId.HasValue()) + { + request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + AbortCopyBlobFromUriResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 204)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); } - auto response_http_headers_content_type_iterator - = httpResponse.GetHeaders().find("content-type"); - if (response_http_headers_content_type_iterator != httpResponse.GetHeaders().end()) + + struct CreateBlobSnapshotOptions { - response.HttpHeaders.ContentType = response_http_headers_content_type_iterator->second; + Azure::Core::Nullable Timeout; + std::map Metadata; + Azure::Core::Nullable LeaseId; + Azure::Core::Nullable EncryptionKey; + Azure::Core::Nullable EncryptionKeySha256; + Azure::Core::Nullable EncryptionAlgorithm; + Azure::Core::Nullable EncryptionScope; + Azure::Core::Nullable IfModifiedSince; + Azure::Core::Nullable IfUnmodifiedSince; + Azure::Core::Nullable IfMatch; + Azure::Core::Nullable IfNoneMatch; + Azure::Core::Nullable IfTags; + }; // struct CreateBlobSnapshotOptions + + static Azure::Core::Response CreateSnapshot( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const CreateBlobSnapshotOptions& options) + { + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); + request.AddHeader("Content-Length", "0"); + request.GetUrl().AppendQueryParameter("comp", "snapshot"); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + if (options.EncryptionKey.HasValue()) + { + request.AddHeader("x-ms-encryption-key", options.EncryptionKey.GetValue()); + } + if (options.EncryptionKeySha256.HasValue()) + { + request.AddHeader("x-ms-encryption-key-sha256", options.EncryptionKeySha256.GetValue()); + } + if (options.EncryptionAlgorithm.HasValue()) + { + request.AddHeader( + "x-ms-encryption-algorithm", + EncryptionAlgorithmTypeToString(options.EncryptionAlgorithm.GetValue())); + } + if (options.EncryptionScope.HasValue()) + { + request.AddHeader("x-ms-encryption-scope", options.EncryptionScope.GetValue()); + } + std::set metadataKeys; + for (const auto& pair : options.Metadata) + { + if (metadataKeys.insert(Azure::Core::Strings::ToLower(pair.first)).second == false) + { + throw std::runtime_error("duplicate keys in metadata"); + } + request.AddHeader("x-ms-meta-" + pair.first, pair.second); + } + metadataKeys.clear(); + if (options.LeaseId.HasValue()) + { + request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); + } + if (options.IfModifiedSince.HasValue()) + { + request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); + } + if (options.IfUnmodifiedSince.HasValue()) + { + request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); + } + if (options.IfMatch.HasValue()) + { + request.AddHeader("If-Match", options.IfMatch.GetValue()); + } + if (options.IfNoneMatch.HasValue()) + { + request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); + } + if (options.IfTags.HasValue()) + { + request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + CreateBlobSnapshotResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 201)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + response.ETag = httpResponse.GetHeaders().at("etag"); + response.LastModified = httpResponse.GetHeaders().at("last-modified"); + auto response_server_encrypted_iterator + = httpResponse.GetHeaders().find("x-ms-request-server-encrypted"); + if (response_server_encrypted_iterator != httpResponse.GetHeaders().end()) + { + response.ServerEncrypted = response_server_encrypted_iterator->second == "true"; + } + auto response_encryption_key_sha256_iterator + = httpResponse.GetHeaders().find("x-ms-encryption-key-sha256"); + if (response_encryption_key_sha256_iterator != httpResponse.GetHeaders().end()) + { + response.EncryptionKeySha256 = response_encryption_key_sha256_iterator->second; + } + auto response_encryption_scope_iterator + = httpResponse.GetHeaders().find("x-ms-encryption-scope"); + if (response_encryption_scope_iterator != httpResponse.GetHeaders().end()) + { + response.EncryptionScope = response_encryption_scope_iterator->second; + } + response.Snapshot = httpResponse.GetHeaders().at("x-ms-snapshot"); + auto response_version_id_iterator = httpResponse.GetHeaders().find("x-ms-version-id"); + if (response_version_id_iterator != httpResponse.GetHeaders().end()) + { + response.VersionId = response_version_id_iterator->second; + } + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); } - auto response_http_headers_content_encoding_iterator - = httpResponse.GetHeaders().find("content-encoding"); - if (response_http_headers_content_encoding_iterator != httpResponse.GetHeaders().end()) + + struct GetBlobTagsOptions { - response.HttpHeaders.ContentEncoding - = response_http_headers_content_encoding_iterator->second; + Azure::Core::Nullable Timeout; + Azure::Core::Nullable IfTags; + }; // struct GetBlobTagsOptions + + static Azure::Core::Response GetTags( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const GetBlobTagsOptions& options) + { + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + request.GetUrl().AppendQueryParameter("comp", "tags"); + if (options.IfTags.HasValue()) + { + request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + GetBlobTagsResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 200)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + { + const auto& httpResponseBody = httpResponse.GetBody(); + XmlReader reader( + reinterpret_cast(httpResponseBody.data()), httpResponseBody.size()); + response = GetBlobTagsResultFromXml(reader); + } + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); } - auto response_http_headers_content_language_iterator - = httpResponse.GetHeaders().find("content-language"); - if (response_http_headers_content_language_iterator != httpResponse.GetHeaders().end()) + + struct SetBlobTagsOptions { - response.HttpHeaders.ContentLanguage - = response_http_headers_content_language_iterator->second; + Azure::Core::Nullable Timeout; + std::map Tags; + Azure::Core::Nullable IfTags; + }; // struct SetBlobTagsOptions + + static Azure::Core::Response SetTags( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const SetBlobTagsOptions& options) + { + unused(options); + std::string xml_body; + { + XmlWriter writer; + SetBlobTagsOptionsToXml(writer, options); + xml_body = writer.GetDocument(); + writer.Write(XmlNode{XmlNodeType::End}); + } + Azure::Core::Http::MemoryBodyStream xml_body_stream( + reinterpret_cast(xml_body.data()), xml_body.length()); + auto request = Azure::Core::Http::Request( + Azure::Core::Http::HttpMethod::Put, url, &xml_body_stream); + request.AddHeader("Content-Length", std::to_string(xml_body_stream.Length())); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + request.GetUrl().AppendQueryParameter("comp", "tags"); + request.AddHeader("Content-Type", "application/xml; charset=UTF-8"); + if (options.IfTags.HasValue()) + { + request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + SetBlobTagsResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 204)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); } - auto response_http_headers_cache_control_iterator - = httpResponse.GetHeaders().find("cache-control"); - if (response_http_headers_cache_control_iterator != httpResponse.GetHeaders().end()) + + struct AcquireBlobLeaseOptions { - response.HttpHeaders.CacheControl = response_http_headers_cache_control_iterator->second; + Azure::Core::Nullable Timeout; + int32_t LeaseDuration = -1; + Azure::Core::Nullable ProposedLeaseId; + Azure::Core::Nullable IfModifiedSince; + Azure::Core::Nullable IfUnmodifiedSince; + Azure::Core::Nullable IfMatch; + Azure::Core::Nullable IfNoneMatch; + Azure::Core::Nullable IfTags; + }; // struct AcquireBlobLeaseOptions + + static Azure::Core::Response AcquireLease( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const AcquireBlobLeaseOptions& options) + { + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); + request.AddHeader("Content-Length", "0"); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + request.GetUrl().AppendQueryParameter("comp", "lease"); + request.AddHeader("x-ms-lease-action", "acquire"); + request.AddHeader("x-ms-lease-duration", std::to_string(options.LeaseDuration)); + if (options.ProposedLeaseId.HasValue()) + { + request.AddHeader("x-ms-proposed-lease-id", options.ProposedLeaseId.GetValue()); + } + if (options.IfModifiedSince.HasValue()) + { + request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); + } + if (options.IfUnmodifiedSince.HasValue()) + { + request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); + } + if (options.IfMatch.HasValue()) + { + request.AddHeader("If-Match", options.IfMatch.GetValue()); + } + if (options.IfNoneMatch.HasValue()) + { + request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); + } + if (options.IfTags.HasValue()) + { + request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + AcquireBlobLeaseResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 201)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + response.ETag = httpResponse.GetHeaders().at("etag"); + response.LastModified = httpResponse.GetHeaders().at("last-modified"); + response.LeaseId = httpResponse.GetHeaders().at("x-ms-lease-id"); + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); } - auto response_http_headers_content_md5_iterator - = httpResponse.GetHeaders().find("content-md5"); - if (response_http_headers_content_md5_iterator != httpResponse.GetHeaders().end()) + + struct RenewBlobLeaseOptions { - response.HttpHeaders.ContentMd5 = response_http_headers_content_md5_iterator->second; + Azure::Core::Nullable Timeout; + std::string LeaseId; + Azure::Core::Nullable IfModifiedSince; + Azure::Core::Nullable IfUnmodifiedSince; + Azure::Core::Nullable IfMatch; + Azure::Core::Nullable IfNoneMatch; + Azure::Core::Nullable IfTags; + }; // struct RenewBlobLeaseOptions + + static Azure::Core::Response RenewLease( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const RenewBlobLeaseOptions& options) + { + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); + request.AddHeader("Content-Length", "0"); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + request.GetUrl().AppendQueryParameter("comp", "lease"); + request.AddHeader("x-ms-lease-action", "renew"); + request.AddHeader("x-ms-lease-id", options.LeaseId); + if (options.IfModifiedSince.HasValue()) + { + request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); + } + if (options.IfUnmodifiedSince.HasValue()) + { + request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); + } + if (options.IfMatch.HasValue()) + { + request.AddHeader("If-Match", options.IfMatch.GetValue()); + } + if (options.IfNoneMatch.HasValue()) + { + request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); + } + if (options.IfTags.HasValue()) + { + request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + RenewBlobLeaseResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 200)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + response.ETag = httpResponse.GetHeaders().at("etag"); + response.LastModified = httpResponse.GetHeaders().at("last-modified"); + response.LeaseId = httpResponse.GetHeaders().at("x-ms-lease-id"); + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); } - auto x_ms_blob_content_md5_iterator - = httpResponse.GetHeaders().find("x-ms-blob-content-md5"); - if (x_ms_blob_content_md5_iterator != httpResponse.GetHeaders().end()) + + struct ChangeBlobLeaseOptions { - response.HttpHeaders.ContentMd5 = x_ms_blob_content_md5_iterator->second; + Azure::Core::Nullable Timeout; + std::string LeaseId; + std::string ProposedLeaseId; + Azure::Core::Nullable IfModifiedSince; + Azure::Core::Nullable IfUnmodifiedSince; + Azure::Core::Nullable IfMatch; + Azure::Core::Nullable IfNoneMatch; + Azure::Core::Nullable IfTags; + }; // struct ChangeBlobLeaseOptions + + static Azure::Core::Response ChangeLease( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const ChangeBlobLeaseOptions& options) + { + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); + request.AddHeader("Content-Length", "0"); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + request.GetUrl().AppendQueryParameter("comp", "lease"); + request.AddHeader("x-ms-lease-action", "change"); + request.AddHeader("x-ms-lease-id", options.LeaseId); + request.AddHeader("x-ms-proposed-lease-id", options.ProposedLeaseId); + if (options.IfModifiedSince.HasValue()) + { + request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); + } + if (options.IfUnmodifiedSince.HasValue()) + { + request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); + } + if (options.IfMatch.HasValue()) + { + request.AddHeader("If-Match", options.IfMatch.GetValue()); + } + if (options.IfNoneMatch.HasValue()) + { + request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); + } + if (options.IfTags.HasValue()) + { + request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + ChangeBlobLeaseResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 200)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + response.ETag = httpResponse.GetHeaders().at("etag"); + response.LastModified = httpResponse.GetHeaders().at("last-modified"); + response.LeaseId = httpResponse.GetHeaders().at("x-ms-lease-id"); + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); } - auto response_http_headers_content_disposition_iterator - = httpResponse.GetHeaders().find("content-disposition"); - if (response_http_headers_content_disposition_iterator != httpResponse.GetHeaders().end()) + + struct ReleaseBlobLeaseOptions { - response.HttpHeaders.ContentDisposition - = response_http_headers_content_disposition_iterator->second; + Azure::Core::Nullable Timeout; + std::string LeaseId; + Azure::Core::Nullable IfModifiedSince; + Azure::Core::Nullable IfUnmodifiedSince; + Azure::Core::Nullable IfMatch; + Azure::Core::Nullable IfNoneMatch; + Azure::Core::Nullable IfTags; + }; // struct ReleaseBlobLeaseOptions + + static Azure::Core::Response ReleaseLease( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const ReleaseBlobLeaseOptions& options) + { + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); + request.AddHeader("Content-Length", "0"); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + request.GetUrl().AppendQueryParameter("comp", "lease"); + request.AddHeader("x-ms-lease-action", "release"); + request.AddHeader("x-ms-lease-id", options.LeaseId); + if (options.IfModifiedSince.HasValue()) + { + request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); + } + if (options.IfUnmodifiedSince.HasValue()) + { + request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); + } + if (options.IfMatch.HasValue()) + { + request.AddHeader("If-Match", options.IfMatch.GetValue()); + } + if (options.IfNoneMatch.HasValue()) + { + request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); + } + if (options.IfTags.HasValue()) + { + request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + ReleaseBlobLeaseResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 200)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + response.ETag = httpResponse.GetHeaders().at("etag"); + response.LastModified = httpResponse.GetHeaders().at("last-modified"); + auto response_sequence_number_iterator + = httpResponse.GetHeaders().find("x-ms-blob-sequence-number"); + if (response_sequence_number_iterator != httpResponse.GetHeaders().end()) + { + response.SequenceNumber = std::stoll(response_sequence_number_iterator->second); + } + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); } - for (auto i = httpResponse.GetHeaders().lower_bound("x-ms-meta-"); - i != httpResponse.GetHeaders().end() && i->first.substr(0, 10) == "x-ms-meta-"; - ++i) + + struct BreakBlobLeaseOptions { - response.Metadata.emplace(i->first.substr(10), i->second); + Azure::Core::Nullable Timeout; + Azure::Core::Nullable BreakPeriod; + Azure::Core::Nullable IfModifiedSince; + Azure::Core::Nullable IfUnmodifiedSince; + Azure::Core::Nullable IfMatch; + Azure::Core::Nullable IfNoneMatch; + Azure::Core::Nullable IfTags; + }; // struct BreakBlobLeaseOptions + + static Azure::Core::Response BreakLease( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const BreakBlobLeaseOptions& options) + { + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); + request.AddHeader("Content-Length", "0"); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + request.GetUrl().AppendQueryParameter("comp", "lease"); + request.AddHeader("x-ms-lease-action", "break"); + if (options.BreakPeriod.HasValue()) + { + request.AddHeader( + "x-ms-lease-break-period", std::to_string(options.BreakPeriod.GetValue())); + } + if (options.IfModifiedSince.HasValue()) + { + request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); + } + if (options.IfUnmodifiedSince.HasValue()) + { + request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); + } + if (options.IfMatch.HasValue()) + { + request.AddHeader("If-Match", options.IfMatch.GetValue()); + } + if (options.IfNoneMatch.HasValue()) + { + request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); + } + if (options.IfTags.HasValue()) + { + request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + BreakBlobLeaseResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 202)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + response.ETag = httpResponse.GetHeaders().at("etag"); + response.LastModified = httpResponse.GetHeaders().at("last-modified"); + response.LeaseTime = std::stoi(httpResponse.GetHeaders().at("x-ms-lease-time")); + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); } - auto response_server_encrypted_iterator - = httpResponse.GetHeaders().find("x-ms-server-encrypted"); - if (response_server_encrypted_iterator != httpResponse.GetHeaders().end()) + + private: + static GetBlobTagsResult GetBlobTagsResultFromXml(XmlReader& reader) { - response.ServerEncrypted = response_server_encrypted_iterator->second == "true"; + GetBlobTagsResult ret; + enum class XmlTagName + { + k_Tags, + k_TagSet, + k_Unknown, + }; + std::vector path; + while (true) + { + auto node = reader.Read(); + if (node.Type == XmlNodeType::End) + { + break; + } + else if (node.Type == XmlNodeType::EndTag) + { + if (path.size() > 0) + { + path.pop_back(); + } + else + { + break; + } + } + else if (node.Type == XmlNodeType::StartTag) + { + if (std::strcmp(node.Name, "Tags") == 0) + { + path.emplace_back(XmlTagName::k_Tags); + } + else if (std::strcmp(node.Name, "TagSet") == 0) + { + path.emplace_back(XmlTagName::k_TagSet); + } + else + { + path.emplace_back(XmlTagName::k_Unknown); + } + if (path.size() == 2 && path[0] == XmlTagName::k_Tags + && path[1] == XmlTagName::k_TagSet) + { + ret.Tags = TagsFromXml(reader); + path.pop_back(); + } + } + else if (node.Type == XmlNodeType::Text) + { + } + } + return ret; } - auto response_encryption_key_sha256_iterator - = httpResponse.GetHeaders().find("x-ms-encryption-key-sha256"); - if (response_encryption_key_sha256_iterator != httpResponse.GetHeaders().end()) + + static std::map TagsFromXml(XmlReader& reader) { - response.EncryptionKeySha256 = response_encryption_key_sha256_iterator->second; + std::map ret; + int depth = 0; + std::string key; + bool is_key = false; + bool is_value = false; + while (true) + { + auto node = reader.Read(); + if (node.Type == XmlNodeType::End) + { + break; + } + else if (node.Type == XmlNodeType::StartTag) + { + ++depth; + if (strcmp(node.Name, "Key") == 0) + { + is_key = true; + } + else if (strcmp(node.Name, "Value") == 0) + { + is_value = true; + } + } + else if (node.Type == XmlNodeType::EndTag) + { + if (depth-- == 0) + { + break; + } + } + if (depth == 2 && node.Type == XmlNodeType::Text) + { + if (is_key) + { + key = node.Value; + is_key = false; + } + else if (is_value) + { + ret.emplace(std::move(key), node.Value); + is_value = false; + } + } + } + return ret; } - auto response_encryption_scope_iterator - = httpResponse.GetHeaders().find("x-ms-encryption-scope"); - if (response_encryption_scope_iterator != httpResponse.GetHeaders().end()) + + static void SetBlobTagsOptionsToXml(XmlWriter& writer, const SetBlobTagsOptions& options) { - response.EncryptionScope = response_encryption_scope_iterator->second; + writer.Write(XmlNode{XmlNodeType::StartTag, "Tags"}); + writer.Write(XmlNode{XmlNodeType::StartTag, "TagSet"}); + for (const auto& i : options.Tags) + { + writer.Write(XmlNode{XmlNodeType::StartTag, "Tag"}); + writer.Write(XmlNode{XmlNodeType::StartTag, "Key"}); + writer.Write(XmlNode{XmlNodeType::Text, nullptr, i.first.data()}); + writer.Write(XmlNode{XmlNodeType::EndTag}); + writer.Write(XmlNode{XmlNodeType::StartTag, "Value"}); + writer.Write(XmlNode{XmlNodeType::Text, nullptr, i.second.data()}); + writer.Write(XmlNode{XmlNodeType::EndTag}); + writer.Write(XmlNode{XmlNodeType::EndTag}); + } + writer.Write(XmlNode{XmlNodeType::EndTag}); + writer.Write(XmlNode{XmlNodeType::EndTag}); } - auto response_lease_status_iterator = httpResponse.GetHeaders().find("x-ms-lease-status"); - if (response_lease_status_iterator != httpResponse.GetHeaders().end()) + + }; // class Blob + + class BlockBlob { + public: + struct UploadBlockBlobOptions { - response.LeaseStatus = BlobLeaseStatusFromString(response_lease_status_iterator->second); + Azure::Core::Nullable Timeout; + Azure::Core::Nullable TransactionalContentMd5; + Azure::Core::Nullable TransactionalContentCrc64; + BlobHttpHeaders HttpHeaders; + std::map Metadata; + Azure::Core::Nullable LeaseId; + Azure::Core::Nullable Tier; + Azure::Core::Nullable EncryptionKey; + Azure::Core::Nullable EncryptionKeySha256; + Azure::Core::Nullable EncryptionAlgorithm; + Azure::Core::Nullable EncryptionScope; + Azure::Core::Nullable IfModifiedSince; + Azure::Core::Nullable IfUnmodifiedSince; + Azure::Core::Nullable IfMatch; + Azure::Core::Nullable IfNoneMatch; + Azure::Core::Nullable IfTags; + }; // struct UploadBlockBlobOptions + + static Azure::Core::Response Upload( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + Azure::Core::Http::BodyStream* requestBody, + const UploadBlockBlobOptions& options) + { + unused(options); + auto request + = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url, requestBody); + request.AddHeader("Content-Length", std::to_string(requestBody->Length())); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + if (options.EncryptionKey.HasValue()) + { + request.AddHeader("x-ms-encryption-key", options.EncryptionKey.GetValue()); + } + if (options.EncryptionKeySha256.HasValue()) + { + request.AddHeader("x-ms-encryption-key-sha256", options.EncryptionKeySha256.GetValue()); + } + if (options.EncryptionAlgorithm.HasValue()) + { + request.AddHeader( + "x-ms-encryption-algorithm", + EncryptionAlgorithmTypeToString(options.EncryptionAlgorithm.GetValue())); + } + if (options.EncryptionScope.HasValue()) + { + request.AddHeader("x-ms-encryption-scope", options.EncryptionScope.GetValue()); + } + if (options.TransactionalContentMd5.HasValue()) + { + request.AddHeader("Content-MD5", options.TransactionalContentMd5.GetValue()); + } + if (options.TransactionalContentCrc64.HasValue()) + { + request.AddHeader("x-ms-content-crc64", options.TransactionalContentCrc64.GetValue()); + } + if (!options.HttpHeaders.ContentType.empty()) + { + request.AddHeader("x-ms-blob-content-type", options.HttpHeaders.ContentType); + } + if (!options.HttpHeaders.ContentEncoding.empty()) + { + request.AddHeader("x-ms-blob-content-encoding", options.HttpHeaders.ContentEncoding); + } + if (!options.HttpHeaders.ContentLanguage.empty()) + { + request.AddHeader("x-ms-blob-content-language", options.HttpHeaders.ContentLanguage); + } + if (!options.HttpHeaders.CacheControl.empty()) + { + request.AddHeader("x-ms-blob-cache-control", options.HttpHeaders.CacheControl); + } + if (!options.HttpHeaders.ContentMd5.empty()) + { + request.AddHeader("x-ms-blob-content-md5", options.HttpHeaders.ContentMd5); + } + if (!options.HttpHeaders.ContentDisposition.empty()) + { + request.AddHeader( + "x-ms-blob-content-disposition", options.HttpHeaders.ContentDisposition); + } + std::set metadataKeys; + for (const auto& pair : options.Metadata) + { + if (metadataKeys.insert(Azure::Core::Strings::ToLower(pair.first)).second == false) + { + throw std::runtime_error("duplicate keys in metadata"); + } + request.AddHeader("x-ms-meta-" + pair.first, pair.second); + } + metadataKeys.clear(); + if (options.LeaseId.HasValue()) + { + request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); + } + request.AddHeader("x-ms-blob-type", "BlockBlob"); + if (options.Tier.HasValue()) + { + request.AddHeader("x-ms-access-tier", AccessTierToString(options.Tier.GetValue())); + } + if (options.IfModifiedSince.HasValue()) + { + request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); + } + if (options.IfUnmodifiedSince.HasValue()) + { + request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); + } + if (options.IfMatch.HasValue()) + { + request.AddHeader("If-Match", options.IfMatch.GetValue()); + } + if (options.IfNoneMatch.HasValue()) + { + request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); + } + if (options.IfTags.HasValue()) + { + request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + UploadBlockBlobResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 201)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + response.ETag = httpResponse.GetHeaders().at("etag"); + response.LastModified = httpResponse.GetHeaders().at("last-modified"); + auto response_transactional_content_md5_iterator + = httpResponse.GetHeaders().find("content-md5"); + if (response_transactional_content_md5_iterator != httpResponse.GetHeaders().end()) + { + response.TransactionalContentMd5 = response_transactional_content_md5_iterator->second; + } + auto response_transactional_content_crc64_iterator + = httpResponse.GetHeaders().find("x-ms-content-crc64"); + if (response_transactional_content_crc64_iterator != httpResponse.GetHeaders().end()) + { + response.TransactionalContentCrc64 + = response_transactional_content_crc64_iterator->second; + } + auto response_version_id_iterator = httpResponse.GetHeaders().find("x-ms-version-id"); + if (response_version_id_iterator != httpResponse.GetHeaders().end()) + { + response.VersionId = response_version_id_iterator->second; + } + auto response_server_encrypted_iterator + = httpResponse.GetHeaders().find("x-ms-request-server-encrypted"); + if (response_server_encrypted_iterator != httpResponse.GetHeaders().end()) + { + response.ServerEncrypted = response_server_encrypted_iterator->second == "true"; + } + auto response_encryption_key_sha256_iterator + = httpResponse.GetHeaders().find("x-ms-encryption-key-sha256"); + if (response_encryption_key_sha256_iterator != httpResponse.GetHeaders().end()) + { + response.EncryptionKeySha256 = response_encryption_key_sha256_iterator->second; + } + auto response_encryption_scope_iterator + = httpResponse.GetHeaders().find("x-ms-encryption-scope"); + if (response_encryption_scope_iterator != httpResponse.GetHeaders().end()) + { + response.EncryptionScope = response_encryption_scope_iterator->second; + } + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); } - auto response_lease_state_iterator = httpResponse.GetHeaders().find("x-ms-lease-state"); - if (response_lease_state_iterator != httpResponse.GetHeaders().end()) + + struct StageBlockOptions { - response.LeaseState = BlobLeaseStateFromString(response_lease_state_iterator->second); + Azure::Core::Nullable Timeout; + std::string BlockId; + Azure::Core::Nullable TransactionalContentMd5; + Azure::Core::Nullable TransactionalContentCrc64; + Azure::Core::Nullable LeaseId; + Azure::Core::Nullable EncryptionKey; + Azure::Core::Nullable EncryptionKeySha256; + Azure::Core::Nullable EncryptionAlgorithm; + Azure::Core::Nullable EncryptionScope; + }; // struct StageBlockOptions + + static Azure::Core::Response StageBlock( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + Azure::Core::Http::BodyStream* requestBody, + const StageBlockOptions& options) + { + unused(options); + auto request + = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url, requestBody); + request.AddHeader("Content-Length", std::to_string(requestBody->Length())); + request.GetUrl().AppendQueryParameter("comp", "block"); + request.GetUrl().AppendQueryParameter( + "blockid", Storage::Details::UrlEncodeQueryParameter(options.BlockId)); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + if (options.TransactionalContentMd5.HasValue()) + { + request.AddHeader("Content-MD5", options.TransactionalContentMd5.GetValue()); + } + if (options.TransactionalContentCrc64.HasValue()) + { + request.AddHeader("x-ms-content-crc64", options.TransactionalContentCrc64.GetValue()); + } + if (options.LeaseId.HasValue()) + { + request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); + } + if (options.EncryptionKey.HasValue()) + { + request.AddHeader("x-ms-encryption-key", options.EncryptionKey.GetValue()); + } + if (options.EncryptionKeySha256.HasValue()) + { + request.AddHeader("x-ms-encryption-key-sha256", options.EncryptionKeySha256.GetValue()); + } + if (options.EncryptionAlgorithm.HasValue()) + { + request.AddHeader( + "x-ms-encryption-algorithm", + EncryptionAlgorithmTypeToString(options.EncryptionAlgorithm.GetValue())); + } + if (options.EncryptionScope.HasValue()) + { + request.AddHeader("x-ms-encryption-scope", options.EncryptionScope.GetValue()); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + StageBlockResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 201)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + auto response_transactional_content_md5_iterator + = httpResponse.GetHeaders().find("content-md5"); + if (response_transactional_content_md5_iterator != httpResponse.GetHeaders().end()) + { + response.TransactionalContentMd5 = response_transactional_content_md5_iterator->second; + } + auto response_transactional_content_crc64_iterator + = httpResponse.GetHeaders().find("x-ms-content-crc64"); + if (response_transactional_content_crc64_iterator != httpResponse.GetHeaders().end()) + { + response.TransactionalContentCrc64 + = response_transactional_content_crc64_iterator->second; + } + auto response_server_encrypted_iterator + = httpResponse.GetHeaders().find("x-ms-request-server-encrypted"); + if (response_server_encrypted_iterator != httpResponse.GetHeaders().end()) + { + response.ServerEncrypted = response_server_encrypted_iterator->second == "true"; + } + auto response_encryption_key_sha256_iterator + = httpResponse.GetHeaders().find("x-ms-encryption-key-sha256"); + if (response_encryption_key_sha256_iterator != httpResponse.GetHeaders().end()) + { + response.EncryptionKeySha256 = response_encryption_key_sha256_iterator->second; + } + auto response_encryption_scope_iterator + = httpResponse.GetHeaders().find("x-ms-encryption-scope"); + if (response_encryption_scope_iterator != httpResponse.GetHeaders().end()) + { + response.EncryptionScope = response_encryption_scope_iterator->second; + } + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); } - auto response_lease_duration_iterator - = httpResponse.GetHeaders().find("x-ms-lease-duration"); - if (response_lease_duration_iterator != httpResponse.GetHeaders().end()) + + struct StageBlockFromUriOptions { - response.LeaseDuration = response_lease_duration_iterator->second; + Azure::Core::Nullable Timeout; + std::string BlockId; + std::string SourceUri; + Azure::Core::Nullable> SourceRange; + Azure::Core::Nullable TransactionalContentMd5; + Azure::Core::Nullable TransactionalContentCrc64; + Azure::Core::Nullable LeaseId; + Azure::Core::Nullable EncryptionKey; + Azure::Core::Nullable EncryptionKeySha256; + Azure::Core::Nullable EncryptionAlgorithm; + Azure::Core::Nullable EncryptionScope; + Azure::Core::Nullable SourceIfModifiedSince; + Azure::Core::Nullable SourceIfUnmodifiedSince; + Azure::Core::Nullable SourceIfMatch; + Azure::Core::Nullable SourceIfNoneMatch; + }; // struct StageBlockFromUriOptions + + static Azure::Core::Response StageBlockFromUri( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const StageBlockFromUriOptions& options) + { + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); + request.AddHeader("Content-Length", "0"); + request.GetUrl().AppendQueryParameter("comp", "block"); + request.GetUrl().AppendQueryParameter( + "blockid", Storage::Details::UrlEncodeQueryParameter(options.BlockId)); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + request.AddHeader("x-ms-copy-source", options.SourceUri); + if (options.SourceRange.HasValue()) + { + auto startOffset = options.SourceRange.GetValue().first; + auto endOffset = options.SourceRange.GetValue().second; + if (endOffset != std::numeric_limits::max()) + { + request.AddHeader( + "x-ms-source_range", + "bytes=" + std::to_string(startOffset) + "-" + std::to_string(endOffset)); + } + else + { + request.AddHeader("x-ms-source_range", "bytes=" + std::to_string(startOffset) + "-"); + } + } + if (options.TransactionalContentMd5.HasValue()) + { + request.AddHeader( + "x-ms-source-content-md5", options.TransactionalContentMd5.GetValue()); + } + if (options.TransactionalContentCrc64.HasValue()) + { + request.AddHeader( + "x-ms-source-content-crc64", options.TransactionalContentCrc64.GetValue()); + } + if (options.LeaseId.HasValue()) + { + request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); + } + if (options.EncryptionKey.HasValue()) + { + request.AddHeader("x-ms-encryption-key", options.EncryptionKey.GetValue()); + } + if (options.EncryptionKeySha256.HasValue()) + { + request.AddHeader("x-ms-encryption-key-sha256", options.EncryptionKeySha256.GetValue()); + } + if (options.EncryptionAlgorithm.HasValue()) + { + request.AddHeader( + "x-ms-encryption-algorithm", + EncryptionAlgorithmTypeToString(options.EncryptionAlgorithm.GetValue())); + } + if (options.EncryptionScope.HasValue()) + { + request.AddHeader("x-ms-encryption-scope", options.EncryptionScope.GetValue()); + } + if (options.SourceIfModifiedSince.HasValue()) + { + request.AddHeader( + "x-ms-source-if-modified-since", options.SourceIfModifiedSince.GetValue()); + } + if (options.SourceIfUnmodifiedSince.HasValue()) + { + request.AddHeader( + "x-ms-source-if-unmodified-since", options.SourceIfUnmodifiedSince.GetValue()); + } + if (options.SourceIfMatch.HasValue()) + { + request.AddHeader("x-ms-source-if-match", options.SourceIfMatch.GetValue()); + } + if (options.SourceIfNoneMatch.HasValue()) + { + request.AddHeader("x-ms-source-if-none-match", options.SourceIfNoneMatch.GetValue()); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + StageBlockFromUriResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 201)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + auto response_transactional_content_md5_iterator + = httpResponse.GetHeaders().find("content-md5"); + if (response_transactional_content_md5_iterator != httpResponse.GetHeaders().end()) + { + response.TransactionalContentMd5 = response_transactional_content_md5_iterator->second; + } + auto response_transactional_content_crc64_iterator + = httpResponse.GetHeaders().find("x-ms-content-crc64"); + if (response_transactional_content_crc64_iterator != httpResponse.GetHeaders().end()) + { + response.TransactionalContentCrc64 + = response_transactional_content_crc64_iterator->second; + } + auto response_server_encrypted_iterator + = httpResponse.GetHeaders().find("x-ms-request-server-encrypted"); + if (response_server_encrypted_iterator != httpResponse.GetHeaders().end()) + { + response.ServerEncrypted = response_server_encrypted_iterator->second == "true"; + } + auto response_encryption_key_sha256_iterator + = httpResponse.GetHeaders().find("x-ms-encryption-key-sha256"); + if (response_encryption_key_sha256_iterator != httpResponse.GetHeaders().end()) + { + response.EncryptionKeySha256 = response_encryption_key_sha256_iterator->second; + } + auto response_encryption_scope_iterator + = httpResponse.GetHeaders().find("x-ms-encryption-scope"); + if (response_encryption_scope_iterator != httpResponse.GetHeaders().end()) + { + response.EncryptionScope = response_encryption_scope_iterator->second; + } + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); } - response.CreationTime = httpResponse.GetHeaders().at("x-ms-creation-time"); - auto response_expiry_time_iterator = httpResponse.GetHeaders().find("x-ms-expiry-time"); - if (response_expiry_time_iterator != httpResponse.GetHeaders().end()) + + struct CommitBlockListOptions { - response.ExpiryTime = response_expiry_time_iterator->second; + Azure::Core::Nullable Timeout; + std::vector> BlockList; + BlobHttpHeaders HttpHeaders; + std::map Metadata; + Azure::Core::Nullable LeaseId; + Azure::Core::Nullable EncryptionKey; + Azure::Core::Nullable EncryptionKeySha256; + Azure::Core::Nullable EncryptionAlgorithm; + Azure::Core::Nullable EncryptionScope; + Azure::Core::Nullable IfModifiedSince; + Azure::Core::Nullable IfUnmodifiedSince; + Azure::Core::Nullable IfMatch; + Azure::Core::Nullable IfNoneMatch; + Azure::Core::Nullable IfTags; + Azure::Core::Nullable Tier; + }; // struct CommitBlockListOptions + + static Azure::Core::Response CommitBlockList( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const CommitBlockListOptions& options) + { + unused(options); + std::string xml_body; + { + XmlWriter writer; + CommitBlockListOptionsToXml(writer, options); + xml_body = writer.GetDocument(); + writer.Write(XmlNode{XmlNodeType::End}); + } + Azure::Core::Http::MemoryBodyStream xml_body_stream( + reinterpret_cast(xml_body.data()), xml_body.length()); + auto request = Azure::Core::Http::Request( + Azure::Core::Http::HttpMethod::Put, url, &xml_body_stream); + request.AddHeader("Content-Length", std::to_string(xml_body_stream.Length())); + request.GetUrl().AppendQueryParameter("comp", "blocklist"); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + if (!options.HttpHeaders.ContentType.empty()) + { + request.AddHeader("x-ms-blob-content-type", options.HttpHeaders.ContentType); + } + if (!options.HttpHeaders.ContentEncoding.empty()) + { + request.AddHeader("x-ms-blob-content-encoding", options.HttpHeaders.ContentEncoding); + } + if (!options.HttpHeaders.ContentLanguage.empty()) + { + request.AddHeader("x-ms-blob-content-language", options.HttpHeaders.ContentLanguage); + } + if (!options.HttpHeaders.CacheControl.empty()) + { + request.AddHeader("x-ms-blob-cache-control", options.HttpHeaders.CacheControl); + } + if (!options.HttpHeaders.ContentMd5.empty()) + { + request.AddHeader("x-ms-blob-content-md5", options.HttpHeaders.ContentMd5); + } + if (!options.HttpHeaders.ContentDisposition.empty()) + { + request.AddHeader( + "x-ms-blob-content-disposition", options.HttpHeaders.ContentDisposition); + } + std::set metadataKeys; + for (const auto& pair : options.Metadata) + { + if (metadataKeys.insert(Azure::Core::Strings::ToLower(pair.first)).second == false) + { + throw std::runtime_error("duplicate keys in metadata"); + } + request.AddHeader("x-ms-meta-" + pair.first, pair.second); + } + metadataKeys.clear(); + if (options.LeaseId.HasValue()) + { + request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); + } + if (options.EncryptionKey.HasValue()) + { + request.AddHeader("x-ms-encryption-key", options.EncryptionKey.GetValue()); + } + if (options.EncryptionKeySha256.HasValue()) + { + request.AddHeader("x-ms-encryption-key-sha256", options.EncryptionKeySha256.GetValue()); + } + if (options.EncryptionAlgorithm.HasValue()) + { + request.AddHeader( + "x-ms-encryption-algorithm", + EncryptionAlgorithmTypeToString(options.EncryptionAlgorithm.GetValue())); + } + if (options.EncryptionScope.HasValue()) + { + request.AddHeader("x-ms-encryption-scope", options.EncryptionScope.GetValue()); + } + if (options.Tier.HasValue()) + { + request.AddHeader("x-ms-access-tier", AccessTierToString(options.Tier.GetValue())); + } + if (options.IfModifiedSince.HasValue()) + { + request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); + } + if (options.IfUnmodifiedSince.HasValue()) + { + request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); + } + if (options.IfMatch.HasValue()) + { + request.AddHeader("If-Match", options.IfMatch.GetValue()); + } + if (options.IfNoneMatch.HasValue()) + { + request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); + } + if (options.IfTags.HasValue()) + { + request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + CommitBlockListResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 201)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + response.ETag = httpResponse.GetHeaders().at("etag"); + response.LastModified = httpResponse.GetHeaders().at("last-modified"); + auto response_version_id_iterator = httpResponse.GetHeaders().find("x-ms-version-id"); + if (response_version_id_iterator != httpResponse.GetHeaders().end()) + { + response.VersionId = response_version_id_iterator->second; + } + auto response_server_encrypted_iterator + = httpResponse.GetHeaders().find("x-ms-request-server-encrypted"); + if (response_server_encrypted_iterator != httpResponse.GetHeaders().end()) + { + response.ServerEncrypted = response_server_encrypted_iterator->second == "true"; + } + auto response_encryption_key_sha256_iterator + = httpResponse.GetHeaders().find("x-ms-encryption-key-sha256"); + if (response_encryption_key_sha256_iterator != httpResponse.GetHeaders().end()) + { + response.EncryptionKeySha256 = response_encryption_key_sha256_iterator->second; + } + auto response_encryption_scope_iterator + = httpResponse.GetHeaders().find("x-ms-encryption-scope"); + if (response_encryption_scope_iterator != httpResponse.GetHeaders().end()) + { + response.EncryptionScope = response_encryption_scope_iterator->second; + } + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); } - auto response_last_access_time_iterator - = httpResponse.GetHeaders().find("x-ms-last-access-time"); - if (response_last_access_time_iterator != httpResponse.GetHeaders().end()) + + struct GetBlockListOptions { - response.LastAccessTime = response_last_access_time_iterator->second; + Azure::Core::Nullable Timeout; + Azure::Core::Nullable ListType; + Azure::Core::Nullable LeaseId; + Azure::Core::Nullable IfTags; + }; // struct GetBlockListOptions + + static Azure::Core::Response GetBlockList( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const GetBlockListOptions& options) + { + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url); + request.GetUrl().AppendQueryParameter("comp", "blocklist"); + if (options.ListType.HasValue()) + { + std::string block_list_type_option + = BlockListTypeOptionToString(options.ListType.GetValue()); + request.GetUrl().AppendQueryParameter( + "blocklisttype", Storage::Details::UrlEncodeQueryParameter(block_list_type_option)); + } + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + if (options.LeaseId.HasValue()) + { + request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); + } + if (options.IfTags.HasValue()) + { + request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + GetBlockListResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 200)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + { + const auto& httpResponseBody = httpResponse.GetBody(); + XmlReader reader( + reinterpret_cast(httpResponseBody.data()), httpResponseBody.size()); + response = GetBlockListResultFromXml(reader); + } + response.ETag = httpResponse.GetHeaders().at("etag"); + response.LastModified = httpResponse.GetHeaders().at("last-modified"); + response.ContentType = httpResponse.GetHeaders().at("content-type"); + response.ContentLength + = std::stoll(httpResponse.GetHeaders().at("x-ms-blob-content-length")); + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); } - auto response_content_range_iterator = httpResponse.GetHeaders().find("content-range"); - if (response_content_range_iterator != httpResponse.GetHeaders().end()) + + private: + static GetBlockListResult GetBlockListResultFromXml(XmlReader& reader) { - response.ContentRange = response_content_range_iterator->second; + GetBlockListResult ret; + enum class XmlTagName + { + k_BlockList, + k_CommittedBlocks, + k_Block, + k_UncommittedBlocks, + k_Unknown, + }; + std::vector path; + while (true) + { + auto node = reader.Read(); + if (node.Type == XmlNodeType::End) + { + break; + } + else if (node.Type == XmlNodeType::EndTag) + { + if (path.size() > 0) + { + path.pop_back(); + } + else + { + break; + } + } + else if (node.Type == XmlNodeType::StartTag) + { + if (std::strcmp(node.Name, "BlockList") == 0) + { + path.emplace_back(XmlTagName::k_BlockList); + } + else if (std::strcmp(node.Name, "CommittedBlocks") == 0) + { + path.emplace_back(XmlTagName::k_CommittedBlocks); + } + else if (std::strcmp(node.Name, "Block") == 0) + { + path.emplace_back(XmlTagName::k_Block); + } + else if (std::strcmp(node.Name, "UncommittedBlocks") == 0) + { + path.emplace_back(XmlTagName::k_UncommittedBlocks); + } + else + { + path.emplace_back(XmlTagName::k_Unknown); + } + if (path.size() == 3 && path[0] == XmlTagName::k_BlockList + && path[1] == XmlTagName::k_CommittedBlocks && path[2] == XmlTagName::k_Block) + { + ret.CommittedBlocks.emplace_back(BlobBlockFromXml(reader)); + path.pop_back(); + } + else if ( + path.size() == 3 && path[0] == XmlTagName::k_BlockList + && path[1] == XmlTagName::k_UncommittedBlocks && path[2] == XmlTagName::k_Block) + { + ret.UncommittedBlocks.emplace_back(BlobBlockFromXml(reader)); + path.pop_back(); + } + } + else if (node.Type == XmlNodeType::Text) + { + } + } + return ret; } - auto response_sequence_number_iterator - = httpResponse.GetHeaders().find("x-ms-blob-sequence-number"); - if (response_sequence_number_iterator != httpResponse.GetHeaders().end()) + + static BlobBlock BlobBlockFromXml(XmlReader& reader) { - response.SequenceNumber = std::stoll(response_sequence_number_iterator->second); + BlobBlock ret; + enum class XmlTagName + { + k_Name, + k_Size, + k_Unknown, + }; + std::vector path; + while (true) + { + auto node = reader.Read(); + if (node.Type == XmlNodeType::End) + { + break; + } + else if (node.Type == XmlNodeType::EndTag) + { + if (path.size() > 0) + { + path.pop_back(); + } + else + { + break; + } + } + else if (node.Type == XmlNodeType::StartTag) + { + if (std::strcmp(node.Name, "Name") == 0) + { + path.emplace_back(XmlTagName::k_Name); + } + else if (std::strcmp(node.Name, "Size") == 0) + { + path.emplace_back(XmlTagName::k_Size); + } + else + { + path.emplace_back(XmlTagName::k_Unknown); + } + } + else if (node.Type == XmlNodeType::Text) + { + if (path.size() == 1 && path[0] == XmlTagName::k_Name) + { + ret.Name = node.Value; + } + else if (path.size() == 1 && path[0] == XmlTagName::k_Size) + { + ret.Size = std::stoll(node.Value); + } + } + } + return ret; } - auto response_committed_block_count_iterator - = httpResponse.GetHeaders().find("x-ms-blob-committed-block-count"); - if (response_committed_block_count_iterator != httpResponse.GetHeaders().end()) + + static void CommitBlockListOptionsToXml( + XmlWriter& writer, + const CommitBlockListOptions& options) { + writer.Write(XmlNode{XmlNodeType::StartTag, "BlockList"}); + for (const auto& i : options.BlockList) + { + writer.Write( + XmlNode{XmlNodeType::StartTag, BlockTypeToString(i.first).data(), i.second.data()}); + } + writer.Write(XmlNode{XmlNodeType::EndTag}); + } + + }; // class BlockBlob + + class PageBlob { + public: + struct CreatePageBlobOptions + { + Azure::Core::Nullable Timeout; + int64_t BlobContentLength = -1; + Azure::Core::Nullable SequenceNumber; + BlobHttpHeaders HttpHeaders; + std::map Metadata; + Azure::Core::Nullable LeaseId; + Azure::Core::Nullable Tier; + Azure::Core::Nullable EncryptionKey; + Azure::Core::Nullable EncryptionKeySha256; + Azure::Core::Nullable EncryptionAlgorithm; + Azure::Core::Nullable EncryptionScope; + Azure::Core::Nullable IfModifiedSince; + Azure::Core::Nullable IfUnmodifiedSince; + Azure::Core::Nullable IfMatch; + Azure::Core::Nullable IfNoneMatch; + Azure::Core::Nullable IfTags; + }; // struct CreatePageBlobOptions + + static Azure::Core::Response Create( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const CreatePageBlobOptions& options) + { + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); + request.AddHeader("Content-Length", "0"); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + if (!options.HttpHeaders.ContentType.empty()) + { + request.AddHeader("x-ms-blob-content-type", options.HttpHeaders.ContentType); + } + if (!options.HttpHeaders.ContentEncoding.empty()) + { + request.AddHeader("x-ms-blob-content-encoding", options.HttpHeaders.ContentEncoding); + } + if (!options.HttpHeaders.ContentLanguage.empty()) + { + request.AddHeader("x-ms-blob-content-language", options.HttpHeaders.ContentLanguage); + } + if (!options.HttpHeaders.CacheControl.empty()) + { + request.AddHeader("x-ms-blob-cache-control", options.HttpHeaders.CacheControl); + } + if (!options.HttpHeaders.ContentMd5.empty()) + { + request.AddHeader("x-ms-blob-content-md5", options.HttpHeaders.ContentMd5); + } + if (!options.HttpHeaders.ContentDisposition.empty()) + { + request.AddHeader( + "x-ms-blob-content-disposition", options.HttpHeaders.ContentDisposition); + } + std::set metadataKeys; + for (const auto& pair : options.Metadata) + { + if (metadataKeys.insert(Azure::Core::Strings::ToLower(pair.first)).second == false) + { + throw std::runtime_error("duplicate keys in metadata"); + } + request.AddHeader("x-ms-meta-" + pair.first, pair.second); + } + metadataKeys.clear(); + if (options.LeaseId.HasValue()) + { + request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); + } + request.AddHeader("x-ms-blob-type", "PageBlob"); + request.AddHeader("x-ms-blob-content-length", std::to_string(options.BlobContentLength)); + if (options.SequenceNumber.HasValue()) + { + request.AddHeader( + "x-ms-blob-sequence-number", std::to_string(options.SequenceNumber.GetValue())); + } + if (options.Tier.HasValue()) + { + request.AddHeader("x-ms-access-tier", AccessTierToString(options.Tier.GetValue())); + } + if (options.EncryptionKey.HasValue()) + { + request.AddHeader("x-ms-encryption-key", options.EncryptionKey.GetValue()); + } + if (options.EncryptionKeySha256.HasValue()) + { + request.AddHeader("x-ms-encryption-key-sha256", options.EncryptionKeySha256.GetValue()); + } + if (options.EncryptionAlgorithm.HasValue()) + { + request.AddHeader( + "x-ms-encryption-algorithm", + EncryptionAlgorithmTypeToString(options.EncryptionAlgorithm.GetValue())); + } + if (options.EncryptionScope.HasValue()) + { + request.AddHeader("x-ms-encryption-scope", options.EncryptionScope.GetValue()); + } + if (options.IfModifiedSince.HasValue()) + { + request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); + } + if (options.IfUnmodifiedSince.HasValue()) + { + request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); + } + if (options.IfMatch.HasValue()) + { + request.AddHeader("If-Match", options.IfMatch.GetValue()); + } + if (options.IfNoneMatch.HasValue()) + { + request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); + } + if (options.IfTags.HasValue()) + { + request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + CreatePageBlobResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 201)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + response.ETag = httpResponse.GetHeaders().at("etag"); + response.LastModified = httpResponse.GetHeaders().at("last-modified"); + auto response_version_id_iterator = httpResponse.GetHeaders().find("x-ms-version-id"); + if (response_version_id_iterator != httpResponse.GetHeaders().end()) + { + response.VersionId = response_version_id_iterator->second; + } + auto response_server_encrypted_iterator + = httpResponse.GetHeaders().find("x-ms-request-server-encrypted"); + if (response_server_encrypted_iterator != httpResponse.GetHeaders().end()) + { + response.ServerEncrypted = response_server_encrypted_iterator->second == "true"; + } + auto response_encryption_key_sha256_iterator + = httpResponse.GetHeaders().find("x-ms-encryption-key-sha256"); + if (response_encryption_key_sha256_iterator != httpResponse.GetHeaders().end()) + { + response.EncryptionKeySha256 = response_encryption_key_sha256_iterator->second; + } + auto response_encryption_scope_iterator + = httpResponse.GetHeaders().find("x-ms-encryption-scope"); + if (response_encryption_scope_iterator != httpResponse.GetHeaders().end()) + { + response.EncryptionScope = response_encryption_scope_iterator->second; + } + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); + } + + struct UploadPageBlobPagesOptions + { + Azure::Core::Nullable Timeout; + std::pair Range; + Azure::Core::Nullable TransactionalContentMd5; + Azure::Core::Nullable TransactionalContentCrc64; + Azure::Core::Nullable LeaseId; + Azure::Core::Nullable IfSequenceNumberLessThanOrEqualTo; + Azure::Core::Nullable IfSequenceNumberLessThan; + Azure::Core::Nullable IfSequenceNumberEqualTo; + Azure::Core::Nullable EncryptionKey; + Azure::Core::Nullable EncryptionKeySha256; + Azure::Core::Nullable EncryptionAlgorithm; + Azure::Core::Nullable EncryptionScope; + Azure::Core::Nullable IfModifiedSince; + Azure::Core::Nullable IfUnmodifiedSince; + Azure::Core::Nullable IfMatch; + Azure::Core::Nullable IfNoneMatch; + Azure::Core::Nullable IfTags; + }; // struct UploadPageBlobPagesOptions + + static Azure::Core::Response UploadPages( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + Azure::Core::Http::BodyStream* requestBody, + const UploadPageBlobPagesOptions& options) + { + unused(options); + auto request + = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url, requestBody); + request.AddHeader("Content-Length", std::to_string(requestBody->Length())); + request.GetUrl().AppendQueryParameter("comp", "page"); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + request.AddHeader( + "x-ms-range", + "bytes=" + std::to_string(options.Range.first) + "-" + + std::to_string(options.Range.second)); + if (options.TransactionalContentMd5.HasValue()) + { + request.AddHeader("Content-MD5", options.TransactionalContentMd5.GetValue()); + } + if (options.TransactionalContentCrc64.HasValue()) + { + request.AddHeader("x-ms-content-crc64", options.TransactionalContentCrc64.GetValue()); + } + request.AddHeader("x-ms-page-write", "update"); + if (options.LeaseId.HasValue()) + { + request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); + } + if (options.IfSequenceNumberLessThanOrEqualTo.HasValue()) + { + request.AddHeader( + "x-ms-if-sequence-number-le", + std::to_string(options.IfSequenceNumberLessThanOrEqualTo.GetValue())); + } + if (options.IfSequenceNumberLessThan.HasValue()) + { + request.AddHeader( + "x-ms-if-sequence-number-lt", + std::to_string(options.IfSequenceNumberLessThan.GetValue())); + } + if (options.IfSequenceNumberEqualTo.HasValue()) + { + request.AddHeader( + "x-ms-if-sequence-number-eq", + std::to_string(options.IfSequenceNumberEqualTo.GetValue())); + } + if (options.EncryptionKey.HasValue()) + { + request.AddHeader("x-ms-encryption-key", options.EncryptionKey.GetValue()); + } + if (options.EncryptionKeySha256.HasValue()) + { + request.AddHeader("x-ms-encryption-key-sha256", options.EncryptionKeySha256.GetValue()); + } + if (options.EncryptionAlgorithm.HasValue()) + { + request.AddHeader( + "x-ms-encryption-algorithm", + EncryptionAlgorithmTypeToString(options.EncryptionAlgorithm.GetValue())); + } + if (options.EncryptionScope.HasValue()) + { + request.AddHeader("x-ms-encryption-scope", options.EncryptionScope.GetValue()); + } + if (options.IfModifiedSince.HasValue()) + { + request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); + } + if (options.IfUnmodifiedSince.HasValue()) + { + request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); + } + if (options.IfMatch.HasValue()) + { + request.AddHeader("If-Match", options.IfMatch.GetValue()); + } + if (options.IfNoneMatch.HasValue()) + { + request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); + } + if (options.IfTags.HasValue()) + { + request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + UploadPageBlobPagesResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 201)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + response.ETag = httpResponse.GetHeaders().at("etag"); + response.LastModified = httpResponse.GetHeaders().at("last-modified"); + auto response_transactional_content_md5_iterator + = httpResponse.GetHeaders().find("content-md5"); + if (response_transactional_content_md5_iterator != httpResponse.GetHeaders().end()) + { + response.TransactionalContentMd5 = response_transactional_content_md5_iterator->second; + } + auto response_transactional_content_crc64_iterator + = httpResponse.GetHeaders().find("x-ms-content-crc64"); + if (response_transactional_content_crc64_iterator != httpResponse.GetHeaders().end()) + { + response.TransactionalContentCrc64 + = response_transactional_content_crc64_iterator->second; + } + response.SequenceNumber + = std::stoll(httpResponse.GetHeaders().at("x-ms-blob-sequence-number")); + auto response_server_encrypted_iterator + = httpResponse.GetHeaders().find("x-ms-request-server-encrypted"); + if (response_server_encrypted_iterator != httpResponse.GetHeaders().end()) + { + response.ServerEncrypted = response_server_encrypted_iterator->second == "true"; + } + auto response_encryption_key_sha256_iterator + = httpResponse.GetHeaders().find("x-ms-encryption-key-sha256"); + if (response_encryption_key_sha256_iterator != httpResponse.GetHeaders().end()) + { + response.EncryptionKeySha256 = response_encryption_key_sha256_iterator->second; + } + auto response_encryption_scope_iterator + = httpResponse.GetHeaders().find("x-ms-encryption-scope"); + if (response_encryption_scope_iterator != httpResponse.GetHeaders().end()) + { + response.EncryptionScope = response_encryption_scope_iterator->second; + } + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); + } + + struct UploadPageBlobPagesFromUriOptions + { + Azure::Core::Nullable Timeout; + std::string SourceUri; + std::pair SourceRange; + std::pair Range; + Azure::Core::Nullable TransactionalContentMd5; + Azure::Core::Nullable TransactionalContentCrc64; + Azure::Core::Nullable LeaseId; + Azure::Core::Nullable IfSequenceNumberLessThanOrEqualTo; + Azure::Core::Nullable IfSequenceNumberLessThan; + Azure::Core::Nullable IfSequenceNumberEqualTo; + Azure::Core::Nullable EncryptionKey; + Azure::Core::Nullable EncryptionKeySha256; + Azure::Core::Nullable EncryptionAlgorithm; + Azure::Core::Nullable EncryptionScope; + Azure::Core::Nullable IfModifiedSince; + Azure::Core::Nullable IfUnmodifiedSince; + Azure::Core::Nullable IfMatch; + Azure::Core::Nullable IfNoneMatch; + Azure::Core::Nullable IfTags; + }; // struct UploadPageBlobPagesFromUriOptions + + static Azure::Core::Response UploadPagesFromUri( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const UploadPageBlobPagesFromUriOptions& options) + { + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); + request.AddHeader("Content-Length", "0"); + request.GetUrl().AppendQueryParameter("comp", "page"); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + request.AddHeader( + "x-ms-range", + "bytes=" + std::to_string(options.Range.first) + "-" + + std::to_string(options.Range.second)); + request.AddHeader("x-ms-copy-source", options.SourceUri); + request.AddHeader( + "x-ms-source-range", + "bytes=" + std::to_string(options.SourceRange.first) + "-" + + std::to_string(options.SourceRange.second)); + if (options.TransactionalContentMd5.HasValue()) + { + request.AddHeader( + "x-ms-source-content-md5", options.TransactionalContentMd5.GetValue()); + } + if (options.TransactionalContentCrc64.HasValue()) + { + request.AddHeader( + "x-ms-source-content-crc64", options.TransactionalContentCrc64.GetValue()); + } + request.AddHeader("x-ms-page-write", "update"); + if (options.LeaseId.HasValue()) + { + request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); + } + if (options.IfSequenceNumberLessThanOrEqualTo.HasValue()) + { + request.AddHeader( + "x-ms-if-sequence-number-le", + std::to_string(options.IfSequenceNumberLessThanOrEqualTo.GetValue())); + } + if (options.IfSequenceNumberLessThan.HasValue()) + { + request.AddHeader( + "x-ms-if-sequence-number-lt", + std::to_string(options.IfSequenceNumberLessThan.GetValue())); + } + if (options.IfSequenceNumberEqualTo.HasValue()) + { + request.AddHeader( + "x-ms-if-sequence-number-eq", + std::to_string(options.IfSequenceNumberEqualTo.GetValue())); + } + if (options.EncryptionKey.HasValue()) + { + request.AddHeader("x-ms-encryption-key", options.EncryptionKey.GetValue()); + } + if (options.EncryptionKeySha256.HasValue()) + { + request.AddHeader("x-ms-encryption-key-sha256", options.EncryptionKeySha256.GetValue()); + } + if (options.EncryptionAlgorithm.HasValue()) + { + request.AddHeader( + "x-ms-encryption-algorithm", + EncryptionAlgorithmTypeToString(options.EncryptionAlgorithm.GetValue())); + } + if (options.EncryptionScope.HasValue()) + { + request.AddHeader("x-ms-encryption-scope", options.EncryptionScope.GetValue()); + } + if (options.IfModifiedSince.HasValue()) + { + request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); + } + if (options.IfUnmodifiedSince.HasValue()) + { + request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); + } + if (options.IfMatch.HasValue()) + { + request.AddHeader("If-Match", options.IfMatch.GetValue()); + } + if (options.IfNoneMatch.HasValue()) + { + request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); + } + if (options.IfTags.HasValue()) + { + request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + UploadPageBlobPagesFromUriResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 201)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + response.ETag = httpResponse.GetHeaders().at("etag"); + response.LastModified = httpResponse.GetHeaders().at("last-modified"); + auto response_transactional_content_md5_iterator + = httpResponse.GetHeaders().find("content-md5"); + if (response_transactional_content_md5_iterator != httpResponse.GetHeaders().end()) + { + response.TransactionalContentMd5 = response_transactional_content_md5_iterator->second; + } + auto response_transactional_content_crc64_iterator + = httpResponse.GetHeaders().find("x-ms-content-crc64"); + if (response_transactional_content_crc64_iterator != httpResponse.GetHeaders().end()) + { + response.TransactionalContentCrc64 + = response_transactional_content_crc64_iterator->second; + } + response.SequenceNumber + = std::stoll(httpResponse.GetHeaders().at("x-ms-blob-sequence-number")); + auto response_server_encrypted_iterator + = httpResponse.GetHeaders().find("x-ms-request-server-encrypted"); + if (response_server_encrypted_iterator != httpResponse.GetHeaders().end()) + { + response.ServerEncrypted = response_server_encrypted_iterator->second == "true"; + } + auto response_encryption_key_sha256_iterator + = httpResponse.GetHeaders().find("x-ms-encryption-key-sha256"); + if (response_encryption_key_sha256_iterator != httpResponse.GetHeaders().end()) + { + response.EncryptionKeySha256 = response_encryption_key_sha256_iterator->second; + } + auto response_encryption_scope_iterator + = httpResponse.GetHeaders().find("x-ms-encryption-scope"); + if (response_encryption_scope_iterator != httpResponse.GetHeaders().end()) + { + response.EncryptionScope = response_encryption_scope_iterator->second; + } + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); + } + + struct ClearPageBlobPagesOptions + { + Azure::Core::Nullable Timeout; + std::pair Range; + Azure::Core::Nullable LeaseId; + Azure::Core::Nullable IfSequenceNumberLessThanOrEqualTo; + Azure::Core::Nullable IfSequenceNumberLessThan; + Azure::Core::Nullable IfSequenceNumberEqualTo; + Azure::Core::Nullable EncryptionKey; + Azure::Core::Nullable EncryptionKeySha256; + Azure::Core::Nullable EncryptionAlgorithm; + Azure::Core::Nullable EncryptionScope; + Azure::Core::Nullable IfModifiedSince; + Azure::Core::Nullable IfUnmodifiedSince; + Azure::Core::Nullable IfMatch; + Azure::Core::Nullable IfNoneMatch; + Azure::Core::Nullable IfTags; + }; // struct ClearPageBlobPagesOptions + + static Azure::Core::Response ClearPages( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const ClearPageBlobPagesOptions& options) + { + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); + request.AddHeader("Content-Length", "0"); + request.GetUrl().AppendQueryParameter("comp", "page"); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + request.AddHeader( + "x-ms-range", + "bytes=" + std::to_string(options.Range.first) + "-" + + std::to_string(options.Range.second)); + request.AddHeader("x-ms-page-write", "clear"); + if (options.LeaseId.HasValue()) + { + request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); + } + if (options.IfSequenceNumberLessThanOrEqualTo.HasValue()) + { + request.AddHeader( + "x-ms-if-sequence-number-le", + std::to_string(options.IfSequenceNumberLessThanOrEqualTo.GetValue())); + } + if (options.IfSequenceNumberLessThan.HasValue()) + { + request.AddHeader( + "x-ms-if-sequence-number-lt", + std::to_string(options.IfSequenceNumberLessThan.GetValue())); + } + if (options.IfSequenceNumberEqualTo.HasValue()) + { + request.AddHeader( + "x-ms-if-sequence-number-eq", + std::to_string(options.IfSequenceNumberEqualTo.GetValue())); + } + if (options.EncryptionKey.HasValue()) + { + request.AddHeader("x-ms-encryption-key", options.EncryptionKey.GetValue()); + } + if (options.EncryptionKeySha256.HasValue()) + { + request.AddHeader("x-ms-encryption-key-sha256", options.EncryptionKeySha256.GetValue()); + } + if (options.EncryptionAlgorithm.HasValue()) + { + request.AddHeader( + "x-ms-encryption-algorithm", + EncryptionAlgorithmTypeToString(options.EncryptionAlgorithm.GetValue())); + } + if (options.EncryptionScope.HasValue()) + { + request.AddHeader("x-ms-encryption-scope", options.EncryptionScope.GetValue()); + } + if (options.IfModifiedSince.HasValue()) + { + request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); + } + if (options.IfUnmodifiedSince.HasValue()) + { + request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); + } + if (options.IfMatch.HasValue()) + { + request.AddHeader("If-Match", options.IfMatch.GetValue()); + } + if (options.IfNoneMatch.HasValue()) + { + request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); + } + if (options.IfTags.HasValue()) + { + request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + ClearPageBlobPagesResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 201)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + response.ETag = httpResponse.GetHeaders().at("etag"); + response.LastModified = httpResponse.GetHeaders().at("last-modified"); + response.SequenceNumber + = std::stoll(httpResponse.GetHeaders().at("x-ms-blob-sequence-number")); + auto response_server_encrypted_iterator + = httpResponse.GetHeaders().find("x-ms-request-server-encrypted"); + if (response_server_encrypted_iterator != httpResponse.GetHeaders().end()) + { + response.ServerEncrypted = response_server_encrypted_iterator->second == "true"; + } + auto response_encryption_key_sha256_iterator + = httpResponse.GetHeaders().find("x-ms-encryption-key-sha256"); + if (response_encryption_key_sha256_iterator != httpResponse.GetHeaders().end()) + { + response.EncryptionKeySha256 = response_encryption_key_sha256_iterator->second; + } + auto response_encryption_scope_iterator + = httpResponse.GetHeaders().find("x-ms-encryption-scope"); + if (response_encryption_scope_iterator != httpResponse.GetHeaders().end()) + { + response.EncryptionScope = response_encryption_scope_iterator->second; + } + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); + } + + struct ResizePageBlobOptions + { + Azure::Core::Nullable Timeout; + int64_t BlobContentLength = -1; + Azure::Core::Nullable LeaseId; + Azure::Core::Nullable IfSequenceNumberLessThanOrEqualTo; + Azure::Core::Nullable IfSequenceNumberLessThan; + Azure::Core::Nullable IfSequenceNumberEqualTo; + Azure::Core::Nullable EncryptionKey; + Azure::Core::Nullable EncryptionKeySha256; + Azure::Core::Nullable EncryptionAlgorithm; + Azure::Core::Nullable EncryptionScope; + Azure::Core::Nullable IfModifiedSince; + Azure::Core::Nullable IfUnmodifiedSince; + Azure::Core::Nullable IfMatch; + Azure::Core::Nullable IfNoneMatch; + Azure::Core::Nullable IfTags; + }; // struct ResizePageBlobOptions + + static Azure::Core::Response Resize( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const ResizePageBlobOptions& options) + { + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); + request.AddHeader("Content-Length", "0"); + request.GetUrl().AppendQueryParameter("comp", "properties"); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + request.AddHeader("x-ms-blob-content-length", std::to_string(options.BlobContentLength)); + if (options.LeaseId.HasValue()) + { + request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); + } + if (options.IfSequenceNumberLessThanOrEqualTo.HasValue()) + { + request.AddHeader( + "x-ms-if-sequence-number-le", + std::to_string(options.IfSequenceNumberLessThanOrEqualTo.GetValue())); + } + if (options.IfSequenceNumberLessThan.HasValue()) + { + request.AddHeader( + "x-ms-if-sequence-number-lt", + std::to_string(options.IfSequenceNumberLessThan.GetValue())); + } + if (options.IfSequenceNumberEqualTo.HasValue()) + { + request.AddHeader( + "x-ms-if-sequence-number-eq", + std::to_string(options.IfSequenceNumberEqualTo.GetValue())); + } + if (options.EncryptionKey.HasValue()) + { + request.AddHeader("x-ms-encryption-key", options.EncryptionKey.GetValue()); + } + if (options.EncryptionKeySha256.HasValue()) + { + request.AddHeader("x-ms-encryption-key-sha256", options.EncryptionKeySha256.GetValue()); + } + if (options.EncryptionAlgorithm.HasValue()) + { + request.AddHeader( + "x-ms-encryption-algorithm", + EncryptionAlgorithmTypeToString(options.EncryptionAlgorithm.GetValue())); + } + if (options.EncryptionScope.HasValue()) + { + request.AddHeader("x-ms-encryption-scope", options.EncryptionScope.GetValue()); + } + if (options.IfModifiedSince.HasValue()) + { + request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); + } + if (options.IfUnmodifiedSince.HasValue()) + { + request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); + } + if (options.IfMatch.HasValue()) + { + request.AddHeader("If-Match", options.IfMatch.GetValue()); + } + if (options.IfNoneMatch.HasValue()) + { + request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); + } + if (options.IfTags.HasValue()) + { + request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + ResizePageBlobResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 200)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + response.ETag = httpResponse.GetHeaders().at("etag"); + response.LastModified = httpResponse.GetHeaders().at("last-modified"); + response.SequenceNumber + = std::stoll(httpResponse.GetHeaders().at("x-ms-blob-sequence-number")); + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); + } + + struct GetPageBlobPageRangesOptions + { + Azure::Core::Nullable Timeout; + Azure::Core::Nullable PreviousSnapshot; + Azure::Core::Nullable PreviousSnapshotUrl; + Azure::Core::Nullable> Range; + Azure::Core::Nullable LeaseId; + Azure::Core::Nullable IfModifiedSince; + Azure::Core::Nullable IfUnmodifiedSince; + Azure::Core::Nullable IfMatch; + Azure::Core::Nullable IfNoneMatch; + Azure::Core::Nullable IfTags; + }; // struct GetPageBlobPageRangesOptions + + static Azure::Core::Response GetPageRanges( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const GetPageBlobPageRangesOptions& options) + { + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url); + request.GetUrl().AppendQueryParameter("comp", "pagelist"); + if (options.PreviousSnapshot.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "prevsnapshot", + Storage::Details::UrlEncodeQueryParameter(options.PreviousSnapshot.GetValue())); + } + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + if (options.Range.HasValue()) + { + auto startOffset = options.Range.GetValue().first; + auto endOffset = options.Range.GetValue().second; + if (endOffset != std::numeric_limits::max()) + { + request.AddHeader( + "x-ms-range", + "bytes=" + std::to_string(startOffset) + "-" + std::to_string(endOffset)); + } + else + { + request.AddHeader("x-ms-range", "bytes=" + std::to_string(startOffset) + "-"); + } + } + if (options.LeaseId.HasValue()) + { + request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); + } + if (options.PreviousSnapshotUrl.HasValue()) + { + request.AddHeader("x-ms-previous-snapshot-url", options.PreviousSnapshotUrl.GetValue()); + } + if (options.IfModifiedSince.HasValue()) + { + request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); + } + if (options.IfUnmodifiedSince.HasValue()) + { + request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); + } + if (options.IfMatch.HasValue()) + { + request.AddHeader("If-Match", options.IfMatch.GetValue()); + } + if (options.IfNoneMatch.HasValue()) + { + request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); + } + if (options.IfTags.HasValue()) + { + request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + GetPageBlobPageRangesResultInternal response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 200)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + { + const auto& httpResponseBody = httpResponse.GetBody(); + XmlReader reader( + reinterpret_cast(httpResponseBody.data()), httpResponseBody.size()); + response = GetPageBlobPageRangesResultInternalFromXml(reader); + } + response.ETag = httpResponse.GetHeaders().at("etag"); + response.LastModified = httpResponse.GetHeaders().at("last-modified"); + response.BlobContentLength + = std::stoll(httpResponse.GetHeaders().at("x-ms-blob-content-length")); + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); + } + + struct StartCopyPageBlobIncrementalOptions + { + Azure::Core::Nullable Timeout; + std::string CopySource; + Azure::Core::Nullable IfModifiedSince; + Azure::Core::Nullable IfUnmodifiedSince; + Azure::Core::Nullable IfMatch; + Azure::Core::Nullable IfNoneMatch; + Azure::Core::Nullable IfTags; + }; // struct StartCopyPageBlobIncrementalOptions + + static Azure::Core::Response StartCopyIncremental( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const StartCopyPageBlobIncrementalOptions& options) + { + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); + request.AddHeader("Content-Length", "0"); + request.GetUrl().AppendQueryParameter("comp", "incrementalcopy"); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + request.AddHeader("x-ms-copy-source", options.CopySource); + if (options.IfModifiedSince.HasValue()) + { + request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); + } + if (options.IfUnmodifiedSince.HasValue()) + { + request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); + } + if (options.IfMatch.HasValue()) + { + request.AddHeader("If-Match", options.IfMatch.GetValue()); + } + if (options.IfNoneMatch.HasValue()) + { + request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); + } + if (options.IfTags.HasValue()) + { + request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + StartCopyPageBlobIncrementalResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 202)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + response.ETag = httpResponse.GetHeaders().at("etag"); + response.LastModified = httpResponse.GetHeaders().at("last-modified"); + response.CopyId = httpResponse.GetHeaders().at("x-ms-copy-id"); + response.CopyStatus + = CopyStatusFromString(httpResponse.GetHeaders().at("x-ms-copy-status")); + auto response_version_id_iterator = httpResponse.GetHeaders().find("x-ms-version-id"); + if (response_version_id_iterator != httpResponse.GetHeaders().end()) + { + response.VersionId = response_version_id_iterator->second; + } + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); + } + + private: + static GetPageBlobPageRangesResultInternal GetPageBlobPageRangesResultInternalFromXml( + XmlReader& reader) + { + GetPageBlobPageRangesResultInternal ret; + enum class XmlTagName + { + k_PageList, + k_PageRange, + k_ClearRange, + k_Unknown, + }; + std::vector path; + while (true) + { + auto node = reader.Read(); + if (node.Type == XmlNodeType::End) + { + break; + } + else if (node.Type == XmlNodeType::EndTag) + { + if (path.size() > 0) + { + path.pop_back(); + } + else + { + break; + } + } + else if (node.Type == XmlNodeType::StartTag) + { + if (std::strcmp(node.Name, "PageList") == 0) + { + path.emplace_back(XmlTagName::k_PageList); + } + else if (std::strcmp(node.Name, "PageRange") == 0) + { + path.emplace_back(XmlTagName::k_PageRange); + } + else if (std::strcmp(node.Name, "ClearRange") == 0) + { + path.emplace_back(XmlTagName::k_ClearRange); + } + else + { + path.emplace_back(XmlTagName::k_Unknown); + } + if (path.size() == 2 && path[0] == XmlTagName::k_PageList + && path[1] == XmlTagName::k_PageRange) + { + ret.PageRanges.emplace_back(PageRangesFromXml(reader)); + path.pop_back(); + } + else if ( + path.size() == 2 && path[0] == XmlTagName::k_PageList + && path[1] == XmlTagName::k_ClearRange) + { + ret.ClearRanges.emplace_back(ClearRangesFromXml(reader)); + path.pop_back(); + } + } + else if (node.Type == XmlNodeType::Text) + { + } + } + return ret; + } + + static std::pair ClearRangesFromXml(XmlReader& reader) + { + int depth = 0; + bool is_start = false; + bool is_end = false; + int64_t start = 0; + int64_t end = 0; + while (true) + { + auto node = reader.Read(); + if (node.Type == XmlNodeType::End) + { + break; + } + else if (node.Type == XmlNodeType::StartTag && strcmp(node.Name, "Start") == 0) + { + ++depth; + is_start = true; + } + else if (node.Type == XmlNodeType::StartTag && strcmp(node.Name, "End") == 0) + { + ++depth; + is_end = true; + } + else if (node.Type == XmlNodeType::EndTag) + { + is_start = false; + is_end = false; + if (depth-- == 0) + { + break; + } + } + if (depth == 1 && node.Type == XmlNodeType::Text) + { + if (is_start) + { + start = std::stoll(node.Value); + } + else if (is_end) + { + end = std::stoll(node.Value); + } + } + } + return std::make_pair(start, end); + } + + static std::pair PageRangesFromXml(XmlReader& reader) + { + int depth = 0; + bool is_start = false; + bool is_end = false; + int64_t start = 0; + int64_t end = 0; + while (true) + { + auto node = reader.Read(); + if (node.Type == XmlNodeType::End) + { + break; + } + else if (node.Type == XmlNodeType::StartTag && strcmp(node.Name, "Start") == 0) + { + ++depth; + is_start = true; + } + else if (node.Type == XmlNodeType::StartTag && strcmp(node.Name, "End") == 0) + { + ++depth; + is_end = true; + } + else if (node.Type == XmlNodeType::EndTag) + { + is_start = false; + is_end = false; + if (depth-- == 0) + { + break; + } + } + if (depth == 1 && node.Type == XmlNodeType::Text) + { + if (is_start) + { + start = std::stoll(node.Value); + } + else if (is_end) + { + end = std::stoll(node.Value); + } + } + } + return std::make_pair(start, end); + } + + }; // class PageBlob + + class AppendBlob { + public: + struct CreateAppendBlobOptions + { + Azure::Core::Nullable Timeout; + BlobHttpHeaders HttpHeaders; + std::map Metadata; + Azure::Core::Nullable LeaseId; + Azure::Core::Nullable EncryptionKey; + Azure::Core::Nullable EncryptionKeySha256; + Azure::Core::Nullable EncryptionAlgorithm; + Azure::Core::Nullable EncryptionScope; + Azure::Core::Nullable IfModifiedSince; + Azure::Core::Nullable IfUnmodifiedSince; + Azure::Core::Nullable IfMatch; + Azure::Core::Nullable IfNoneMatch; + Azure::Core::Nullable IfTags; + }; // struct CreateAppendBlobOptions + + static Azure::Core::Response Create( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const CreateAppendBlobOptions& options) + { + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); + request.AddHeader("Content-Length", "0"); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + if (!options.HttpHeaders.ContentType.empty()) + { + request.AddHeader("x-ms-blob-content-type", options.HttpHeaders.ContentType); + } + if (!options.HttpHeaders.ContentEncoding.empty()) + { + request.AddHeader("x-ms-blob-content-encoding", options.HttpHeaders.ContentEncoding); + } + if (!options.HttpHeaders.ContentLanguage.empty()) + { + request.AddHeader("x-ms-blob-content-language", options.HttpHeaders.ContentLanguage); + } + if (!options.HttpHeaders.CacheControl.empty()) + { + request.AddHeader("x-ms-blob-cache-control", options.HttpHeaders.CacheControl); + } + if (!options.HttpHeaders.ContentMd5.empty()) + { + request.AddHeader("x-ms-blob-content-md5", options.HttpHeaders.ContentMd5); + } + if (!options.HttpHeaders.ContentDisposition.empty()) + { + request.AddHeader( + "x-ms-blob-content-disposition", options.HttpHeaders.ContentDisposition); + } + std::set metadataKeys; + for (const auto& pair : options.Metadata) + { + if (metadataKeys.insert(Azure::Core::Strings::ToLower(pair.first)).second == false) + { + throw std::runtime_error("duplicate keys in metadata"); + } + request.AddHeader("x-ms-meta-" + pair.first, pair.second); + } + metadataKeys.clear(); + if (options.LeaseId.HasValue()) + { + request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); + } + request.AddHeader("x-ms-blob-type", "AppendBlob"); + if (options.EncryptionKey.HasValue()) + { + request.AddHeader("x-ms-encryption-key", options.EncryptionKey.GetValue()); + } + if (options.EncryptionKeySha256.HasValue()) + { + request.AddHeader("x-ms-encryption-key-sha256", options.EncryptionKeySha256.GetValue()); + } + if (options.EncryptionAlgorithm.HasValue()) + { + request.AddHeader( + "x-ms-encryption-algorithm", + EncryptionAlgorithmTypeToString(options.EncryptionAlgorithm.GetValue())); + } + if (options.EncryptionScope.HasValue()) + { + request.AddHeader("x-ms-encryption-scope", options.EncryptionScope.GetValue()); + } + if (options.IfModifiedSince.HasValue()) + { + request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); + } + if (options.IfUnmodifiedSince.HasValue()) + { + request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); + } + if (options.IfMatch.HasValue()) + { + request.AddHeader("If-Match", options.IfMatch.GetValue()); + } + if (options.IfNoneMatch.HasValue()) + { + request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); + } + if (options.IfTags.HasValue()) + { + request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + CreateAppendBlobResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 201)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + response.ETag = httpResponse.GetHeaders().at("etag"); + response.LastModified = httpResponse.GetHeaders().at("last-modified"); + auto response_version_id_iterator = httpResponse.GetHeaders().find("x-ms-version-id"); + if (response_version_id_iterator != httpResponse.GetHeaders().end()) + { + response.VersionId = response_version_id_iterator->second; + } + auto response_server_encrypted_iterator + = httpResponse.GetHeaders().find("x-ms-request-server-encrypted"); + if (response_server_encrypted_iterator != httpResponse.GetHeaders().end()) + { + response.ServerEncrypted = response_server_encrypted_iterator->second == "true"; + } + auto response_encryption_key_sha256_iterator + = httpResponse.GetHeaders().find("x-ms-encryption-key-sha256"); + if (response_encryption_key_sha256_iterator != httpResponse.GetHeaders().end()) + { + response.EncryptionKeySha256 = response_encryption_key_sha256_iterator->second; + } + auto response_encryption_scope_iterator + = httpResponse.GetHeaders().find("x-ms-encryption-scope"); + if (response_encryption_scope_iterator != httpResponse.GetHeaders().end()) + { + response.EncryptionScope = response_encryption_scope_iterator->second; + } + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); + } + + struct AppendBlockOptions + { + Azure::Core::Nullable Timeout; + Azure::Core::Nullable TransactionalContentMd5; + Azure::Core::Nullable TransactionalContentCrc64; + Azure::Core::Nullable LeaseId; + Azure::Core::Nullable MaxSize; + Azure::Core::Nullable AppendPosition; + Azure::Core::Nullable EncryptionKey; + Azure::Core::Nullable EncryptionKeySha256; + Azure::Core::Nullable EncryptionAlgorithm; + Azure::Core::Nullable EncryptionScope; + Azure::Core::Nullable IfModifiedSince; + Azure::Core::Nullable IfUnmodifiedSince; + Azure::Core::Nullable IfMatch; + Azure::Core::Nullable IfNoneMatch; + Azure::Core::Nullable IfTags; + }; // struct AppendBlockOptions + + static Azure::Core::Response AppendBlock( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + Azure::Core::Http::BodyStream* requestBody, + const AppendBlockOptions& options) + { + unused(options); + auto request + = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url, requestBody); + request.AddHeader("Content-Length", std::to_string(requestBody->Length())); + request.GetUrl().AppendQueryParameter("comp", "appendblock"); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + if (options.TransactionalContentMd5.HasValue()) + { + request.AddHeader("Content-MD5", options.TransactionalContentMd5.GetValue()); + } + if (options.TransactionalContentCrc64.HasValue()) + { + request.AddHeader("x-ms-content-crc64", options.TransactionalContentCrc64.GetValue()); + } + if (options.LeaseId.HasValue()) + { + request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); + } + if (options.MaxSize.HasValue()) + { + request.AddHeader( + "x-ms-blob-condition-maxsize", std::to_string(options.MaxSize.GetValue())); + } + if (options.AppendPosition.HasValue()) + { + request.AddHeader( + "x-ms-blob-condition-appendpos", std::to_string(options.AppendPosition.GetValue())); + } + if (options.EncryptionKey.HasValue()) + { + request.AddHeader("x-ms-encryption-key", options.EncryptionKey.GetValue()); + } + if (options.EncryptionKeySha256.HasValue()) + { + request.AddHeader("x-ms-encryption-key-sha256", options.EncryptionKeySha256.GetValue()); + } + if (options.EncryptionAlgorithm.HasValue()) + { + request.AddHeader( + "x-ms-encryption-algorithm", + EncryptionAlgorithmTypeToString(options.EncryptionAlgorithm.GetValue())); + } + if (options.EncryptionScope.HasValue()) + { + request.AddHeader("x-ms-encryption-scope", options.EncryptionScope.GetValue()); + } + if (options.IfModifiedSince.HasValue()) + { + request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); + } + if (options.IfUnmodifiedSince.HasValue()) + { + request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); + } + if (options.IfMatch.HasValue()) + { + request.AddHeader("If-Match", options.IfMatch.GetValue()); + } + if (options.IfNoneMatch.HasValue()) + { + request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); + } + if (options.IfTags.HasValue()) + { + request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + AppendBlockResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 201)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + response.ETag = httpResponse.GetHeaders().at("etag"); + response.LastModified = httpResponse.GetHeaders().at("last-modified"); + auto response_transactional_content_md5_iterator + = httpResponse.GetHeaders().find("content-md5"); + if (response_transactional_content_md5_iterator != httpResponse.GetHeaders().end()) + { + response.TransactionalContentMd5 = response_transactional_content_md5_iterator->second; + } + auto response_transactional_content_crc64_iterator + = httpResponse.GetHeaders().find("x-ms-content-crc64"); + if (response_transactional_content_crc64_iterator != httpResponse.GetHeaders().end()) + { + response.TransactionalContentCrc64 + = response_transactional_content_crc64_iterator->second; + } + response.AppendOffset + = std::stoll(httpResponse.GetHeaders().at("x-ms-blob-append-offset")); response.CommittedBlockCount - = std::stoll(response_committed_block_count_iterator->second); - } - auto response_is_sealed_iterator = httpResponse.GetHeaders().find("x-ms-blob-sealed"); - if (response_is_sealed_iterator != httpResponse.GetHeaders().end()) - { - response.IsSealed = response_is_sealed_iterator->second == "true"; - } - response.BlobType = BlobTypeFromString(httpResponse.GetHeaders().at("x-ms-blob-type")); - auto response_object_replication_destination_policy_id_iterator - = httpResponse.GetHeaders().find("x-ms-or-policy-id"); - if (response_object_replication_destination_policy_id_iterator - != httpResponse.GetHeaders().end()) - { - response.ObjectReplicationDestinationPolicyId - = response_object_replication_destination_policy_id_iterator->second; - } - { - std::map> orPropertiesMap; - for (auto i = httpResponse.GetHeaders().lower_bound("x-ms-or-"); - i != httpResponse.GetHeaders().end() && i->first.substr(0, 8) == "x-ms-or-"; - ++i) + = std::stoll(httpResponse.GetHeaders().at("x-ms-blob-committed-block-count")); + auto response_server_encrypted_iterator + = httpResponse.GetHeaders().find("x-ms-request-server-encrypted"); + if (response_server_encrypted_iterator != httpResponse.GetHeaders().end()) { - const std::string& header = i->first; - auto underscorePos = header.find('_', 8); - if (underscorePos == std::string::npos) + response.ServerEncrypted = response_server_encrypted_iterator->second == "true"; + } + auto response_encryption_key_sha256_iterator + = httpResponse.GetHeaders().find("x-ms-encryption-key-sha256"); + if (response_encryption_key_sha256_iterator != httpResponse.GetHeaders().end()) + { + response.EncryptionKeySha256 = response_encryption_key_sha256_iterator->second; + } + auto response_encryption_scope_iterator + = httpResponse.GetHeaders().find("x-ms-encryption-scope"); + if (response_encryption_scope_iterator != httpResponse.GetHeaders().end()) + { + response.EncryptionScope = response_encryption_scope_iterator->second; + } + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); + } + + struct AppendBlockFromUriOptions + { + Azure::Core::Nullable Timeout; + std::string SourceUri; + Azure::Core::Nullable> SourceRange; + Azure::Core::Nullable TransactionalContentMd5; + Azure::Core::Nullable TransactionalContentCrc64; + Azure::Core::Nullable LeaseId; + Azure::Core::Nullable MaxSize; + Azure::Core::Nullable AppendPosition; + Azure::Core::Nullable EncryptionKey; + Azure::Core::Nullable EncryptionKeySha256; + Azure::Core::Nullable EncryptionAlgorithm; + Azure::Core::Nullable EncryptionScope; + Azure::Core::Nullable IfModifiedSince; + Azure::Core::Nullable IfUnmodifiedSince; + Azure::Core::Nullable IfMatch; + Azure::Core::Nullable IfNoneMatch; + Azure::Core::Nullable IfTags; + }; // struct AppendBlockFromUriOptions + + static Azure::Core::Response AppendBlockFromUri( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const AppendBlockFromUriOptions& options) + { + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); + request.AddHeader("Content-Length", "0"); + request.GetUrl().AppendQueryParameter("comp", "appendblock"); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + request.AddHeader("x-ms-copy-source", options.SourceUri); + if (options.SourceRange.HasValue()) + { + auto startOffset = options.SourceRange.GetValue().first; + auto endOffset = options.SourceRange.GetValue().second; + if (endOffset != std::numeric_limits::max()) { - continue; - } - std::string policyId = std::string(header.begin() + 8, header.begin() + underscorePos); - std::string ruleId = header.substr(underscorePos + 1); - - ObjectReplicationRule rule; - rule.RuleId = std::move(ruleId); - rule.ReplicationStatus = ObjectReplicationStatusFromString(i->second); - orPropertiesMap[policyId].emplace_back(std::move(rule)); - } - for (auto& property : orPropertiesMap) - { - ObjectReplicationPolicy policy; - policy.PolicyId = property.first; - policy.Rules = std::move(property.second); - response.ObjectReplicationSourceProperties.emplace_back(std::move(policy)); - } - } - auto response_tag_count_iterator = httpResponse.GetHeaders().find("x-ms-tag-count"); - if (response_tag_count_iterator != httpResponse.GetHeaders().end()) - { - response.TagCount = std::stoi(response_tag_count_iterator->second); - } - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct DeleteBlobOptions - { - Azure::Core::Nullable Timeout; - Azure::Core::Nullable DeleteSnapshots; - Azure::Core::Nullable LeaseId; - Azure::Core::Nullable IfModifiedSince; - Azure::Core::Nullable IfUnmodifiedSince; - Azure::Core::Nullable IfMatch; - Azure::Core::Nullable IfNoneMatch; - Azure::Core::Nullable IfTags; - }; // struct DeleteBlobOptions - - static Azure::Core::Http::Request DeleteCreateMessage( - const Azure::Core::Http::Url& url, - const DeleteBlobOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Delete, url); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - if (options.DeleteSnapshots.HasValue()) - { - request.AddHeader( - "x-ms-delete-snapshots", - DeleteSnapshotsOptionToString(options.DeleteSnapshots.GetValue())); - } - if (options.LeaseId.HasValue()) - { - request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); - } - if (options.IfModifiedSince.HasValue()) - { - request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); - } - if (options.IfUnmodifiedSince.HasValue()) - { - request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); - } - if (options.IfMatch.HasValue()) - { - request.AddHeader("If-Match", options.IfMatch.GetValue()); - } - if (options.IfNoneMatch.HasValue()) - { - request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); - } - if (options.IfTags.HasValue()) - { - request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); - } - return request; - } - - static Azure::Core::Response DeleteCreateResponse( - const Azure::Core::Context& context, - std::unique_ptr pHttpResponse) - { - unused(context); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - DeleteBlobResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 202)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - static Azure::Core::Response Delete( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const DeleteBlobOptions& options) - { - auto request = DeleteCreateMessage(url, options); - auto pHttpResponse = pipeline.Send(context, request); - return DeleteCreateResponse(context, std::move(pHttpResponse)); - } - - struct SetBlobExpiryOptions - { - Azure::Core::Nullable Timeout; - ScheduleBlobExpiryOriginType ExpiryOrigin; - Azure::Core::Nullable ExpiryTime; - }; // struct SetBlobExpiryOptions - - static Azure::Core::Response ScheduleDeletion( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const SetBlobExpiryOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); - request.AddHeader("Content-Length", "0"); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - request.GetUrl().AppendQueryParameter("comp", "expiry"); - request.AddHeader( - "x-ms-expiry-option", ScheduleBlobExpiryOriginTypeToString(options.ExpiryOrigin)); - if (options.ExpiryTime.HasValue()) - { - request.AddHeader("x-ms-expiry-time", options.ExpiryTime.GetValue()); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - SetBlobExpiryResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 200)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct UndeleteBlobOptions - { - Azure::Core::Nullable Timeout; - }; // struct UndeleteBlobOptions - - static Azure::Core::Response Undelete( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const UndeleteBlobOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); - request.AddHeader("Content-Length", "0"); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - request.GetUrl().AppendQueryParameter("comp", "undelete"); - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - UndeleteBlobResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 200)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct GetBlobPropertiesOptions - { - Azure::Core::Nullable Timeout; - Azure::Core::Nullable EncryptionKey; - Azure::Core::Nullable EncryptionKeySha256; - Azure::Core::Nullable EncryptionAlgorithm; - Azure::Core::Nullable LeaseId; - Azure::Core::Nullable IfModifiedSince; - Azure::Core::Nullable IfUnmodifiedSince; - Azure::Core::Nullable IfMatch; - Azure::Core::Nullable IfNoneMatch; - Azure::Core::Nullable IfTags; - }; // struct GetBlobPropertiesOptions - - static Azure::Core::Response GetProperties( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const GetBlobPropertiesOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Head, url); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - if (options.EncryptionKey.HasValue()) - { - request.AddHeader("x-ms-encryption-key", options.EncryptionKey.GetValue()); - } - if (options.EncryptionKeySha256.HasValue()) - { - request.AddHeader("x-ms-encryption-key-sha256", options.EncryptionKeySha256.GetValue()); - } - if (options.EncryptionAlgorithm.HasValue()) - { - request.AddHeader( - "x-ms-encryption-algorithm", - EncryptionAlgorithmTypeToString(options.EncryptionAlgorithm.GetValue())); - } - if (options.LeaseId.HasValue()) - { - request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); - } - if (options.IfModifiedSince.HasValue()) - { - request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); - } - if (options.IfUnmodifiedSince.HasValue()) - { - request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); - } - if (options.IfMatch.HasValue()) - { - request.AddHeader("If-Match", options.IfMatch.GetValue()); - } - if (options.IfNoneMatch.HasValue()) - { - request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); - } - if (options.IfTags.HasValue()) - { - request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - GetBlobPropertiesResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 200)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - response.ETag = httpResponse.GetHeaders().at("etag"); - response.LastModified = httpResponse.GetHeaders().at("last-modified"); - response.CreationTime = httpResponse.GetHeaders().at("x-ms-creation-time"); - auto response_expiry_time_iterator = httpResponse.GetHeaders().find("x-ms-expiry-time"); - if (response_expiry_time_iterator != httpResponse.GetHeaders().end()) - { - response.ExpiryTime = response_expiry_time_iterator->second; - } - auto response_last_access_time_iterator - = httpResponse.GetHeaders().find("x-ms-last-access-time"); - if (response_last_access_time_iterator != httpResponse.GetHeaders().end()) - { - response.LastAccessTime = response_last_access_time_iterator->second; - } - for (auto i = httpResponse.GetHeaders().lower_bound("x-ms-meta-"); - i != httpResponse.GetHeaders().end() && i->first.substr(0, 10) == "x-ms-meta-"; - ++i) - { - response.Metadata.emplace(i->first.substr(10), i->second); - } - response.BlobType = BlobTypeFromString(httpResponse.GetHeaders().at("x-ms-blob-type")); - auto response_lease_status_iterator = httpResponse.GetHeaders().find("x-ms-lease-status"); - if (response_lease_status_iterator != httpResponse.GetHeaders().end()) - { - response.LeaseStatus = BlobLeaseStatusFromString(response_lease_status_iterator->second); - } - auto response_lease_state_iterator = httpResponse.GetHeaders().find("x-ms-lease-state"); - if (response_lease_state_iterator != httpResponse.GetHeaders().end()) - { - response.LeaseState = BlobLeaseStateFromString(response_lease_state_iterator->second); - } - auto response_lease_duration_iterator - = httpResponse.GetHeaders().find("x-ms-lease-duration"); - if (response_lease_duration_iterator != httpResponse.GetHeaders().end()) - { - response.LeaseDuration = response_lease_duration_iterator->second; - } - response.ContentLength = std::stoll(httpResponse.GetHeaders().at("content-length")); - auto response_http_headers_content_type_iterator - = httpResponse.GetHeaders().find("content-type"); - if (response_http_headers_content_type_iterator != httpResponse.GetHeaders().end()) - { - response.HttpHeaders.ContentType = response_http_headers_content_type_iterator->second; - } - auto response_http_headers_content_encoding_iterator - = httpResponse.GetHeaders().find("content-encoding"); - if (response_http_headers_content_encoding_iterator != httpResponse.GetHeaders().end()) - { - response.HttpHeaders.ContentEncoding - = response_http_headers_content_encoding_iterator->second; - } - auto response_http_headers_content_language_iterator - = httpResponse.GetHeaders().find("content-language"); - if (response_http_headers_content_language_iterator != httpResponse.GetHeaders().end()) - { - response.HttpHeaders.ContentLanguage - = response_http_headers_content_language_iterator->second; - } - auto response_http_headers_cache_control_iterator - = httpResponse.GetHeaders().find("cache-control"); - if (response_http_headers_cache_control_iterator != httpResponse.GetHeaders().end()) - { - response.HttpHeaders.CacheControl = response_http_headers_cache_control_iterator->second; - } - auto response_http_headers_content_md5_iterator - = httpResponse.GetHeaders().find("content-md5"); - if (response_http_headers_content_md5_iterator != httpResponse.GetHeaders().end()) - { - response.HttpHeaders.ContentMd5 = response_http_headers_content_md5_iterator->second; - } - auto x_ms_blob_content_md5_iterator - = httpResponse.GetHeaders().find("x-ms-blob-content-md5"); - if (x_ms_blob_content_md5_iterator != httpResponse.GetHeaders().end()) - { - response.HttpHeaders.ContentMd5 = x_ms_blob_content_md5_iterator->second; - } - auto response_http_headers_content_disposition_iterator - = httpResponse.GetHeaders().find("content-disposition"); - if (response_http_headers_content_disposition_iterator != httpResponse.GetHeaders().end()) - { - response.HttpHeaders.ContentDisposition - = response_http_headers_content_disposition_iterator->second; - } - auto response_sequence_number_iterator - = httpResponse.GetHeaders().find("x-ms-blob-sequence-number"); - if (response_sequence_number_iterator != httpResponse.GetHeaders().end()) - { - response.SequenceNumber = std::stoll(response_sequence_number_iterator->second); - } - auto response_committed_block_count_iterator - = httpResponse.GetHeaders().find("x-ms-blob-committed-block-count"); - if (response_committed_block_count_iterator != httpResponse.GetHeaders().end()) - { - response.CommittedBlockCount = std::stoi(response_committed_block_count_iterator->second); - } - auto response_is_sealed_iterator = httpResponse.GetHeaders().find("x-ms-blob-sealed"); - if (response_is_sealed_iterator != httpResponse.GetHeaders().end()) - { - response.IsSealed = response_is_sealed_iterator->second == "true"; - } - auto response_server_encrypted_iterator - = httpResponse.GetHeaders().find("x-ms-server-encrypted"); - if (response_server_encrypted_iterator != httpResponse.GetHeaders().end()) - { - response.ServerEncrypted = response_server_encrypted_iterator->second == "true"; - } - auto response_encryption_key_sha256_iterator - = httpResponse.GetHeaders().find("x-ms-encryption-key-sha256"); - if (response_encryption_key_sha256_iterator != httpResponse.GetHeaders().end()) - { - response.EncryptionKeySha256 = response_encryption_key_sha256_iterator->second; - } - auto response_encryption_scope_iterator - = httpResponse.GetHeaders().find("x-ms-encryption-scope"); - if (response_encryption_scope_iterator != httpResponse.GetHeaders().end()) - { - response.EncryptionScope = response_encryption_scope_iterator->second; - } - auto response_tier_iterator = httpResponse.GetHeaders().find("x-ms-access-tier"); - if (response_tier_iterator != httpResponse.GetHeaders().end()) - { - response.Tier = AccessTierFromString(response_tier_iterator->second); - } - auto response_access_tier_inferred_iterator - = httpResponse.GetHeaders().find("x-ms-access-tier-inferred"); - if (response_access_tier_inferred_iterator != httpResponse.GetHeaders().end()) - { - response.AccessTierInferred = response_access_tier_inferred_iterator->second == "true"; - } - auto response_archive_status_iterator - = httpResponse.GetHeaders().find("x-ms-archive-status"); - if (response_archive_status_iterator != httpResponse.GetHeaders().end()) - { - response.ArchiveStatus - = BlobArchiveStatusFromString(response_archive_status_iterator->second); - } - auto response_access_tier_change_time_iterator - = httpResponse.GetHeaders().find("x-ms-access-tier-change-time"); - if (response_access_tier_change_time_iterator != httpResponse.GetHeaders().end()) - { - response.AccessTierChangeTime = response_access_tier_change_time_iterator->second; - } - auto response_copy_id_iterator = httpResponse.GetHeaders().find("x-ms-copy-id"); - if (response_copy_id_iterator != httpResponse.GetHeaders().end()) - { - response.CopyId = response_copy_id_iterator->second; - } - auto response_copy_source_iterator = httpResponse.GetHeaders().find("x-ms-copy-source"); - if (response_copy_source_iterator != httpResponse.GetHeaders().end()) - { - response.CopySource = response_copy_source_iterator->second; - } - auto response_copy_status_iterator = httpResponse.GetHeaders().find("x-ms-copy-status"); - if (response_copy_status_iterator != httpResponse.GetHeaders().end()) - { - response.CopyStatus = CopyStatusFromString(response_copy_status_iterator->second); - } - auto response_copy_progress_iterator = httpResponse.GetHeaders().find("x-ms-copy-progress"); - if (response_copy_progress_iterator != httpResponse.GetHeaders().end()) - { - response.CopyProgress = response_copy_progress_iterator->second; - } - auto response_copy_completion_time_iterator - = httpResponse.GetHeaders().find("x-ms-copy-completion-time"); - if (response_copy_completion_time_iterator != httpResponse.GetHeaders().end()) - { - response.CopyCompletionTime = response_copy_completion_time_iterator->second; - } - auto response_object_replication_destination_policy_id_iterator - = httpResponse.GetHeaders().find("x-ms-or-policy-id"); - if (response_object_replication_destination_policy_id_iterator - != httpResponse.GetHeaders().end()) - { - response.ObjectReplicationDestinationPolicyId - = response_object_replication_destination_policy_id_iterator->second; - } - { - std::map> orPropertiesMap; - for (auto i = httpResponse.GetHeaders().lower_bound("x-ms-or-"); - i != httpResponse.GetHeaders().end() && i->first.substr(0, 8) == "x-ms-or-"; - ++i) - { - const std::string& header = i->first; - auto underscorePos = header.find('_', 8); - if (underscorePos == std::string::npos) - { - continue; - } - std::string policyId = std::string(header.begin() + 8, header.begin() + underscorePos); - std::string ruleId = header.substr(underscorePos + 1); - - ObjectReplicationRule rule; - rule.RuleId = std::move(ruleId); - rule.ReplicationStatus = ObjectReplicationStatusFromString(i->second); - orPropertiesMap[policyId].emplace_back(std::move(rule)); - } - for (auto& property : orPropertiesMap) - { - ObjectReplicationPolicy policy; - policy.PolicyId = property.first; - policy.Rules = std::move(property.second); - response.ObjectReplicationSourceProperties.emplace_back(std::move(policy)); - } - } - auto response_tag_count_iterator = httpResponse.GetHeaders().find("x-ms-tag-count"); - if (response_tag_count_iterator != httpResponse.GetHeaders().end()) - { - response.TagCount = std::stoi(response_tag_count_iterator->second); - } - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct SetBlobHttpHeadersOptions - { - Azure::Core::Nullable Timeout; - BlobHttpHeaders HttpHeaders; - Azure::Core::Nullable LeaseId; - Azure::Core::Nullable IfModifiedSince; - Azure::Core::Nullable IfUnmodifiedSince; - Azure::Core::Nullable IfMatch; - Azure::Core::Nullable IfNoneMatch; - Azure::Core::Nullable IfTags; - }; // struct SetBlobHttpHeadersOptions - - static Azure::Core::Response SetHttpHeaders( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const SetBlobHttpHeadersOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); - request.AddHeader("Content-Length", "0"); - request.GetUrl().AppendQueryParameter("comp", "properties"); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - if (!options.HttpHeaders.ContentType.empty()) - { - request.AddHeader("x-ms-blob-content-type", options.HttpHeaders.ContentType); - } - if (!options.HttpHeaders.ContentEncoding.empty()) - { - request.AddHeader("x-ms-blob-content-encoding", options.HttpHeaders.ContentEncoding); - } - if (!options.HttpHeaders.ContentLanguage.empty()) - { - request.AddHeader("x-ms-blob-content-language", options.HttpHeaders.ContentLanguage); - } - if (!options.HttpHeaders.CacheControl.empty()) - { - request.AddHeader("x-ms-blob-cache-control", options.HttpHeaders.CacheControl); - } - if (!options.HttpHeaders.ContentMd5.empty()) - { - request.AddHeader("x-ms-blob-content-md5", options.HttpHeaders.ContentMd5); - } - if (!options.HttpHeaders.ContentDisposition.empty()) - { - request.AddHeader( - "x-ms-blob-content-disposition", options.HttpHeaders.ContentDisposition); - } - if (options.LeaseId.HasValue()) - { - request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); - } - if (options.IfModifiedSince.HasValue()) - { - request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); - } - if (options.IfUnmodifiedSince.HasValue()) - { - request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); - } - if (options.IfMatch.HasValue()) - { - request.AddHeader("If-Match", options.IfMatch.GetValue()); - } - if (options.IfNoneMatch.HasValue()) - { - request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); - } - if (options.IfTags.HasValue()) - { - request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - SetBlobHttpHeadersResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 200)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - response.ETag = httpResponse.GetHeaders().at("etag"); - response.LastModified = httpResponse.GetHeaders().at("last-modified"); - auto response_sequence_number_iterator - = httpResponse.GetHeaders().find("x-ms-blob-sequence-number"); - if (response_sequence_number_iterator != httpResponse.GetHeaders().end()) - { - response.SequenceNumber = std::stoll(response_sequence_number_iterator->second); - } - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct SetBlobMetadataOptions - { - Azure::Core::Nullable Timeout; - std::map Metadata; - Azure::Core::Nullable EncryptionKey; - Azure::Core::Nullable EncryptionKeySha256; - Azure::Core::Nullable EncryptionAlgorithm; - Azure::Core::Nullable EncryptionScope; - Azure::Core::Nullable LeaseId; - Azure::Core::Nullable IfModifiedSince; - Azure::Core::Nullable IfUnmodifiedSince; - Azure::Core::Nullable IfMatch; - Azure::Core::Nullable IfNoneMatch; - Azure::Core::Nullable IfTags; - }; // struct SetBlobMetadataOptions - - static Azure::Core::Response SetMetadata( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const SetBlobMetadataOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); - request.AddHeader("Content-Length", "0"); - request.GetUrl().AppendQueryParameter("comp", "metadata"); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - std::set metadataKeys; - for (const auto& pair : options.Metadata) - { - if (metadataKeys.insert(Azure::Core::Strings::ToLower(pair.first)).second == false) - { - throw std::runtime_error("duplicate keys in metadata"); - } - request.AddHeader("x-ms-meta-" + pair.first, pair.second); - } - metadataKeys.clear(); - if (options.EncryptionKey.HasValue()) - { - request.AddHeader("x-ms-encryption-key", options.EncryptionKey.GetValue()); - } - if (options.EncryptionKeySha256.HasValue()) - { - request.AddHeader("x-ms-encryption-key-sha256", options.EncryptionKeySha256.GetValue()); - } - if (options.EncryptionAlgorithm.HasValue()) - { - request.AddHeader( - "x-ms-encryption-algorithm", - EncryptionAlgorithmTypeToString(options.EncryptionAlgorithm.GetValue())); - } - if (options.EncryptionScope.HasValue()) - { - request.AddHeader("x-ms-encryption-scope", options.EncryptionScope.GetValue()); - } - if (options.LeaseId.HasValue()) - { - request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); - } - if (options.IfModifiedSince.HasValue()) - { - request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); - } - if (options.IfUnmodifiedSince.HasValue()) - { - request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); - } - if (options.IfMatch.HasValue()) - { - request.AddHeader("If-Match", options.IfMatch.GetValue()); - } - if (options.IfNoneMatch.HasValue()) - { - request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); - } - if (options.IfTags.HasValue()) - { - request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - SetBlobMetadataResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 200)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - response.ETag = httpResponse.GetHeaders().at("etag"); - response.LastModified = httpResponse.GetHeaders().at("last-modified"); - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct SetBlobAccessTierOptions - { - Azure::Core::Nullable Timeout; - AccessTier Tier = AccessTier::Unknown; - Azure::Core::Nullable RehydratePriority; - Azure::Core::Nullable IfTags; - }; // struct SetBlobAccessTierOptions - - static Azure::Core::Http::Request SetAccessTierCreateMessage( - const Azure::Core::Http::Url& url, - const SetBlobAccessTierOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); - request.AddHeader("Content-Length", "0"); - request.GetUrl().AppendQueryParameter("comp", "tier"); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - request.AddHeader("x-ms-access-tier", AccessTierToString(options.Tier)); - if (options.RehydratePriority.HasValue()) - { - request.AddHeader( - "x-ms-rehydrate-priority", - RehydratePriorityToString(options.RehydratePriority.GetValue())); - } - if (options.IfTags.HasValue()) - { - request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); - } - return request; - } - - static Azure::Core::Response SetAccessTierCreateResponse( - const Azure::Core::Context& context, - std::unique_ptr pHttpResponse) - { - unused(context); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - SetBlobAccessTierResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 200 || http_status_code == 202)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - static Azure::Core::Response SetAccessTier( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const SetBlobAccessTierOptions& options) - { - auto request = SetAccessTierCreateMessage(url, options); - auto pHttpResponse = pipeline.Send(context, request); - return SetAccessTierCreateResponse(context, std::move(pHttpResponse)); - } - - struct StartCopyBlobFromUriOptions - { - Azure::Core::Nullable Timeout; - std::map Metadata; - std::string SourceUri; - Azure::Core::Nullable LeaseId; - Azure::Core::Nullable SourceLeaseId; - Azure::Core::Nullable Tier; - Azure::Core::Nullable RehydratePriority; - Azure::Core::Nullable IfModifiedSince; - Azure::Core::Nullable IfUnmodifiedSince; - Azure::Core::Nullable IfMatch; - Azure::Core::Nullable IfNoneMatch; - Azure::Core::Nullable IfTags; - Azure::Core::Nullable SourceIfModifiedSince; - Azure::Core::Nullable SourceIfUnmodifiedSince; - Azure::Core::Nullable SourceIfMatch; - Azure::Core::Nullable SourceIfNoneMatch; - Azure::Core::Nullable SourceIfTags; - Azure::Core::Nullable ShouldSealDestination; - }; // struct StartCopyBlobFromUriOptions - - static Azure::Core::Response StartCopyFromUri( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const StartCopyBlobFromUriOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); - request.AddHeader("Content-Length", "0"); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - std::set metadataKeys; - for (const auto& pair : options.Metadata) - { - if (metadataKeys.insert(Azure::Core::Strings::ToLower(pair.first)).second == false) - { - throw std::runtime_error("duplicate keys in metadata"); - } - request.AddHeader("x-ms-meta-" + pair.first, pair.second); - } - metadataKeys.clear(); - request.AddHeader("x-ms-copy-source", options.SourceUri); - if (options.LeaseId.HasValue()) - { - request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); - } - if (options.SourceLeaseId.HasValue()) - { - request.AddHeader("x-ms-source-lease-id", options.SourceLeaseId.GetValue()); - } - if (options.Tier.HasValue()) - { - request.AddHeader("x-ms-access-tier", AccessTierToString(options.Tier.GetValue())); - } - if (options.RehydratePriority.HasValue()) - { - request.AddHeader( - "x-ms-rehydrate-priority", - RehydratePriorityToString(options.RehydratePriority.GetValue())); - } - if (options.ShouldSealDestination.HasValue()) - { - request.AddHeader( - "x-ms-seal-blob", options.ShouldSealDestination.GetValue() ? "true" : "false"); - } - if (options.IfModifiedSince.HasValue()) - { - request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); - } - if (options.IfUnmodifiedSince.HasValue()) - { - request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); - } - if (options.IfMatch.HasValue()) - { - request.AddHeader("If-Match", options.IfMatch.GetValue()); - } - if (options.IfNoneMatch.HasValue()) - { - request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); - } - if (options.IfTags.HasValue()) - { - request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); - } - if (options.SourceIfModifiedSince.HasValue()) - { - request.AddHeader( - "x-ms-source-if-modified-since", options.SourceIfModifiedSince.GetValue()); - } - if (options.SourceIfUnmodifiedSince.HasValue()) - { - request.AddHeader( - "x-ms-source-if-unmodified-since", options.SourceIfUnmodifiedSince.GetValue()); - } - if (options.SourceIfMatch.HasValue()) - { - request.AddHeader("x-ms-source-if-match", options.SourceIfMatch.GetValue()); - } - if (options.SourceIfNoneMatch.HasValue()) - { - request.AddHeader("x-ms-source-if-none-match", options.SourceIfNoneMatch.GetValue()); - } - if (options.SourceIfTags.HasValue()) - { - request.AddHeader("x-ms-source-if-tags", options.SourceIfTags.GetValue()); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - StartCopyBlobFromUriResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 202)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - response.ETag = httpResponse.GetHeaders().at("etag"); - response.LastModified = httpResponse.GetHeaders().at("last-modified"); - response.CopyId = httpResponse.GetHeaders().at("x-ms-copy-id"); - response.CopyStatus - = CopyStatusFromString(httpResponse.GetHeaders().at("x-ms-copy-status")); - auto response_version_id_iterator = httpResponse.GetHeaders().find("x-ms-version-id"); - if (response_version_id_iterator != httpResponse.GetHeaders().end()) - { - response.VersionId = response_version_id_iterator->second; - } - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct AbortCopyBlobFromUriOptions - { - Azure::Core::Nullable Timeout; - std::string CopyId; - Azure::Core::Nullable LeaseId; - }; // struct AbortCopyBlobFromUriOptions - - static Azure::Core::Response AbortCopyFromUri( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const AbortCopyBlobFromUriOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); - request.AddHeader("Content-Length", "0"); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - request.GetUrl().AppendQueryParameter("comp", "copy"); - request.GetUrl().AppendQueryParameter( - "copyid", Details::UrlEncodeQueryParameter(options.CopyId)); - request.AddHeader("x-ms-copy-action", "abort"); - if (options.LeaseId.HasValue()) - { - request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - AbortCopyBlobFromUriResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 204)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct CreateBlobSnapshotOptions - { - Azure::Core::Nullable Timeout; - std::map Metadata; - Azure::Core::Nullable LeaseId; - Azure::Core::Nullable EncryptionKey; - Azure::Core::Nullable EncryptionKeySha256; - Azure::Core::Nullable EncryptionAlgorithm; - Azure::Core::Nullable EncryptionScope; - Azure::Core::Nullable IfModifiedSince; - Azure::Core::Nullable IfUnmodifiedSince; - Azure::Core::Nullable IfMatch; - Azure::Core::Nullable IfNoneMatch; - Azure::Core::Nullable IfTags; - }; // struct CreateBlobSnapshotOptions - - static Azure::Core::Response CreateSnapshot( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const CreateBlobSnapshotOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); - request.AddHeader("Content-Length", "0"); - request.GetUrl().AppendQueryParameter("comp", "snapshot"); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - if (options.EncryptionKey.HasValue()) - { - request.AddHeader("x-ms-encryption-key", options.EncryptionKey.GetValue()); - } - if (options.EncryptionKeySha256.HasValue()) - { - request.AddHeader("x-ms-encryption-key-sha256", options.EncryptionKeySha256.GetValue()); - } - if (options.EncryptionAlgorithm.HasValue()) - { - request.AddHeader( - "x-ms-encryption-algorithm", - EncryptionAlgorithmTypeToString(options.EncryptionAlgorithm.GetValue())); - } - if (options.EncryptionScope.HasValue()) - { - request.AddHeader("x-ms-encryption-scope", options.EncryptionScope.GetValue()); - } - std::set metadataKeys; - for (const auto& pair : options.Metadata) - { - if (metadataKeys.insert(Azure::Core::Strings::ToLower(pair.first)).second == false) - { - throw std::runtime_error("duplicate keys in metadata"); - } - request.AddHeader("x-ms-meta-" + pair.first, pair.second); - } - metadataKeys.clear(); - if (options.LeaseId.HasValue()) - { - request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); - } - if (options.IfModifiedSince.HasValue()) - { - request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); - } - if (options.IfUnmodifiedSince.HasValue()) - { - request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); - } - if (options.IfMatch.HasValue()) - { - request.AddHeader("If-Match", options.IfMatch.GetValue()); - } - if (options.IfNoneMatch.HasValue()) - { - request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); - } - if (options.IfTags.HasValue()) - { - request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - CreateBlobSnapshotResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 201)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - response.ETag = httpResponse.GetHeaders().at("etag"); - response.LastModified = httpResponse.GetHeaders().at("last-modified"); - auto response_server_encrypted_iterator - = httpResponse.GetHeaders().find("x-ms-request-server-encrypted"); - if (response_server_encrypted_iterator != httpResponse.GetHeaders().end()) - { - response.ServerEncrypted = response_server_encrypted_iterator->second == "true"; - } - auto response_encryption_key_sha256_iterator - = httpResponse.GetHeaders().find("x-ms-encryption-key-sha256"); - if (response_encryption_key_sha256_iterator != httpResponse.GetHeaders().end()) - { - response.EncryptionKeySha256 = response_encryption_key_sha256_iterator->second; - } - auto response_encryption_scope_iterator - = httpResponse.GetHeaders().find("x-ms-encryption-scope"); - if (response_encryption_scope_iterator != httpResponse.GetHeaders().end()) - { - response.EncryptionScope = response_encryption_scope_iterator->second; - } - response.Snapshot = httpResponse.GetHeaders().at("x-ms-snapshot"); - auto response_version_id_iterator = httpResponse.GetHeaders().find("x-ms-version-id"); - if (response_version_id_iterator != httpResponse.GetHeaders().end()) - { - response.VersionId = response_version_id_iterator->second; - } - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct GetBlobTagsOptions - { - Azure::Core::Nullable Timeout; - Azure::Core::Nullable IfTags; - }; // struct GetBlobTagsOptions - - static Azure::Core::Response GetTags( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const GetBlobTagsOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - request.GetUrl().AppendQueryParameter("comp", "tags"); - if (options.IfTags.HasValue()) - { - request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - GetBlobTagsResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 200)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - { - const auto& httpResponseBody = httpResponse.GetBody(); - XmlReader reader( - reinterpret_cast(httpResponseBody.data()), httpResponseBody.size()); - response = GetBlobTagsResultFromXml(reader); - } - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct SetBlobTagsOptions - { - Azure::Core::Nullable Timeout; - std::map Tags; - Azure::Core::Nullable IfTags; - }; // struct SetBlobTagsOptions - - static Azure::Core::Response SetTags( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const SetBlobTagsOptions& options) - { - unused(options); - std::string xml_body; - { - XmlWriter writer; - SetBlobTagsOptionsToXml(writer, options); - xml_body = writer.GetDocument(); - writer.Write(XmlNode{XmlNodeType::End}); - } - Azure::Core::Http::MemoryBodyStream xml_body_stream( - reinterpret_cast(xml_body.data()), xml_body.length()); - auto request - = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url, &xml_body_stream); - request.AddHeader("Content-Length", std::to_string(xml_body_stream.Length())); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - request.GetUrl().AppendQueryParameter("comp", "tags"); - request.AddHeader("Content-Type", "application/xml; charset=UTF-8"); - if (options.IfTags.HasValue()) - { - request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - SetBlobTagsResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 204)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct AcquireBlobLeaseOptions - { - Azure::Core::Nullable Timeout; - int32_t LeaseDuration = -1; - Azure::Core::Nullable ProposedLeaseId; - Azure::Core::Nullable IfModifiedSince; - Azure::Core::Nullable IfUnmodifiedSince; - Azure::Core::Nullable IfMatch; - Azure::Core::Nullable IfNoneMatch; - Azure::Core::Nullable IfTags; - }; // struct AcquireBlobLeaseOptions - - static Azure::Core::Response AcquireLease( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const AcquireBlobLeaseOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); - request.AddHeader("Content-Length", "0"); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - request.GetUrl().AppendQueryParameter("comp", "lease"); - request.AddHeader("x-ms-lease-action", "acquire"); - request.AddHeader("x-ms-lease-duration", std::to_string(options.LeaseDuration)); - if (options.ProposedLeaseId.HasValue()) - { - request.AddHeader("x-ms-proposed-lease-id", options.ProposedLeaseId.GetValue()); - } - if (options.IfModifiedSince.HasValue()) - { - request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); - } - if (options.IfUnmodifiedSince.HasValue()) - { - request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); - } - if (options.IfMatch.HasValue()) - { - request.AddHeader("If-Match", options.IfMatch.GetValue()); - } - if (options.IfNoneMatch.HasValue()) - { - request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); - } - if (options.IfTags.HasValue()) - { - request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - AcquireBlobLeaseResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 201)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - response.ETag = httpResponse.GetHeaders().at("etag"); - response.LastModified = httpResponse.GetHeaders().at("last-modified"); - response.LeaseId = httpResponse.GetHeaders().at("x-ms-lease-id"); - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct RenewBlobLeaseOptions - { - Azure::Core::Nullable Timeout; - std::string LeaseId; - Azure::Core::Nullable IfModifiedSince; - Azure::Core::Nullable IfUnmodifiedSince; - Azure::Core::Nullable IfMatch; - Azure::Core::Nullable IfNoneMatch; - Azure::Core::Nullable IfTags; - }; // struct RenewBlobLeaseOptions - - static Azure::Core::Response RenewLease( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const RenewBlobLeaseOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); - request.AddHeader("Content-Length", "0"); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - request.GetUrl().AppendQueryParameter("comp", "lease"); - request.AddHeader("x-ms-lease-action", "renew"); - request.AddHeader("x-ms-lease-id", options.LeaseId); - if (options.IfModifiedSince.HasValue()) - { - request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); - } - if (options.IfUnmodifiedSince.HasValue()) - { - request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); - } - if (options.IfMatch.HasValue()) - { - request.AddHeader("If-Match", options.IfMatch.GetValue()); - } - if (options.IfNoneMatch.HasValue()) - { - request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); - } - if (options.IfTags.HasValue()) - { - request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - RenewBlobLeaseResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 200)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - response.ETag = httpResponse.GetHeaders().at("etag"); - response.LastModified = httpResponse.GetHeaders().at("last-modified"); - response.LeaseId = httpResponse.GetHeaders().at("x-ms-lease-id"); - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct ChangeBlobLeaseOptions - { - Azure::Core::Nullable Timeout; - std::string LeaseId; - std::string ProposedLeaseId; - Azure::Core::Nullable IfModifiedSince; - Azure::Core::Nullable IfUnmodifiedSince; - Azure::Core::Nullable IfMatch; - Azure::Core::Nullable IfNoneMatch; - Azure::Core::Nullable IfTags; - }; // struct ChangeBlobLeaseOptions - - static Azure::Core::Response ChangeLease( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const ChangeBlobLeaseOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); - request.AddHeader("Content-Length", "0"); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - request.GetUrl().AppendQueryParameter("comp", "lease"); - request.AddHeader("x-ms-lease-action", "change"); - request.AddHeader("x-ms-lease-id", options.LeaseId); - request.AddHeader("x-ms-proposed-lease-id", options.ProposedLeaseId); - if (options.IfModifiedSince.HasValue()) - { - request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); - } - if (options.IfUnmodifiedSince.HasValue()) - { - request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); - } - if (options.IfMatch.HasValue()) - { - request.AddHeader("If-Match", options.IfMatch.GetValue()); - } - if (options.IfNoneMatch.HasValue()) - { - request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); - } - if (options.IfTags.HasValue()) - { - request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - ChangeBlobLeaseResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 200)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - response.ETag = httpResponse.GetHeaders().at("etag"); - response.LastModified = httpResponse.GetHeaders().at("last-modified"); - response.LeaseId = httpResponse.GetHeaders().at("x-ms-lease-id"); - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct ReleaseBlobLeaseOptions - { - Azure::Core::Nullable Timeout; - std::string LeaseId; - Azure::Core::Nullable IfModifiedSince; - Azure::Core::Nullable IfUnmodifiedSince; - Azure::Core::Nullable IfMatch; - Azure::Core::Nullable IfNoneMatch; - Azure::Core::Nullable IfTags; - }; // struct ReleaseBlobLeaseOptions - - static Azure::Core::Response ReleaseLease( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const ReleaseBlobLeaseOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); - request.AddHeader("Content-Length", "0"); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - request.GetUrl().AppendQueryParameter("comp", "lease"); - request.AddHeader("x-ms-lease-action", "release"); - request.AddHeader("x-ms-lease-id", options.LeaseId); - if (options.IfModifiedSince.HasValue()) - { - request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); - } - if (options.IfUnmodifiedSince.HasValue()) - { - request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); - } - if (options.IfMatch.HasValue()) - { - request.AddHeader("If-Match", options.IfMatch.GetValue()); - } - if (options.IfNoneMatch.HasValue()) - { - request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); - } - if (options.IfTags.HasValue()) - { - request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - ReleaseBlobLeaseResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 200)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - response.ETag = httpResponse.GetHeaders().at("etag"); - response.LastModified = httpResponse.GetHeaders().at("last-modified"); - auto response_sequence_number_iterator - = httpResponse.GetHeaders().find("x-ms-blob-sequence-number"); - if (response_sequence_number_iterator != httpResponse.GetHeaders().end()) - { - response.SequenceNumber = std::stoll(response_sequence_number_iterator->second); - } - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct BreakBlobLeaseOptions - { - Azure::Core::Nullable Timeout; - Azure::Core::Nullable BreakPeriod; - Azure::Core::Nullable IfModifiedSince; - Azure::Core::Nullable IfUnmodifiedSince; - Azure::Core::Nullable IfMatch; - Azure::Core::Nullable IfNoneMatch; - Azure::Core::Nullable IfTags; - }; // struct BreakBlobLeaseOptions - - static Azure::Core::Response BreakLease( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const BreakBlobLeaseOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); - request.AddHeader("Content-Length", "0"); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - request.GetUrl().AppendQueryParameter("comp", "lease"); - request.AddHeader("x-ms-lease-action", "break"); - if (options.BreakPeriod.HasValue()) - { - request.AddHeader( - "x-ms-lease-break-period", std::to_string(options.BreakPeriod.GetValue())); - } - if (options.IfModifiedSince.HasValue()) - { - request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); - } - if (options.IfUnmodifiedSince.HasValue()) - { - request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); - } - if (options.IfMatch.HasValue()) - { - request.AddHeader("If-Match", options.IfMatch.GetValue()); - } - if (options.IfNoneMatch.HasValue()) - { - request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); - } - if (options.IfTags.HasValue()) - { - request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - BreakBlobLeaseResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 202)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - response.ETag = httpResponse.GetHeaders().at("etag"); - response.LastModified = httpResponse.GetHeaders().at("last-modified"); - response.LeaseTime = std::stoi(httpResponse.GetHeaders().at("x-ms-lease-time")); - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - private: - static GetBlobTagsResult GetBlobTagsResultFromXml(XmlReader& reader) - { - GetBlobTagsResult ret; - enum class XmlTagName - { - k_Tags, - k_TagSet, - k_Unknown, - }; - std::vector path; - while (true) - { - auto node = reader.Read(); - if (node.Type == XmlNodeType::End) - { - break; - } - else if (node.Type == XmlNodeType::EndTag) - { - if (path.size() > 0) - { - path.pop_back(); + request.AddHeader( + "x-ms-source-range", + "bytes=" + std::to_string(startOffset) + "-" + std::to_string(endOffset)); } else { - break; + request.AddHeader("x-ms-source-range", "bytes=" + std::to_string(startOffset) + "-"); } } - else if (node.Type == XmlNodeType::StartTag) - { - if (std::strcmp(node.Name, "Tags") == 0) - { - path.emplace_back(XmlTagName::k_Tags); - } - else if (std::strcmp(node.Name, "TagSet") == 0) - { - path.emplace_back(XmlTagName::k_TagSet); - } - else - { - path.emplace_back(XmlTagName::k_Unknown); - } - if (path.size() == 2 && path[0] == XmlTagName::k_Tags - && path[1] == XmlTagName::k_TagSet) - { - ret.Tags = TagsFromXml(reader); - path.pop_back(); - } - } - else if (node.Type == XmlNodeType::Text) - { - } - } - return ret; - } - - static std::map TagsFromXml(XmlReader& reader) - { - std::map ret; - int depth = 0; - std::string key; - bool is_key = false; - bool is_value = false; - while (true) - { - auto node = reader.Read(); - if (node.Type == XmlNodeType::End) - { - break; - } - else if (node.Type == XmlNodeType::StartTag) - { - ++depth; - if (strcmp(node.Name, "Key") == 0) - { - is_key = true; - } - else if (strcmp(node.Name, "Value") == 0) - { - is_value = true; - } - } - else if (node.Type == XmlNodeType::EndTag) - { - if (depth-- == 0) - { - break; - } - } - if (depth == 2 && node.Type == XmlNodeType::Text) - { - if (is_key) - { - key = node.Value; - is_key = false; - } - else if (is_value) - { - ret.emplace(std::move(key), node.Value); - is_value = false; - } - } - } - return ret; - } - - static void SetBlobTagsOptionsToXml(XmlWriter& writer, const SetBlobTagsOptions& options) - { - writer.Write(XmlNode{XmlNodeType::StartTag, "Tags"}); - writer.Write(XmlNode{XmlNodeType::StartTag, "TagSet"}); - for (const auto& i : options.Tags) - { - writer.Write(XmlNode{XmlNodeType::StartTag, "Tag"}); - writer.Write(XmlNode{XmlNodeType::StartTag, "Key"}); - writer.Write(XmlNode{XmlNodeType::Text, nullptr, i.first.data()}); - writer.Write(XmlNode{XmlNodeType::EndTag}); - writer.Write(XmlNode{XmlNodeType::StartTag, "Value"}); - writer.Write(XmlNode{XmlNodeType::Text, nullptr, i.second.data()}); - writer.Write(XmlNode{XmlNodeType::EndTag}); - writer.Write(XmlNode{XmlNodeType::EndTag}); - } - writer.Write(XmlNode{XmlNodeType::EndTag}); - writer.Write(XmlNode{XmlNodeType::EndTag}); - } - - }; // class Blob - - class BlockBlob { - public: - struct UploadBlockBlobOptions - { - Azure::Core::Nullable Timeout; - Azure::Core::Nullable TransactionalContentMd5; - Azure::Core::Nullable TransactionalContentCrc64; - BlobHttpHeaders HttpHeaders; - std::map Metadata; - Azure::Core::Nullable LeaseId; - Azure::Core::Nullable Tier; - Azure::Core::Nullable EncryptionKey; - Azure::Core::Nullable EncryptionKeySha256; - Azure::Core::Nullable EncryptionAlgorithm; - Azure::Core::Nullable EncryptionScope; - Azure::Core::Nullable IfModifiedSince; - Azure::Core::Nullable IfUnmodifiedSince; - Azure::Core::Nullable IfMatch; - Azure::Core::Nullable IfNoneMatch; - Azure::Core::Nullable IfTags; - }; // struct UploadBlockBlobOptions - - static Azure::Core::Response Upload( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - Azure::Core::Http::BodyStream* requestBody, - const UploadBlockBlobOptions& options) - { - unused(options); - auto request - = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url, requestBody); - request.AddHeader("Content-Length", std::to_string(requestBody->Length())); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - if (options.EncryptionKey.HasValue()) - { - request.AddHeader("x-ms-encryption-key", options.EncryptionKey.GetValue()); - } - if (options.EncryptionKeySha256.HasValue()) - { - request.AddHeader("x-ms-encryption-key-sha256", options.EncryptionKeySha256.GetValue()); - } - if (options.EncryptionAlgorithm.HasValue()) - { - request.AddHeader( - "x-ms-encryption-algorithm", - EncryptionAlgorithmTypeToString(options.EncryptionAlgorithm.GetValue())); - } - if (options.EncryptionScope.HasValue()) - { - request.AddHeader("x-ms-encryption-scope", options.EncryptionScope.GetValue()); - } - if (options.TransactionalContentMd5.HasValue()) - { - request.AddHeader("Content-MD5", options.TransactionalContentMd5.GetValue()); - } - if (options.TransactionalContentCrc64.HasValue()) - { - request.AddHeader("x-ms-content-crc64", options.TransactionalContentCrc64.GetValue()); - } - if (!options.HttpHeaders.ContentType.empty()) - { - request.AddHeader("x-ms-blob-content-type", options.HttpHeaders.ContentType); - } - if (!options.HttpHeaders.ContentEncoding.empty()) - { - request.AddHeader("x-ms-blob-content-encoding", options.HttpHeaders.ContentEncoding); - } - if (!options.HttpHeaders.ContentLanguage.empty()) - { - request.AddHeader("x-ms-blob-content-language", options.HttpHeaders.ContentLanguage); - } - if (!options.HttpHeaders.CacheControl.empty()) - { - request.AddHeader("x-ms-blob-cache-control", options.HttpHeaders.CacheControl); - } - if (!options.HttpHeaders.ContentMd5.empty()) - { - request.AddHeader("x-ms-blob-content-md5", options.HttpHeaders.ContentMd5); - } - if (!options.HttpHeaders.ContentDisposition.empty()) - { - request.AddHeader( - "x-ms-blob-content-disposition", options.HttpHeaders.ContentDisposition); - } - std::set metadataKeys; - for (const auto& pair : options.Metadata) - { - if (metadataKeys.insert(Azure::Core::Strings::ToLower(pair.first)).second == false) - { - throw std::runtime_error("duplicate keys in metadata"); - } - request.AddHeader("x-ms-meta-" + pair.first, pair.second); - } - metadataKeys.clear(); - if (options.LeaseId.HasValue()) - { - request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); - } - request.AddHeader("x-ms-blob-type", "BlockBlob"); - if (options.Tier.HasValue()) - { - request.AddHeader("x-ms-access-tier", AccessTierToString(options.Tier.GetValue())); - } - if (options.IfModifiedSince.HasValue()) - { - request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); - } - if (options.IfUnmodifiedSince.HasValue()) - { - request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); - } - if (options.IfMatch.HasValue()) - { - request.AddHeader("If-Match", options.IfMatch.GetValue()); - } - if (options.IfNoneMatch.HasValue()) - { - request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); - } - if (options.IfTags.HasValue()) - { - request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - UploadBlockBlobResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 201)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - response.ETag = httpResponse.GetHeaders().at("etag"); - response.LastModified = httpResponse.GetHeaders().at("last-modified"); - auto response_transactional_content_md5_iterator - = httpResponse.GetHeaders().find("content-md5"); - if (response_transactional_content_md5_iterator != httpResponse.GetHeaders().end()) - { - response.TransactionalContentMd5 = response_transactional_content_md5_iterator->second; - } - auto response_transactional_content_crc64_iterator - = httpResponse.GetHeaders().find("x-ms-content-crc64"); - if (response_transactional_content_crc64_iterator != httpResponse.GetHeaders().end()) - { - response.TransactionalContentCrc64 - = response_transactional_content_crc64_iterator->second; - } - auto response_version_id_iterator = httpResponse.GetHeaders().find("x-ms-version-id"); - if (response_version_id_iterator != httpResponse.GetHeaders().end()) - { - response.VersionId = response_version_id_iterator->second; - } - auto response_server_encrypted_iterator - = httpResponse.GetHeaders().find("x-ms-request-server-encrypted"); - if (response_server_encrypted_iterator != httpResponse.GetHeaders().end()) - { - response.ServerEncrypted = response_server_encrypted_iterator->second == "true"; - } - auto response_encryption_key_sha256_iterator - = httpResponse.GetHeaders().find("x-ms-encryption-key-sha256"); - if (response_encryption_key_sha256_iterator != httpResponse.GetHeaders().end()) - { - response.EncryptionKeySha256 = response_encryption_key_sha256_iterator->second; - } - auto response_encryption_scope_iterator - = httpResponse.GetHeaders().find("x-ms-encryption-scope"); - if (response_encryption_scope_iterator != httpResponse.GetHeaders().end()) - { - response.EncryptionScope = response_encryption_scope_iterator->second; - } - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct StageBlockOptions - { - Azure::Core::Nullable Timeout; - std::string BlockId; - Azure::Core::Nullable TransactionalContentMd5; - Azure::Core::Nullable TransactionalContentCrc64; - Azure::Core::Nullable LeaseId; - Azure::Core::Nullable EncryptionKey; - Azure::Core::Nullable EncryptionKeySha256; - Azure::Core::Nullable EncryptionAlgorithm; - Azure::Core::Nullable EncryptionScope; - }; // struct StageBlockOptions - - static Azure::Core::Response StageBlock( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - Azure::Core::Http::BodyStream* requestBody, - const StageBlockOptions& options) - { - unused(options); - auto request - = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url, requestBody); - request.AddHeader("Content-Length", std::to_string(requestBody->Length())); - request.GetUrl().AppendQueryParameter("comp", "block"); - request.GetUrl().AppendQueryParameter( - "blockid", Details::UrlEncodeQueryParameter(options.BlockId)); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - if (options.TransactionalContentMd5.HasValue()) - { - request.AddHeader("Content-MD5", options.TransactionalContentMd5.GetValue()); - } - if (options.TransactionalContentCrc64.HasValue()) - { - request.AddHeader("x-ms-content-crc64", options.TransactionalContentCrc64.GetValue()); - } - if (options.LeaseId.HasValue()) - { - request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); - } - if (options.EncryptionKey.HasValue()) - { - request.AddHeader("x-ms-encryption-key", options.EncryptionKey.GetValue()); - } - if (options.EncryptionKeySha256.HasValue()) - { - request.AddHeader("x-ms-encryption-key-sha256", options.EncryptionKeySha256.GetValue()); - } - if (options.EncryptionAlgorithm.HasValue()) - { - request.AddHeader( - "x-ms-encryption-algorithm", - EncryptionAlgorithmTypeToString(options.EncryptionAlgorithm.GetValue())); - } - if (options.EncryptionScope.HasValue()) - { - request.AddHeader("x-ms-encryption-scope", options.EncryptionScope.GetValue()); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - StageBlockResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 201)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - auto response_transactional_content_md5_iterator - = httpResponse.GetHeaders().find("content-md5"); - if (response_transactional_content_md5_iterator != httpResponse.GetHeaders().end()) - { - response.TransactionalContentMd5 = response_transactional_content_md5_iterator->second; - } - auto response_transactional_content_crc64_iterator - = httpResponse.GetHeaders().find("x-ms-content-crc64"); - if (response_transactional_content_crc64_iterator != httpResponse.GetHeaders().end()) - { - response.TransactionalContentCrc64 - = response_transactional_content_crc64_iterator->second; - } - auto response_server_encrypted_iterator - = httpResponse.GetHeaders().find("x-ms-request-server-encrypted"); - if (response_server_encrypted_iterator != httpResponse.GetHeaders().end()) - { - response.ServerEncrypted = response_server_encrypted_iterator->second == "true"; - } - auto response_encryption_key_sha256_iterator - = httpResponse.GetHeaders().find("x-ms-encryption-key-sha256"); - if (response_encryption_key_sha256_iterator != httpResponse.GetHeaders().end()) - { - response.EncryptionKeySha256 = response_encryption_key_sha256_iterator->second; - } - auto response_encryption_scope_iterator - = httpResponse.GetHeaders().find("x-ms-encryption-scope"); - if (response_encryption_scope_iterator != httpResponse.GetHeaders().end()) - { - response.EncryptionScope = response_encryption_scope_iterator->second; - } - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct StageBlockFromUriOptions - { - Azure::Core::Nullable Timeout; - std::string BlockId; - std::string SourceUri; - Azure::Core::Nullable> SourceRange; - Azure::Core::Nullable TransactionalContentMd5; - Azure::Core::Nullable TransactionalContentCrc64; - Azure::Core::Nullable LeaseId; - Azure::Core::Nullable EncryptionKey; - Azure::Core::Nullable EncryptionKeySha256; - Azure::Core::Nullable EncryptionAlgorithm; - Azure::Core::Nullable EncryptionScope; - Azure::Core::Nullable SourceIfModifiedSince; - Azure::Core::Nullable SourceIfUnmodifiedSince; - Azure::Core::Nullable SourceIfMatch; - Azure::Core::Nullable SourceIfNoneMatch; - }; // struct StageBlockFromUriOptions - - static Azure::Core::Response StageBlockFromUri( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const StageBlockFromUriOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); - request.AddHeader("Content-Length", "0"); - request.GetUrl().AppendQueryParameter("comp", "block"); - request.GetUrl().AppendQueryParameter( - "blockid", Details::UrlEncodeQueryParameter(options.BlockId)); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - request.AddHeader("x-ms-copy-source", options.SourceUri); - if (options.SourceRange.HasValue()) - { - auto startOffset = options.SourceRange.GetValue().first; - auto endOffset = options.SourceRange.GetValue().second; - if (endOffset != std::numeric_limits::max()) + if (options.TransactionalContentMd5.HasValue()) { request.AddHeader( - "x-ms-source_range", - "bytes=" + std::to_string(startOffset) + "-" + std::to_string(endOffset)); + "x-ms-source-content-md5", options.TransactionalContentMd5.GetValue()); } - else - { - request.AddHeader("x-ms-source_range", "bytes=" + std::to_string(startOffset) + "-"); - } - } - if (options.TransactionalContentMd5.HasValue()) - { - request.AddHeader("x-ms-source-content-md5", options.TransactionalContentMd5.GetValue()); - } - if (options.TransactionalContentCrc64.HasValue()) - { - request.AddHeader( - "x-ms-source-content-crc64", options.TransactionalContentCrc64.GetValue()); - } - if (options.LeaseId.HasValue()) - { - request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); - } - if (options.EncryptionKey.HasValue()) - { - request.AddHeader("x-ms-encryption-key", options.EncryptionKey.GetValue()); - } - if (options.EncryptionKeySha256.HasValue()) - { - request.AddHeader("x-ms-encryption-key-sha256", options.EncryptionKeySha256.GetValue()); - } - if (options.EncryptionAlgorithm.HasValue()) - { - request.AddHeader( - "x-ms-encryption-algorithm", - EncryptionAlgorithmTypeToString(options.EncryptionAlgorithm.GetValue())); - } - if (options.EncryptionScope.HasValue()) - { - request.AddHeader("x-ms-encryption-scope", options.EncryptionScope.GetValue()); - } - if (options.SourceIfModifiedSince.HasValue()) - { - request.AddHeader( - "x-ms-source-if-modified-since", options.SourceIfModifiedSince.GetValue()); - } - if (options.SourceIfUnmodifiedSince.HasValue()) - { - request.AddHeader( - "x-ms-source-if-unmodified-since", options.SourceIfUnmodifiedSince.GetValue()); - } - if (options.SourceIfMatch.HasValue()) - { - request.AddHeader("x-ms-source-if-match", options.SourceIfMatch.GetValue()); - } - if (options.SourceIfNoneMatch.HasValue()) - { - request.AddHeader("x-ms-source-if-none-match", options.SourceIfNoneMatch.GetValue()); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - StageBlockFromUriResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 201)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - auto response_transactional_content_md5_iterator - = httpResponse.GetHeaders().find("content-md5"); - if (response_transactional_content_md5_iterator != httpResponse.GetHeaders().end()) - { - response.TransactionalContentMd5 = response_transactional_content_md5_iterator->second; - } - auto response_transactional_content_crc64_iterator - = httpResponse.GetHeaders().find("x-ms-content-crc64"); - if (response_transactional_content_crc64_iterator != httpResponse.GetHeaders().end()) - { - response.TransactionalContentCrc64 - = response_transactional_content_crc64_iterator->second; - } - auto response_server_encrypted_iterator - = httpResponse.GetHeaders().find("x-ms-request-server-encrypted"); - if (response_server_encrypted_iterator != httpResponse.GetHeaders().end()) - { - response.ServerEncrypted = response_server_encrypted_iterator->second == "true"; - } - auto response_encryption_key_sha256_iterator - = httpResponse.GetHeaders().find("x-ms-encryption-key-sha256"); - if (response_encryption_key_sha256_iterator != httpResponse.GetHeaders().end()) - { - response.EncryptionKeySha256 = response_encryption_key_sha256_iterator->second; - } - auto response_encryption_scope_iterator - = httpResponse.GetHeaders().find("x-ms-encryption-scope"); - if (response_encryption_scope_iterator != httpResponse.GetHeaders().end()) - { - response.EncryptionScope = response_encryption_scope_iterator->second; - } - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct CommitBlockListOptions - { - Azure::Core::Nullable Timeout; - std::vector> BlockList; - BlobHttpHeaders HttpHeaders; - std::map Metadata; - Azure::Core::Nullable LeaseId; - Azure::Core::Nullable EncryptionKey; - Azure::Core::Nullable EncryptionKeySha256; - Azure::Core::Nullable EncryptionAlgorithm; - Azure::Core::Nullable EncryptionScope; - Azure::Core::Nullable IfModifiedSince; - Azure::Core::Nullable IfUnmodifiedSince; - Azure::Core::Nullable IfMatch; - Azure::Core::Nullable IfNoneMatch; - Azure::Core::Nullable IfTags; - Azure::Core::Nullable Tier; - }; // struct CommitBlockListOptions - - static Azure::Core::Response CommitBlockList( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const CommitBlockListOptions& options) - { - unused(options); - std::string xml_body; - { - XmlWriter writer; - CommitBlockListOptionsToXml(writer, options); - xml_body = writer.GetDocument(); - writer.Write(XmlNode{XmlNodeType::End}); - } - Azure::Core::Http::MemoryBodyStream xml_body_stream( - reinterpret_cast(xml_body.data()), xml_body.length()); - auto request - = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url, &xml_body_stream); - request.AddHeader("Content-Length", std::to_string(xml_body_stream.Length())); - request.GetUrl().AppendQueryParameter("comp", "blocklist"); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - if (!options.HttpHeaders.ContentType.empty()) - { - request.AddHeader("x-ms-blob-content-type", options.HttpHeaders.ContentType); - } - if (!options.HttpHeaders.ContentEncoding.empty()) - { - request.AddHeader("x-ms-blob-content-encoding", options.HttpHeaders.ContentEncoding); - } - if (!options.HttpHeaders.ContentLanguage.empty()) - { - request.AddHeader("x-ms-blob-content-language", options.HttpHeaders.ContentLanguage); - } - if (!options.HttpHeaders.CacheControl.empty()) - { - request.AddHeader("x-ms-blob-cache-control", options.HttpHeaders.CacheControl); - } - if (!options.HttpHeaders.ContentMd5.empty()) - { - request.AddHeader("x-ms-blob-content-md5", options.HttpHeaders.ContentMd5); - } - if (!options.HttpHeaders.ContentDisposition.empty()) - { - request.AddHeader( - "x-ms-blob-content-disposition", options.HttpHeaders.ContentDisposition); - } - std::set metadataKeys; - for (const auto& pair : options.Metadata) - { - if (metadataKeys.insert(Azure::Core::Strings::ToLower(pair.first)).second == false) - { - throw std::runtime_error("duplicate keys in metadata"); - } - request.AddHeader("x-ms-meta-" + pair.first, pair.second); - } - metadataKeys.clear(); - if (options.LeaseId.HasValue()) - { - request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); - } - if (options.EncryptionKey.HasValue()) - { - request.AddHeader("x-ms-encryption-key", options.EncryptionKey.GetValue()); - } - if (options.EncryptionKeySha256.HasValue()) - { - request.AddHeader("x-ms-encryption-key-sha256", options.EncryptionKeySha256.GetValue()); - } - if (options.EncryptionAlgorithm.HasValue()) - { - request.AddHeader( - "x-ms-encryption-algorithm", - EncryptionAlgorithmTypeToString(options.EncryptionAlgorithm.GetValue())); - } - if (options.EncryptionScope.HasValue()) - { - request.AddHeader("x-ms-encryption-scope", options.EncryptionScope.GetValue()); - } - if (options.Tier.HasValue()) - { - request.AddHeader("x-ms-access-tier", AccessTierToString(options.Tier.GetValue())); - } - if (options.IfModifiedSince.HasValue()) - { - request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); - } - if (options.IfUnmodifiedSince.HasValue()) - { - request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); - } - if (options.IfMatch.HasValue()) - { - request.AddHeader("If-Match", options.IfMatch.GetValue()); - } - if (options.IfNoneMatch.HasValue()) - { - request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); - } - if (options.IfTags.HasValue()) - { - request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - CommitBlockListResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 201)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - response.ETag = httpResponse.GetHeaders().at("etag"); - response.LastModified = httpResponse.GetHeaders().at("last-modified"); - auto response_version_id_iterator = httpResponse.GetHeaders().find("x-ms-version-id"); - if (response_version_id_iterator != httpResponse.GetHeaders().end()) - { - response.VersionId = response_version_id_iterator->second; - } - auto response_server_encrypted_iterator - = httpResponse.GetHeaders().find("x-ms-request-server-encrypted"); - if (response_server_encrypted_iterator != httpResponse.GetHeaders().end()) - { - response.ServerEncrypted = response_server_encrypted_iterator->second == "true"; - } - auto response_encryption_key_sha256_iterator - = httpResponse.GetHeaders().find("x-ms-encryption-key-sha256"); - if (response_encryption_key_sha256_iterator != httpResponse.GetHeaders().end()) - { - response.EncryptionKeySha256 = response_encryption_key_sha256_iterator->second; - } - auto response_encryption_scope_iterator - = httpResponse.GetHeaders().find("x-ms-encryption-scope"); - if (response_encryption_scope_iterator != httpResponse.GetHeaders().end()) - { - response.EncryptionScope = response_encryption_scope_iterator->second; - } - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct GetBlockListOptions - { - Azure::Core::Nullable Timeout; - Azure::Core::Nullable ListType; - Azure::Core::Nullable LeaseId; - Azure::Core::Nullable IfTags; - }; // struct GetBlockListOptions - - static Azure::Core::Response GetBlockList( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const GetBlockListOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url); - request.GetUrl().AppendQueryParameter("comp", "blocklist"); - if (options.ListType.HasValue()) - { - std::string block_list_type_option - = BlockListTypeOptionToString(options.ListType.GetValue()); - request.GetUrl().AppendQueryParameter( - "blocklisttype", Details::UrlEncodeQueryParameter(block_list_type_option)); - } - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - if (options.LeaseId.HasValue()) - { - request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); - } - if (options.IfTags.HasValue()) - { - request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - GetBlockListResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 200)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - { - const auto& httpResponseBody = httpResponse.GetBody(); - XmlReader reader( - reinterpret_cast(httpResponseBody.data()), httpResponseBody.size()); - response = GetBlockListResultFromXml(reader); - } - response.ETag = httpResponse.GetHeaders().at("etag"); - response.LastModified = httpResponse.GetHeaders().at("last-modified"); - response.ContentType = httpResponse.GetHeaders().at("content-type"); - response.ContentLength - = std::stoll(httpResponse.GetHeaders().at("x-ms-blob-content-length")); - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - private: - static GetBlockListResult GetBlockListResultFromXml(XmlReader& reader) - { - GetBlockListResult ret; - enum class XmlTagName - { - k_BlockList, - k_CommittedBlocks, - k_Block, - k_UncommittedBlocks, - k_Unknown, - }; - std::vector path; - while (true) - { - auto node = reader.Read(); - if (node.Type == XmlNodeType::End) - { - break; - } - else if (node.Type == XmlNodeType::EndTag) - { - if (path.size() > 0) - { - path.pop_back(); - } - else - { - break; - } - } - else if (node.Type == XmlNodeType::StartTag) - { - if (std::strcmp(node.Name, "BlockList") == 0) - { - path.emplace_back(XmlTagName::k_BlockList); - } - else if (std::strcmp(node.Name, "CommittedBlocks") == 0) - { - path.emplace_back(XmlTagName::k_CommittedBlocks); - } - else if (std::strcmp(node.Name, "Block") == 0) - { - path.emplace_back(XmlTagName::k_Block); - } - else if (std::strcmp(node.Name, "UncommittedBlocks") == 0) - { - path.emplace_back(XmlTagName::k_UncommittedBlocks); - } - else - { - path.emplace_back(XmlTagName::k_Unknown); - } - if (path.size() == 3 && path[0] == XmlTagName::k_BlockList - && path[1] == XmlTagName::k_CommittedBlocks && path[2] == XmlTagName::k_Block) - { - ret.CommittedBlocks.emplace_back(BlobBlockFromXml(reader)); - path.pop_back(); - } - else if ( - path.size() == 3 && path[0] == XmlTagName::k_BlockList - && path[1] == XmlTagName::k_UncommittedBlocks && path[2] == XmlTagName::k_Block) - { - ret.UncommittedBlocks.emplace_back(BlobBlockFromXml(reader)); - path.pop_back(); - } - } - else if (node.Type == XmlNodeType::Text) - { - } - } - return ret; - } - - static BlobBlock BlobBlockFromXml(XmlReader& reader) - { - BlobBlock ret; - enum class XmlTagName - { - k_Name, - k_Size, - k_Unknown, - }; - std::vector path; - while (true) - { - auto node = reader.Read(); - if (node.Type == XmlNodeType::End) - { - break; - } - else if (node.Type == XmlNodeType::EndTag) - { - if (path.size() > 0) - { - path.pop_back(); - } - else - { - break; - } - } - else if (node.Type == XmlNodeType::StartTag) - { - if (std::strcmp(node.Name, "Name") == 0) - { - path.emplace_back(XmlTagName::k_Name); - } - else if (std::strcmp(node.Name, "Size") == 0) - { - path.emplace_back(XmlTagName::k_Size); - } - else - { - path.emplace_back(XmlTagName::k_Unknown); - } - } - else if (node.Type == XmlNodeType::Text) - { - if (path.size() == 1 && path[0] == XmlTagName::k_Name) - { - ret.Name = node.Value; - } - else if (path.size() == 1 && path[0] == XmlTagName::k_Size) - { - ret.Size = std::stoll(node.Value); - } - } - } - return ret; - } - - static void CommitBlockListOptionsToXml( - XmlWriter& writer, - const CommitBlockListOptions& options) - { - writer.Write(XmlNode{XmlNodeType::StartTag, "BlockList"}); - for (const auto& i : options.BlockList) - { - writer.Write( - XmlNode{XmlNodeType::StartTag, BlockTypeToString(i.first).data(), i.second.data()}); - } - writer.Write(XmlNode{XmlNodeType::EndTag}); - } - - }; // class BlockBlob - - class PageBlob { - public: - struct CreatePageBlobOptions - { - Azure::Core::Nullable Timeout; - int64_t BlobContentLength = -1; - Azure::Core::Nullable SequenceNumber; - BlobHttpHeaders HttpHeaders; - std::map Metadata; - Azure::Core::Nullable LeaseId; - Azure::Core::Nullable Tier; - Azure::Core::Nullable EncryptionKey; - Azure::Core::Nullable EncryptionKeySha256; - Azure::Core::Nullable EncryptionAlgorithm; - Azure::Core::Nullable EncryptionScope; - Azure::Core::Nullable IfModifiedSince; - Azure::Core::Nullable IfUnmodifiedSince; - Azure::Core::Nullable IfMatch; - Azure::Core::Nullable IfNoneMatch; - Azure::Core::Nullable IfTags; - }; // struct CreatePageBlobOptions - - static Azure::Core::Response Create( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const CreatePageBlobOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); - request.AddHeader("Content-Length", "0"); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - if (!options.HttpHeaders.ContentType.empty()) - { - request.AddHeader("x-ms-blob-content-type", options.HttpHeaders.ContentType); - } - if (!options.HttpHeaders.ContentEncoding.empty()) - { - request.AddHeader("x-ms-blob-content-encoding", options.HttpHeaders.ContentEncoding); - } - if (!options.HttpHeaders.ContentLanguage.empty()) - { - request.AddHeader("x-ms-blob-content-language", options.HttpHeaders.ContentLanguage); - } - if (!options.HttpHeaders.CacheControl.empty()) - { - request.AddHeader("x-ms-blob-cache-control", options.HttpHeaders.CacheControl); - } - if (!options.HttpHeaders.ContentMd5.empty()) - { - request.AddHeader("x-ms-blob-content-md5", options.HttpHeaders.ContentMd5); - } - if (!options.HttpHeaders.ContentDisposition.empty()) - { - request.AddHeader( - "x-ms-blob-content-disposition", options.HttpHeaders.ContentDisposition); - } - std::set metadataKeys; - for (const auto& pair : options.Metadata) - { - if (metadataKeys.insert(Azure::Core::Strings::ToLower(pair.first)).second == false) - { - throw std::runtime_error("duplicate keys in metadata"); - } - request.AddHeader("x-ms-meta-" + pair.first, pair.second); - } - metadataKeys.clear(); - if (options.LeaseId.HasValue()) - { - request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); - } - request.AddHeader("x-ms-blob-type", "PageBlob"); - request.AddHeader("x-ms-blob-content-length", std::to_string(options.BlobContentLength)); - if (options.SequenceNumber.HasValue()) - { - request.AddHeader( - "x-ms-blob-sequence-number", std::to_string(options.SequenceNumber.GetValue())); - } - if (options.Tier.HasValue()) - { - request.AddHeader("x-ms-access-tier", AccessTierToString(options.Tier.GetValue())); - } - if (options.EncryptionKey.HasValue()) - { - request.AddHeader("x-ms-encryption-key", options.EncryptionKey.GetValue()); - } - if (options.EncryptionKeySha256.HasValue()) - { - request.AddHeader("x-ms-encryption-key-sha256", options.EncryptionKeySha256.GetValue()); - } - if (options.EncryptionAlgorithm.HasValue()) - { - request.AddHeader( - "x-ms-encryption-algorithm", - EncryptionAlgorithmTypeToString(options.EncryptionAlgorithm.GetValue())); - } - if (options.EncryptionScope.HasValue()) - { - request.AddHeader("x-ms-encryption-scope", options.EncryptionScope.GetValue()); - } - if (options.IfModifiedSince.HasValue()) - { - request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); - } - if (options.IfUnmodifiedSince.HasValue()) - { - request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); - } - if (options.IfMatch.HasValue()) - { - request.AddHeader("If-Match", options.IfMatch.GetValue()); - } - if (options.IfNoneMatch.HasValue()) - { - request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); - } - if (options.IfTags.HasValue()) - { - request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - CreatePageBlobResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 201)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - response.ETag = httpResponse.GetHeaders().at("etag"); - response.LastModified = httpResponse.GetHeaders().at("last-modified"); - auto response_version_id_iterator = httpResponse.GetHeaders().find("x-ms-version-id"); - if (response_version_id_iterator != httpResponse.GetHeaders().end()) - { - response.VersionId = response_version_id_iterator->second; - } - auto response_server_encrypted_iterator - = httpResponse.GetHeaders().find("x-ms-request-server-encrypted"); - if (response_server_encrypted_iterator != httpResponse.GetHeaders().end()) - { - response.ServerEncrypted = response_server_encrypted_iterator->second == "true"; - } - auto response_encryption_key_sha256_iterator - = httpResponse.GetHeaders().find("x-ms-encryption-key-sha256"); - if (response_encryption_key_sha256_iterator != httpResponse.GetHeaders().end()) - { - response.EncryptionKeySha256 = response_encryption_key_sha256_iterator->second; - } - auto response_encryption_scope_iterator - = httpResponse.GetHeaders().find("x-ms-encryption-scope"); - if (response_encryption_scope_iterator != httpResponse.GetHeaders().end()) - { - response.EncryptionScope = response_encryption_scope_iterator->second; - } - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct UploadPageBlobPagesOptions - { - Azure::Core::Nullable Timeout; - std::pair Range; - Azure::Core::Nullable TransactionalContentMd5; - Azure::Core::Nullable TransactionalContentCrc64; - Azure::Core::Nullable LeaseId; - Azure::Core::Nullable IfSequenceNumberLessThanOrEqualTo; - Azure::Core::Nullable IfSequenceNumberLessThan; - Azure::Core::Nullable IfSequenceNumberEqualTo; - Azure::Core::Nullable EncryptionKey; - Azure::Core::Nullable EncryptionKeySha256; - Azure::Core::Nullable EncryptionAlgorithm; - Azure::Core::Nullable EncryptionScope; - Azure::Core::Nullable IfModifiedSince; - Azure::Core::Nullable IfUnmodifiedSince; - Azure::Core::Nullable IfMatch; - Azure::Core::Nullable IfNoneMatch; - Azure::Core::Nullable IfTags; - }; // struct UploadPageBlobPagesOptions - - static Azure::Core::Response UploadPages( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - Azure::Core::Http::BodyStream* requestBody, - const UploadPageBlobPagesOptions& options) - { - unused(options); - auto request - = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url, requestBody); - request.AddHeader("Content-Length", std::to_string(requestBody->Length())); - request.GetUrl().AppendQueryParameter("comp", "page"); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - request.AddHeader( - "x-ms-range", - "bytes=" + std::to_string(options.Range.first) + "-" - + std::to_string(options.Range.second)); - if (options.TransactionalContentMd5.HasValue()) - { - request.AddHeader("Content-MD5", options.TransactionalContentMd5.GetValue()); - } - if (options.TransactionalContentCrc64.HasValue()) - { - request.AddHeader("x-ms-content-crc64", options.TransactionalContentCrc64.GetValue()); - } - request.AddHeader("x-ms-page-write", "update"); - if (options.LeaseId.HasValue()) - { - request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); - } - if (options.IfSequenceNumberLessThanOrEqualTo.HasValue()) - { - request.AddHeader( - "x-ms-if-sequence-number-le", - std::to_string(options.IfSequenceNumberLessThanOrEqualTo.GetValue())); - } - if (options.IfSequenceNumberLessThan.HasValue()) - { - request.AddHeader( - "x-ms-if-sequence-number-lt", - std::to_string(options.IfSequenceNumberLessThan.GetValue())); - } - if (options.IfSequenceNumberEqualTo.HasValue()) - { - request.AddHeader( - "x-ms-if-sequence-number-eq", - std::to_string(options.IfSequenceNumberEqualTo.GetValue())); - } - if (options.EncryptionKey.HasValue()) - { - request.AddHeader("x-ms-encryption-key", options.EncryptionKey.GetValue()); - } - if (options.EncryptionKeySha256.HasValue()) - { - request.AddHeader("x-ms-encryption-key-sha256", options.EncryptionKeySha256.GetValue()); - } - if (options.EncryptionAlgorithm.HasValue()) - { - request.AddHeader( - "x-ms-encryption-algorithm", - EncryptionAlgorithmTypeToString(options.EncryptionAlgorithm.GetValue())); - } - if (options.EncryptionScope.HasValue()) - { - request.AddHeader("x-ms-encryption-scope", options.EncryptionScope.GetValue()); - } - if (options.IfModifiedSince.HasValue()) - { - request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); - } - if (options.IfUnmodifiedSince.HasValue()) - { - request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); - } - if (options.IfMatch.HasValue()) - { - request.AddHeader("If-Match", options.IfMatch.GetValue()); - } - if (options.IfNoneMatch.HasValue()) - { - request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); - } - if (options.IfTags.HasValue()) - { - request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - UploadPageBlobPagesResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 201)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - response.ETag = httpResponse.GetHeaders().at("etag"); - response.LastModified = httpResponse.GetHeaders().at("last-modified"); - auto response_transactional_content_md5_iterator - = httpResponse.GetHeaders().find("content-md5"); - if (response_transactional_content_md5_iterator != httpResponse.GetHeaders().end()) - { - response.TransactionalContentMd5 = response_transactional_content_md5_iterator->second; - } - auto response_transactional_content_crc64_iterator - = httpResponse.GetHeaders().find("x-ms-content-crc64"); - if (response_transactional_content_crc64_iterator != httpResponse.GetHeaders().end()) - { - response.TransactionalContentCrc64 - = response_transactional_content_crc64_iterator->second; - } - response.SequenceNumber - = std::stoll(httpResponse.GetHeaders().at("x-ms-blob-sequence-number")); - auto response_server_encrypted_iterator - = httpResponse.GetHeaders().find("x-ms-request-server-encrypted"); - if (response_server_encrypted_iterator != httpResponse.GetHeaders().end()) - { - response.ServerEncrypted = response_server_encrypted_iterator->second == "true"; - } - auto response_encryption_key_sha256_iterator - = httpResponse.GetHeaders().find("x-ms-encryption-key-sha256"); - if (response_encryption_key_sha256_iterator != httpResponse.GetHeaders().end()) - { - response.EncryptionKeySha256 = response_encryption_key_sha256_iterator->second; - } - auto response_encryption_scope_iterator - = httpResponse.GetHeaders().find("x-ms-encryption-scope"); - if (response_encryption_scope_iterator != httpResponse.GetHeaders().end()) - { - response.EncryptionScope = response_encryption_scope_iterator->second; - } - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct UploadPageBlobPagesFromUriOptions - { - Azure::Core::Nullable Timeout; - std::string SourceUri; - std::pair SourceRange; - std::pair Range; - Azure::Core::Nullable TransactionalContentMd5; - Azure::Core::Nullable TransactionalContentCrc64; - Azure::Core::Nullable LeaseId; - Azure::Core::Nullable IfSequenceNumberLessThanOrEqualTo; - Azure::Core::Nullable IfSequenceNumberLessThan; - Azure::Core::Nullable IfSequenceNumberEqualTo; - Azure::Core::Nullable EncryptionKey; - Azure::Core::Nullable EncryptionKeySha256; - Azure::Core::Nullable EncryptionAlgorithm; - Azure::Core::Nullable EncryptionScope; - Azure::Core::Nullable IfModifiedSince; - Azure::Core::Nullable IfUnmodifiedSince; - Azure::Core::Nullable IfMatch; - Azure::Core::Nullable IfNoneMatch; - Azure::Core::Nullable IfTags; - }; // struct UploadPageBlobPagesFromUriOptions - - static Azure::Core::Response UploadPagesFromUri( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const UploadPageBlobPagesFromUriOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); - request.AddHeader("Content-Length", "0"); - request.GetUrl().AppendQueryParameter("comp", "page"); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - request.AddHeader( - "x-ms-range", - "bytes=" + std::to_string(options.Range.first) + "-" - + std::to_string(options.Range.second)); - request.AddHeader("x-ms-copy-source", options.SourceUri); - request.AddHeader( - "x-ms-source-range", - "bytes=" + std::to_string(options.SourceRange.first) + "-" - + std::to_string(options.SourceRange.second)); - if (options.TransactionalContentMd5.HasValue()) - { - request.AddHeader("x-ms-source-content-md5", options.TransactionalContentMd5.GetValue()); - } - if (options.TransactionalContentCrc64.HasValue()) - { - request.AddHeader( - "x-ms-source-content-crc64", options.TransactionalContentCrc64.GetValue()); - } - request.AddHeader("x-ms-page-write", "update"); - if (options.LeaseId.HasValue()) - { - request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); - } - if (options.IfSequenceNumberLessThanOrEqualTo.HasValue()) - { - request.AddHeader( - "x-ms-if-sequence-number-le", - std::to_string(options.IfSequenceNumberLessThanOrEqualTo.GetValue())); - } - if (options.IfSequenceNumberLessThan.HasValue()) - { - request.AddHeader( - "x-ms-if-sequence-number-lt", - std::to_string(options.IfSequenceNumberLessThan.GetValue())); - } - if (options.IfSequenceNumberEqualTo.HasValue()) - { - request.AddHeader( - "x-ms-if-sequence-number-eq", - std::to_string(options.IfSequenceNumberEqualTo.GetValue())); - } - if (options.EncryptionKey.HasValue()) - { - request.AddHeader("x-ms-encryption-key", options.EncryptionKey.GetValue()); - } - if (options.EncryptionKeySha256.HasValue()) - { - request.AddHeader("x-ms-encryption-key-sha256", options.EncryptionKeySha256.GetValue()); - } - if (options.EncryptionAlgorithm.HasValue()) - { - request.AddHeader( - "x-ms-encryption-algorithm", - EncryptionAlgorithmTypeToString(options.EncryptionAlgorithm.GetValue())); - } - if (options.EncryptionScope.HasValue()) - { - request.AddHeader("x-ms-encryption-scope", options.EncryptionScope.GetValue()); - } - if (options.IfModifiedSince.HasValue()) - { - request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); - } - if (options.IfUnmodifiedSince.HasValue()) - { - request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); - } - if (options.IfMatch.HasValue()) - { - request.AddHeader("If-Match", options.IfMatch.GetValue()); - } - if (options.IfNoneMatch.HasValue()) - { - request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); - } - if (options.IfTags.HasValue()) - { - request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - UploadPageBlobPagesFromUriResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 201)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - response.ETag = httpResponse.GetHeaders().at("etag"); - response.LastModified = httpResponse.GetHeaders().at("last-modified"); - auto response_transactional_content_md5_iterator - = httpResponse.GetHeaders().find("content-md5"); - if (response_transactional_content_md5_iterator != httpResponse.GetHeaders().end()) - { - response.TransactionalContentMd5 = response_transactional_content_md5_iterator->second; - } - auto response_transactional_content_crc64_iterator - = httpResponse.GetHeaders().find("x-ms-content-crc64"); - if (response_transactional_content_crc64_iterator != httpResponse.GetHeaders().end()) - { - response.TransactionalContentCrc64 - = response_transactional_content_crc64_iterator->second; - } - response.SequenceNumber - = std::stoll(httpResponse.GetHeaders().at("x-ms-blob-sequence-number")); - auto response_server_encrypted_iterator - = httpResponse.GetHeaders().find("x-ms-request-server-encrypted"); - if (response_server_encrypted_iterator != httpResponse.GetHeaders().end()) - { - response.ServerEncrypted = response_server_encrypted_iterator->second == "true"; - } - auto response_encryption_key_sha256_iterator - = httpResponse.GetHeaders().find("x-ms-encryption-key-sha256"); - if (response_encryption_key_sha256_iterator != httpResponse.GetHeaders().end()) - { - response.EncryptionKeySha256 = response_encryption_key_sha256_iterator->second; - } - auto response_encryption_scope_iterator - = httpResponse.GetHeaders().find("x-ms-encryption-scope"); - if (response_encryption_scope_iterator != httpResponse.GetHeaders().end()) - { - response.EncryptionScope = response_encryption_scope_iterator->second; - } - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct ClearPageBlobPagesOptions - { - Azure::Core::Nullable Timeout; - std::pair Range; - Azure::Core::Nullable LeaseId; - Azure::Core::Nullable IfSequenceNumberLessThanOrEqualTo; - Azure::Core::Nullable IfSequenceNumberLessThan; - Azure::Core::Nullable IfSequenceNumberEqualTo; - Azure::Core::Nullable EncryptionKey; - Azure::Core::Nullable EncryptionKeySha256; - Azure::Core::Nullable EncryptionAlgorithm; - Azure::Core::Nullable EncryptionScope; - Azure::Core::Nullable IfModifiedSince; - Azure::Core::Nullable IfUnmodifiedSince; - Azure::Core::Nullable IfMatch; - Azure::Core::Nullable IfNoneMatch; - Azure::Core::Nullable IfTags; - }; // struct ClearPageBlobPagesOptions - - static Azure::Core::Response ClearPages( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const ClearPageBlobPagesOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); - request.AddHeader("Content-Length", "0"); - request.GetUrl().AppendQueryParameter("comp", "page"); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - request.AddHeader( - "x-ms-range", - "bytes=" + std::to_string(options.Range.first) + "-" - + std::to_string(options.Range.second)); - request.AddHeader("x-ms-page-write", "clear"); - if (options.LeaseId.HasValue()) - { - request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); - } - if (options.IfSequenceNumberLessThanOrEqualTo.HasValue()) - { - request.AddHeader( - "x-ms-if-sequence-number-le", - std::to_string(options.IfSequenceNumberLessThanOrEqualTo.GetValue())); - } - if (options.IfSequenceNumberLessThan.HasValue()) - { - request.AddHeader( - "x-ms-if-sequence-number-lt", - std::to_string(options.IfSequenceNumberLessThan.GetValue())); - } - if (options.IfSequenceNumberEqualTo.HasValue()) - { - request.AddHeader( - "x-ms-if-sequence-number-eq", - std::to_string(options.IfSequenceNumberEqualTo.GetValue())); - } - if (options.EncryptionKey.HasValue()) - { - request.AddHeader("x-ms-encryption-key", options.EncryptionKey.GetValue()); - } - if (options.EncryptionKeySha256.HasValue()) - { - request.AddHeader("x-ms-encryption-key-sha256", options.EncryptionKeySha256.GetValue()); - } - if (options.EncryptionAlgorithm.HasValue()) - { - request.AddHeader( - "x-ms-encryption-algorithm", - EncryptionAlgorithmTypeToString(options.EncryptionAlgorithm.GetValue())); - } - if (options.EncryptionScope.HasValue()) - { - request.AddHeader("x-ms-encryption-scope", options.EncryptionScope.GetValue()); - } - if (options.IfModifiedSince.HasValue()) - { - request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); - } - if (options.IfUnmodifiedSince.HasValue()) - { - request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); - } - if (options.IfMatch.HasValue()) - { - request.AddHeader("If-Match", options.IfMatch.GetValue()); - } - if (options.IfNoneMatch.HasValue()) - { - request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); - } - if (options.IfTags.HasValue()) - { - request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - ClearPageBlobPagesResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 201)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - response.ETag = httpResponse.GetHeaders().at("etag"); - response.LastModified = httpResponse.GetHeaders().at("last-modified"); - response.SequenceNumber - = std::stoll(httpResponse.GetHeaders().at("x-ms-blob-sequence-number")); - auto response_server_encrypted_iterator - = httpResponse.GetHeaders().find("x-ms-request-server-encrypted"); - if (response_server_encrypted_iterator != httpResponse.GetHeaders().end()) - { - response.ServerEncrypted = response_server_encrypted_iterator->second == "true"; - } - auto response_encryption_key_sha256_iterator - = httpResponse.GetHeaders().find("x-ms-encryption-key-sha256"); - if (response_encryption_key_sha256_iterator != httpResponse.GetHeaders().end()) - { - response.EncryptionKeySha256 = response_encryption_key_sha256_iterator->second; - } - auto response_encryption_scope_iterator - = httpResponse.GetHeaders().find("x-ms-encryption-scope"); - if (response_encryption_scope_iterator != httpResponse.GetHeaders().end()) - { - response.EncryptionScope = response_encryption_scope_iterator->second; - } - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct ResizePageBlobOptions - { - Azure::Core::Nullable Timeout; - int64_t BlobContentLength = -1; - Azure::Core::Nullable LeaseId; - Azure::Core::Nullable IfSequenceNumberLessThanOrEqualTo; - Azure::Core::Nullable IfSequenceNumberLessThan; - Azure::Core::Nullable IfSequenceNumberEqualTo; - Azure::Core::Nullable EncryptionKey; - Azure::Core::Nullable EncryptionKeySha256; - Azure::Core::Nullable EncryptionAlgorithm; - Azure::Core::Nullable EncryptionScope; - Azure::Core::Nullable IfModifiedSince; - Azure::Core::Nullable IfUnmodifiedSince; - Azure::Core::Nullable IfMatch; - Azure::Core::Nullable IfNoneMatch; - Azure::Core::Nullable IfTags; - }; // struct ResizePageBlobOptions - - static Azure::Core::Response Resize( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const ResizePageBlobOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); - request.AddHeader("Content-Length", "0"); - request.GetUrl().AppendQueryParameter("comp", "properties"); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - request.AddHeader("x-ms-blob-content-length", std::to_string(options.BlobContentLength)); - if (options.LeaseId.HasValue()) - { - request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); - } - if (options.IfSequenceNumberLessThanOrEqualTo.HasValue()) - { - request.AddHeader( - "x-ms-if-sequence-number-le", - std::to_string(options.IfSequenceNumberLessThanOrEqualTo.GetValue())); - } - if (options.IfSequenceNumberLessThan.HasValue()) - { - request.AddHeader( - "x-ms-if-sequence-number-lt", - std::to_string(options.IfSequenceNumberLessThan.GetValue())); - } - if (options.IfSequenceNumberEqualTo.HasValue()) - { - request.AddHeader( - "x-ms-if-sequence-number-eq", - std::to_string(options.IfSequenceNumberEqualTo.GetValue())); - } - if (options.EncryptionKey.HasValue()) - { - request.AddHeader("x-ms-encryption-key", options.EncryptionKey.GetValue()); - } - if (options.EncryptionKeySha256.HasValue()) - { - request.AddHeader("x-ms-encryption-key-sha256", options.EncryptionKeySha256.GetValue()); - } - if (options.EncryptionAlgorithm.HasValue()) - { - request.AddHeader( - "x-ms-encryption-algorithm", - EncryptionAlgorithmTypeToString(options.EncryptionAlgorithm.GetValue())); - } - if (options.EncryptionScope.HasValue()) - { - request.AddHeader("x-ms-encryption-scope", options.EncryptionScope.GetValue()); - } - if (options.IfModifiedSince.HasValue()) - { - request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); - } - if (options.IfUnmodifiedSince.HasValue()) - { - request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); - } - if (options.IfMatch.HasValue()) - { - request.AddHeader("If-Match", options.IfMatch.GetValue()); - } - if (options.IfNoneMatch.HasValue()) - { - request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); - } - if (options.IfTags.HasValue()) - { - request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - ResizePageBlobResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 200)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - response.ETag = httpResponse.GetHeaders().at("etag"); - response.LastModified = httpResponse.GetHeaders().at("last-modified"); - response.SequenceNumber - = std::stoll(httpResponse.GetHeaders().at("x-ms-blob-sequence-number")); - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct GetPageBlobPageRangesOptions - { - Azure::Core::Nullable Timeout; - Azure::Core::Nullable PreviousSnapshot; - Azure::Core::Nullable PreviousSnapshotUrl; - Azure::Core::Nullable> Range; - Azure::Core::Nullable LeaseId; - Azure::Core::Nullable IfModifiedSince; - Azure::Core::Nullable IfUnmodifiedSince; - Azure::Core::Nullable IfMatch; - Azure::Core::Nullable IfNoneMatch; - Azure::Core::Nullable IfTags; - }; // struct GetPageBlobPageRangesOptions - - static Azure::Core::Response GetPageRanges( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const GetPageBlobPageRangesOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url); - request.GetUrl().AppendQueryParameter("comp", "pagelist"); - if (options.PreviousSnapshot.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "prevsnapshot", - Details::UrlEncodeQueryParameter(options.PreviousSnapshot.GetValue())); - } - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - if (options.Range.HasValue()) - { - auto startOffset = options.Range.GetValue().first; - auto endOffset = options.Range.GetValue().second; - if (endOffset != std::numeric_limits::max()) + if (options.TransactionalContentCrc64.HasValue()) { request.AddHeader( - "x-ms-range", - "bytes=" + std::to_string(startOffset) + "-" + std::to_string(endOffset)); + "x-ms-source-content-crc64", options.TransactionalContentCrc64.GetValue()); } - else + if (options.LeaseId.HasValue()) { - request.AddHeader("x-ms-range", "bytes=" + std::to_string(startOffset) + "-"); + request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); } - } - if (options.LeaseId.HasValue()) - { - request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); - } - if (options.PreviousSnapshotUrl.HasValue()) - { - request.AddHeader("x-ms-previous-snapshot-url", options.PreviousSnapshotUrl.GetValue()); - } - if (options.IfModifiedSince.HasValue()) - { - request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); - } - if (options.IfUnmodifiedSince.HasValue()) - { - request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); - } - if (options.IfMatch.HasValue()) - { - request.AddHeader("If-Match", options.IfMatch.GetValue()); - } - if (options.IfNoneMatch.HasValue()) - { - request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); - } - if (options.IfTags.HasValue()) - { - request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - GetPageBlobPageRangesResultInternal response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 200)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - { - const auto& httpResponseBody = httpResponse.GetBody(); - XmlReader reader( - reinterpret_cast(httpResponseBody.data()), httpResponseBody.size()); - response = GetPageBlobPageRangesResultInternalFromXml(reader); - } - response.ETag = httpResponse.GetHeaders().at("etag"); - response.LastModified = httpResponse.GetHeaders().at("last-modified"); - response.BlobContentLength - = std::stoll(httpResponse.GetHeaders().at("x-ms-blob-content-length")); - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct StartCopyPageBlobIncrementalOptions - { - Azure::Core::Nullable Timeout; - std::string CopySource; - Azure::Core::Nullable IfModifiedSince; - Azure::Core::Nullable IfUnmodifiedSince; - Azure::Core::Nullable IfMatch; - Azure::Core::Nullable IfNoneMatch; - Azure::Core::Nullable IfTags; - }; // struct StartCopyPageBlobIncrementalOptions - - static Azure::Core::Response StartCopyIncremental( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const StartCopyPageBlobIncrementalOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); - request.AddHeader("Content-Length", "0"); - request.GetUrl().AppendQueryParameter("comp", "incrementalcopy"); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - request.AddHeader("x-ms-copy-source", options.CopySource); - if (options.IfModifiedSince.HasValue()) - { - request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); - } - if (options.IfUnmodifiedSince.HasValue()) - { - request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); - } - if (options.IfMatch.HasValue()) - { - request.AddHeader("If-Match", options.IfMatch.GetValue()); - } - if (options.IfNoneMatch.HasValue()) - { - request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); - } - if (options.IfTags.HasValue()) - { - request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - StartCopyPageBlobIncrementalResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 202)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - response.ETag = httpResponse.GetHeaders().at("etag"); - response.LastModified = httpResponse.GetHeaders().at("last-modified"); - response.CopyId = httpResponse.GetHeaders().at("x-ms-copy-id"); - response.CopyStatus - = CopyStatusFromString(httpResponse.GetHeaders().at("x-ms-copy-status")); - auto response_version_id_iterator = httpResponse.GetHeaders().find("x-ms-version-id"); - if (response_version_id_iterator != httpResponse.GetHeaders().end()) - { - response.VersionId = response_version_id_iterator->second; - } - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - private: - static GetPageBlobPageRangesResultInternal GetPageBlobPageRangesResultInternalFromXml( - XmlReader& reader) - { - GetPageBlobPageRangesResultInternal ret; - enum class XmlTagName - { - k_PageList, - k_PageRange, - k_ClearRange, - k_Unknown, - }; - std::vector path; - while (true) - { - auto node = reader.Read(); - if (node.Type == XmlNodeType::End) - { - break; - } - else if (node.Type == XmlNodeType::EndTag) - { - if (path.size() > 0) - { - path.pop_back(); - } - else - { - break; - } - } - else if (node.Type == XmlNodeType::StartTag) - { - if (std::strcmp(node.Name, "PageList") == 0) - { - path.emplace_back(XmlTagName::k_PageList); - } - else if (std::strcmp(node.Name, "PageRange") == 0) - { - path.emplace_back(XmlTagName::k_PageRange); - } - else if (std::strcmp(node.Name, "ClearRange") == 0) - { - path.emplace_back(XmlTagName::k_ClearRange); - } - else - { - path.emplace_back(XmlTagName::k_Unknown); - } - if (path.size() == 2 && path[0] == XmlTagName::k_PageList - && path[1] == XmlTagName::k_PageRange) - { - ret.PageRanges.emplace_back(PageRangesFromXml(reader)); - path.pop_back(); - } - else if ( - path.size() == 2 && path[0] == XmlTagName::k_PageList - && path[1] == XmlTagName::k_ClearRange) - { - ret.ClearRanges.emplace_back(ClearRangesFromXml(reader)); - path.pop_back(); - } - } - else if (node.Type == XmlNodeType::Text) - { - } - } - return ret; - } - - static std::pair ClearRangesFromXml(XmlReader& reader) - { - int depth = 0; - bool is_start = false; - bool is_end = false; - int64_t start = 0; - int64_t end = 0; - while (true) - { - auto node = reader.Read(); - if (node.Type == XmlNodeType::End) - { - break; - } - else if (node.Type == XmlNodeType::StartTag && strcmp(node.Name, "Start") == 0) - { - ++depth; - is_start = true; - } - else if (node.Type == XmlNodeType::StartTag && strcmp(node.Name, "End") == 0) - { - ++depth; - is_end = true; - } - else if (node.Type == XmlNodeType::EndTag) - { - is_start = false; - is_end = false; - if (depth-- == 0) - { - break; - } - } - if (depth == 1 && node.Type == XmlNodeType::Text) - { - if (is_start) - { - start = std::stoll(node.Value); - } - else if (is_end) - { - end = std::stoll(node.Value); - } - } - } - return std::make_pair(start, end); - } - - static std::pair PageRangesFromXml(XmlReader& reader) - { - int depth = 0; - bool is_start = false; - bool is_end = false; - int64_t start = 0; - int64_t end = 0; - while (true) - { - auto node = reader.Read(); - if (node.Type == XmlNodeType::End) - { - break; - } - else if (node.Type == XmlNodeType::StartTag && strcmp(node.Name, "Start") == 0) - { - ++depth; - is_start = true; - } - else if (node.Type == XmlNodeType::StartTag && strcmp(node.Name, "End") == 0) - { - ++depth; - is_end = true; - } - else if (node.Type == XmlNodeType::EndTag) - { - is_start = false; - is_end = false; - if (depth-- == 0) - { - break; - } - } - if (depth == 1 && node.Type == XmlNodeType::Text) - { - if (is_start) - { - start = std::stoll(node.Value); - } - else if (is_end) - { - end = std::stoll(node.Value); - } - } - } - return std::make_pair(start, end); - } - - }; // class PageBlob - - class AppendBlob { - public: - struct CreateAppendBlobOptions - { - Azure::Core::Nullable Timeout; - BlobHttpHeaders HttpHeaders; - std::map Metadata; - Azure::Core::Nullable LeaseId; - Azure::Core::Nullable EncryptionKey; - Azure::Core::Nullable EncryptionKeySha256; - Azure::Core::Nullable EncryptionAlgorithm; - Azure::Core::Nullable EncryptionScope; - Azure::Core::Nullable IfModifiedSince; - Azure::Core::Nullable IfUnmodifiedSince; - Azure::Core::Nullable IfMatch; - Azure::Core::Nullable IfNoneMatch; - Azure::Core::Nullable IfTags; - }; // struct CreateAppendBlobOptions - - static Azure::Core::Response Create( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const CreateAppendBlobOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); - request.AddHeader("Content-Length", "0"); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - if (!options.HttpHeaders.ContentType.empty()) - { - request.AddHeader("x-ms-blob-content-type", options.HttpHeaders.ContentType); - } - if (!options.HttpHeaders.ContentEncoding.empty()) - { - request.AddHeader("x-ms-blob-content-encoding", options.HttpHeaders.ContentEncoding); - } - if (!options.HttpHeaders.ContentLanguage.empty()) - { - request.AddHeader("x-ms-blob-content-language", options.HttpHeaders.ContentLanguage); - } - if (!options.HttpHeaders.CacheControl.empty()) - { - request.AddHeader("x-ms-blob-cache-control", options.HttpHeaders.CacheControl); - } - if (!options.HttpHeaders.ContentMd5.empty()) - { - request.AddHeader("x-ms-blob-content-md5", options.HttpHeaders.ContentMd5); - } - if (!options.HttpHeaders.ContentDisposition.empty()) - { - request.AddHeader( - "x-ms-blob-content-disposition", options.HttpHeaders.ContentDisposition); - } - std::set metadataKeys; - for (const auto& pair : options.Metadata) - { - if (metadataKeys.insert(Azure::Core::Strings::ToLower(pair.first)).second == false) - { - throw std::runtime_error("duplicate keys in metadata"); - } - request.AddHeader("x-ms-meta-" + pair.first, pair.second); - } - metadataKeys.clear(); - if (options.LeaseId.HasValue()) - { - request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); - } - request.AddHeader("x-ms-blob-type", "AppendBlob"); - if (options.EncryptionKey.HasValue()) - { - request.AddHeader("x-ms-encryption-key", options.EncryptionKey.GetValue()); - } - if (options.EncryptionKeySha256.HasValue()) - { - request.AddHeader("x-ms-encryption-key-sha256", options.EncryptionKeySha256.GetValue()); - } - if (options.EncryptionAlgorithm.HasValue()) - { - request.AddHeader( - "x-ms-encryption-algorithm", - EncryptionAlgorithmTypeToString(options.EncryptionAlgorithm.GetValue())); - } - if (options.EncryptionScope.HasValue()) - { - request.AddHeader("x-ms-encryption-scope", options.EncryptionScope.GetValue()); - } - if (options.IfModifiedSince.HasValue()) - { - request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); - } - if (options.IfUnmodifiedSince.HasValue()) - { - request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); - } - if (options.IfMatch.HasValue()) - { - request.AddHeader("If-Match", options.IfMatch.GetValue()); - } - if (options.IfNoneMatch.HasValue()) - { - request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); - } - if (options.IfTags.HasValue()) - { - request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - CreateAppendBlobResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 201)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - response.ETag = httpResponse.GetHeaders().at("etag"); - response.LastModified = httpResponse.GetHeaders().at("last-modified"); - auto response_version_id_iterator = httpResponse.GetHeaders().find("x-ms-version-id"); - if (response_version_id_iterator != httpResponse.GetHeaders().end()) - { - response.VersionId = response_version_id_iterator->second; - } - auto response_server_encrypted_iterator - = httpResponse.GetHeaders().find("x-ms-request-server-encrypted"); - if (response_server_encrypted_iterator != httpResponse.GetHeaders().end()) - { - response.ServerEncrypted = response_server_encrypted_iterator->second == "true"; - } - auto response_encryption_key_sha256_iterator - = httpResponse.GetHeaders().find("x-ms-encryption-key-sha256"); - if (response_encryption_key_sha256_iterator != httpResponse.GetHeaders().end()) - { - response.EncryptionKeySha256 = response_encryption_key_sha256_iterator->second; - } - auto response_encryption_scope_iterator - = httpResponse.GetHeaders().find("x-ms-encryption-scope"); - if (response_encryption_scope_iterator != httpResponse.GetHeaders().end()) - { - response.EncryptionScope = response_encryption_scope_iterator->second; - } - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct AppendBlockOptions - { - Azure::Core::Nullable Timeout; - Azure::Core::Nullable TransactionalContentMd5; - Azure::Core::Nullable TransactionalContentCrc64; - Azure::Core::Nullable LeaseId; - Azure::Core::Nullable MaxSize; - Azure::Core::Nullable AppendPosition; - Azure::Core::Nullable EncryptionKey; - Azure::Core::Nullable EncryptionKeySha256; - Azure::Core::Nullable EncryptionAlgorithm; - Azure::Core::Nullable EncryptionScope; - Azure::Core::Nullable IfModifiedSince; - Azure::Core::Nullable IfUnmodifiedSince; - Azure::Core::Nullable IfMatch; - Azure::Core::Nullable IfNoneMatch; - Azure::Core::Nullable IfTags; - }; // struct AppendBlockOptions - - static Azure::Core::Response AppendBlock( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - Azure::Core::Http::BodyStream* requestBody, - const AppendBlockOptions& options) - { - unused(options); - auto request - = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url, requestBody); - request.AddHeader("Content-Length", std::to_string(requestBody->Length())); - request.GetUrl().AppendQueryParameter("comp", "appendblock"); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - if (options.TransactionalContentMd5.HasValue()) - { - request.AddHeader("Content-MD5", options.TransactionalContentMd5.GetValue()); - } - if (options.TransactionalContentCrc64.HasValue()) - { - request.AddHeader("x-ms-content-crc64", options.TransactionalContentCrc64.GetValue()); - } - if (options.LeaseId.HasValue()) - { - request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); - } - if (options.MaxSize.HasValue()) - { - request.AddHeader( - "x-ms-blob-condition-maxsize", std::to_string(options.MaxSize.GetValue())); - } - if (options.AppendPosition.HasValue()) - { - request.AddHeader( - "x-ms-blob-condition-appendpos", std::to_string(options.AppendPosition.GetValue())); - } - if (options.EncryptionKey.HasValue()) - { - request.AddHeader("x-ms-encryption-key", options.EncryptionKey.GetValue()); - } - if (options.EncryptionKeySha256.HasValue()) - { - request.AddHeader("x-ms-encryption-key-sha256", options.EncryptionKeySha256.GetValue()); - } - if (options.EncryptionAlgorithm.HasValue()) - { - request.AddHeader( - "x-ms-encryption-algorithm", - EncryptionAlgorithmTypeToString(options.EncryptionAlgorithm.GetValue())); - } - if (options.EncryptionScope.HasValue()) - { - request.AddHeader("x-ms-encryption-scope", options.EncryptionScope.GetValue()); - } - if (options.IfModifiedSince.HasValue()) - { - request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); - } - if (options.IfUnmodifiedSince.HasValue()) - { - request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); - } - if (options.IfMatch.HasValue()) - { - request.AddHeader("If-Match", options.IfMatch.GetValue()); - } - if (options.IfNoneMatch.HasValue()) - { - request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); - } - if (options.IfTags.HasValue()) - { - request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - AppendBlockResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 201)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - response.ETag = httpResponse.GetHeaders().at("etag"); - response.LastModified = httpResponse.GetHeaders().at("last-modified"); - auto response_transactional_content_md5_iterator - = httpResponse.GetHeaders().find("content-md5"); - if (response_transactional_content_md5_iterator != httpResponse.GetHeaders().end()) - { - response.TransactionalContentMd5 = response_transactional_content_md5_iterator->second; - } - auto response_transactional_content_crc64_iterator - = httpResponse.GetHeaders().find("x-ms-content-crc64"); - if (response_transactional_content_crc64_iterator != httpResponse.GetHeaders().end()) - { - response.TransactionalContentCrc64 - = response_transactional_content_crc64_iterator->second; - } - response.AppendOffset = std::stoll(httpResponse.GetHeaders().at("x-ms-blob-append-offset")); - response.CommittedBlockCount - = std::stoll(httpResponse.GetHeaders().at("x-ms-blob-committed-block-count")); - auto response_server_encrypted_iterator - = httpResponse.GetHeaders().find("x-ms-request-server-encrypted"); - if (response_server_encrypted_iterator != httpResponse.GetHeaders().end()) - { - response.ServerEncrypted = response_server_encrypted_iterator->second == "true"; - } - auto response_encryption_key_sha256_iterator - = httpResponse.GetHeaders().find("x-ms-encryption-key-sha256"); - if (response_encryption_key_sha256_iterator != httpResponse.GetHeaders().end()) - { - response.EncryptionKeySha256 = response_encryption_key_sha256_iterator->second; - } - auto response_encryption_scope_iterator - = httpResponse.GetHeaders().find("x-ms-encryption-scope"); - if (response_encryption_scope_iterator != httpResponse.GetHeaders().end()) - { - response.EncryptionScope = response_encryption_scope_iterator->second; - } - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - - struct AppendBlockFromUriOptions - { - Azure::Core::Nullable Timeout; - std::string SourceUri; - Azure::Core::Nullable> SourceRange; - Azure::Core::Nullable TransactionalContentMd5; - Azure::Core::Nullable TransactionalContentCrc64; - Azure::Core::Nullable LeaseId; - Azure::Core::Nullable MaxSize; - Azure::Core::Nullable AppendPosition; - Azure::Core::Nullable EncryptionKey; - Azure::Core::Nullable EncryptionKeySha256; - Azure::Core::Nullable EncryptionAlgorithm; - Azure::Core::Nullable EncryptionScope; - Azure::Core::Nullable IfModifiedSince; - Azure::Core::Nullable IfUnmodifiedSince; - Azure::Core::Nullable IfMatch; - Azure::Core::Nullable IfNoneMatch; - Azure::Core::Nullable IfTags; - }; // struct AppendBlockFromUriOptions - - static Azure::Core::Response AppendBlockFromUri( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const AppendBlockFromUriOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); - request.AddHeader("Content-Length", "0"); - request.GetUrl().AppendQueryParameter("comp", "appendblock"); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) - { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - request.AddHeader("x-ms-copy-source", options.SourceUri); - if (options.SourceRange.HasValue()) - { - auto startOffset = options.SourceRange.GetValue().first; - auto endOffset = options.SourceRange.GetValue().second; - if (endOffset != std::numeric_limits::max()) + if (options.MaxSize.HasValue()) { request.AddHeader( - "x-ms-source-range", - "bytes=" + std::to_string(startOffset) + "-" + std::to_string(endOffset)); + "x-ms-blob-condition-maxsize", std::to_string(options.MaxSize.GetValue())); } - else + if (options.AppendPosition.HasValue()) { - request.AddHeader("x-ms-source-range", "bytes=" + std::to_string(startOffset) + "-"); + request.AddHeader( + "x-ms-blob-condition-appendpos", std::to_string(options.AppendPosition.GetValue())); } + if (options.EncryptionKey.HasValue()) + { + request.AddHeader("x-ms-encryption-key", options.EncryptionKey.GetValue()); + } + if (options.EncryptionKeySha256.HasValue()) + { + request.AddHeader("x-ms-encryption-key-sha256", options.EncryptionKeySha256.GetValue()); + } + if (options.EncryptionAlgorithm.HasValue()) + { + request.AddHeader( + "x-ms-encryption-algorithm", + EncryptionAlgorithmTypeToString(options.EncryptionAlgorithm.GetValue())); + } + if (options.EncryptionScope.HasValue()) + { + request.AddHeader("x-ms-encryption-scope", options.EncryptionScope.GetValue()); + } + if (options.IfModifiedSince.HasValue()) + { + request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); + } + if (options.IfUnmodifiedSince.HasValue()) + { + request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); + } + if (options.IfMatch.HasValue()) + { + request.AddHeader("If-Match", options.IfMatch.GetValue()); + } + if (options.IfNoneMatch.HasValue()) + { + request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); + } + if (options.IfTags.HasValue()) + { + request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + AppendBlockFromUriResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 201)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + response.ETag = httpResponse.GetHeaders().at("etag"); + response.LastModified = httpResponse.GetHeaders().at("last-modified"); + auto response_transactional_content_md5_iterator + = httpResponse.GetHeaders().find("content-md5"); + if (response_transactional_content_md5_iterator != httpResponse.GetHeaders().end()) + { + response.TransactionalContentMd5 = response_transactional_content_md5_iterator->second; + } + auto response_transactional_content_crc64_iterator + = httpResponse.GetHeaders().find("x-ms-content-crc64"); + if (response_transactional_content_crc64_iterator != httpResponse.GetHeaders().end()) + { + response.TransactionalContentCrc64 + = response_transactional_content_crc64_iterator->second; + } + response.AppendOffset + = std::stoll(httpResponse.GetHeaders().at("x-ms-blob-append-offset")); + response.CommittedBlockCount + = std::stoll(httpResponse.GetHeaders().at("x-ms-blob-committed-block-count")); + auto response_server_encrypted_iterator + = httpResponse.GetHeaders().find("x-ms-request-server-encrypted"); + if (response_server_encrypted_iterator != httpResponse.GetHeaders().end()) + { + response.ServerEncrypted = response_server_encrypted_iterator->second == "true"; + } + auto response_encryption_key_sha256_iterator + = httpResponse.GetHeaders().find("x-ms-encryption-key-sha256"); + if (response_encryption_key_sha256_iterator != httpResponse.GetHeaders().end()) + { + response.EncryptionKeySha256 = response_encryption_key_sha256_iterator->second; + } + auto response_encryption_scope_iterator + = httpResponse.GetHeaders().find("x-ms-encryption-scope"); + if (response_encryption_scope_iterator != httpResponse.GetHeaders().end()) + { + response.EncryptionScope = response_encryption_scope_iterator->second; + } + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); } - if (options.TransactionalContentMd5.HasValue()) - { - request.AddHeader("x-ms-source-content-md5", options.TransactionalContentMd5.GetValue()); - } - if (options.TransactionalContentCrc64.HasValue()) - { - request.AddHeader( - "x-ms-source-content-crc64", options.TransactionalContentCrc64.GetValue()); - } - if (options.LeaseId.HasValue()) - { - request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); - } - if (options.MaxSize.HasValue()) - { - request.AddHeader( - "x-ms-blob-condition-maxsize", std::to_string(options.MaxSize.GetValue())); - } - if (options.AppendPosition.HasValue()) - { - request.AddHeader( - "x-ms-blob-condition-appendpos", std::to_string(options.AppendPosition.GetValue())); - } - if (options.EncryptionKey.HasValue()) - { - request.AddHeader("x-ms-encryption-key", options.EncryptionKey.GetValue()); - } - if (options.EncryptionKeySha256.HasValue()) - { - request.AddHeader("x-ms-encryption-key-sha256", options.EncryptionKeySha256.GetValue()); - } - if (options.EncryptionAlgorithm.HasValue()) - { - request.AddHeader( - "x-ms-encryption-algorithm", - EncryptionAlgorithmTypeToString(options.EncryptionAlgorithm.GetValue())); - } - if (options.EncryptionScope.HasValue()) - { - request.AddHeader("x-ms-encryption-scope", options.EncryptionScope.GetValue()); - } - if (options.IfModifiedSince.HasValue()) - { - request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); - } - if (options.IfUnmodifiedSince.HasValue()) - { - request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); - } - if (options.IfMatch.HasValue()) - { - request.AddHeader("If-Match", options.IfMatch.GetValue()); - } - if (options.IfNoneMatch.HasValue()) - { - request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); - } - if (options.IfTags.HasValue()) - { - request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - AppendBlockFromUriResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 201)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - response.ETag = httpResponse.GetHeaders().at("etag"); - response.LastModified = httpResponse.GetHeaders().at("last-modified"); - auto response_transactional_content_md5_iterator - = httpResponse.GetHeaders().find("content-md5"); - if (response_transactional_content_md5_iterator != httpResponse.GetHeaders().end()) - { - response.TransactionalContentMd5 = response_transactional_content_md5_iterator->second; - } - auto response_transactional_content_crc64_iterator - = httpResponse.GetHeaders().find("x-ms-content-crc64"); - if (response_transactional_content_crc64_iterator != httpResponse.GetHeaders().end()) - { - response.TransactionalContentCrc64 - = response_transactional_content_crc64_iterator->second; - } - response.AppendOffset = std::stoll(httpResponse.GetHeaders().at("x-ms-blob-append-offset")); - response.CommittedBlockCount - = std::stoll(httpResponse.GetHeaders().at("x-ms-blob-committed-block-count")); - auto response_server_encrypted_iterator - = httpResponse.GetHeaders().find("x-ms-request-server-encrypted"); - if (response_server_encrypted_iterator != httpResponse.GetHeaders().end()) - { - response.ServerEncrypted = response_server_encrypted_iterator->second == "true"; - } - auto response_encryption_key_sha256_iterator - = httpResponse.GetHeaders().find("x-ms-encryption-key-sha256"); - if (response_encryption_key_sha256_iterator != httpResponse.GetHeaders().end()) - { - response.EncryptionKeySha256 = response_encryption_key_sha256_iterator->second; - } - auto response_encryption_scope_iterator - = httpResponse.GetHeaders().find("x-ms-encryption-scope"); - if (response_encryption_scope_iterator != httpResponse.GetHeaders().end()) - { - response.EncryptionScope = response_encryption_scope_iterator->second; - } - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - struct SealAppendBlobOptions - { - Azure::Core::Nullable Timeout; - Azure::Core::Nullable LeaseId; - Azure::Core::Nullable IfModifiedSince; - Azure::Core::Nullable IfUnmodifiedSince; - Azure::Core::Nullable IfMatch; - Azure::Core::Nullable IfNoneMatch; - Azure::Core::Nullable IfTags; - Azure::Core::Nullable AppendPosition; - }; // struct SealAppendBlobOptions + struct SealAppendBlobOptions + { + Azure::Core::Nullable Timeout; + Azure::Core::Nullable LeaseId; + Azure::Core::Nullable IfModifiedSince; + Azure::Core::Nullable IfUnmodifiedSince; + Azure::Core::Nullable IfMatch; + Azure::Core::Nullable IfNoneMatch; + Azure::Core::Nullable IfTags; + Azure::Core::Nullable AppendPosition; + }; // struct SealAppendBlobOptions - static Azure::Core::Response Seal( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - const SealAppendBlobOptions& options) - { - unused(options); - auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); - request.AddHeader("Content-Length", "0"); - request.GetUrl().AppendQueryParameter("comp", "seal"); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) + static Azure::Core::Response Seal( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + const SealAppendBlobOptions& options) { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); + unused(options); + auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url); + request.AddHeader("Content-Length", "0"); + request.GetUrl().AppendQueryParameter("comp", "seal"); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + if (options.LeaseId.HasValue()) + { + request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); + } + if (options.IfModifiedSince.HasValue()) + { + request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); + } + if (options.IfUnmodifiedSince.HasValue()) + { + request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); + } + if (options.IfMatch.HasValue()) + { + request.AddHeader("If-Match", options.IfMatch.GetValue()); + } + if (options.IfNoneMatch.HasValue()) + { + request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); + } + if (options.IfTags.HasValue()) + { + request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); + } + if (options.AppendPosition.HasValue()) + { + request.AddHeader( + "x-ms-blob-condition-appendpos", std::to_string(options.AppendPosition.GetValue())); + } + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + SealAppendBlobResult response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 200)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + response.ETag = httpResponse.GetHeaders().at("etag"); + response.LastModified = httpResponse.GetHeaders().at("last-modified"); + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); } - if (options.LeaseId.HasValue()) - { - request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue()); - } - if (options.IfModifiedSince.HasValue()) - { - request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue()); - } - if (options.IfUnmodifiedSince.HasValue()) - { - request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue()); - } - if (options.IfMatch.HasValue()) - { - request.AddHeader("If-Match", options.IfMatch.GetValue()); - } - if (options.IfNoneMatch.HasValue()) - { - request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue()); - } - if (options.IfTags.HasValue()) - { - request.AddHeader("x-ms-if-tags", options.IfTags.GetValue()); - } - if (options.AppendPosition.HasValue()) - { - request.AddHeader( - "x-ms-blob-condition-appendpos", std::to_string(options.AppendPosition.GetValue())); - } - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - SealAppendBlobResult response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 200)) - { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); - } - response.ETag = httpResponse.GetHeaders().at("etag"); - response.LastModified = httpResponse.GetHeaders().at("last-modified"); - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - private: - }; // class AppendBlob + private: + }; // class AppendBlob - class BlobBatch { - public: - struct SubmitBlobBatchOptions - { - Azure::Core::Nullable Timeout; - std::string ContentType; - }; // struct SubmitBlobBatchOptions - - static Azure::Core::Response SubmitBatch( - const Azure::Core::Context& context, - Azure::Core::Http::HttpPipeline& pipeline, - const Azure::Core::Http::Url& url, - Azure::Core::Http::BodyStream* requestBody, - const SubmitBlobBatchOptions& options) - { - unused(options); - auto request - = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Post, url, requestBody); - request.AddHeader("Content-Length", std::to_string(requestBody->Length())); - request.GetUrl().AppendQueryParameter("comp", "batch"); - request.AddHeader("x-ms-version", c_ApiVersion); - if (options.Timeout.HasValue()) + class BlobBatch { + public: + struct SubmitBlobBatchOptions { - request.GetUrl().AppendQueryParameter( - "timeout", std::to_string(options.Timeout.GetValue())); - } - request.AddHeader("Content-Type", options.ContentType); - auto pHttpResponse = pipeline.Send(context, request); - Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; - SubmitBlobBatchResultInternal response; - auto http_status_code - = static_cast::type>( - httpResponse.GetStatusCode()); - if (!(http_status_code == 202)) + Azure::Core::Nullable Timeout; + std::string ContentType; + }; // struct SubmitBlobBatchOptions + + static Azure::Core::Response SubmitBatch( + const Azure::Core::Context& context, + Azure::Core::Http::HttpPipeline& pipeline, + const Azure::Core::Http::Url& url, + Azure::Core::Http::BodyStream* requestBody, + const SubmitBlobBatchOptions& options) { - throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + unused(options); + auto request + = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Post, url, requestBody); + request.AddHeader("Content-Length", std::to_string(requestBody->Length())); + request.GetUrl().AppendQueryParameter("comp", "batch"); + request.AddHeader("x-ms-version", c_ApiVersion); + if (options.Timeout.HasValue()) + { + request.GetUrl().AppendQueryParameter( + "timeout", std::to_string(options.Timeout.GetValue())); + } + request.AddHeader("Content-Type", options.ContentType); + auto pHttpResponse = pipeline.Send(context, request); + Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse; + SubmitBlobBatchResultInternal response; + auto http_status_code + = static_cast::type>( + httpResponse.GetStatusCode()); + if (!(http_status_code == 202)) + { + throw StorageError::CreateFromResponse(std::move(pHttpResponse)); + } + response.ContentType = httpResponse.GetHeaders().at("content-type"); + return Azure::Core::Response( + std::move(response), std::move(pHttpResponse)); } - response.ContentType = httpResponse.GetHeaders().at("content-type"); - return Azure::Core::Response( - std::move(response), std::move(pHttpResponse)); - } - private: - }; // class BlobBatch + private: + }; // class BlobBatch - }; // class BlobRestClient + }; // class BlobRestClient + } // namespace Details }}} // namespace Azure::Storage::Blobs diff --git a/sdk/storage/azure-storage-blobs/src/append_blob_client.cpp b/sdk/storage/azure-storage-blobs/src/append_blob_client.cpp index f1fb20ca7..118ad5935 100644 --- a/sdk/storage/azure-storage-blobs/src/append_blob_client.cpp +++ b/sdk/storage/azure-storage-blobs/src/append_blob_client.cpp @@ -49,12 +49,13 @@ namespace Azure { namespace Storage { namespace Blobs { AppendBlobClient newClient(*this); if (snapshot.empty()) { - newClient.m_blobUrl.RemoveQueryParameter(Details::c_HttpQuerySnapshot); + newClient.m_blobUrl.RemoveQueryParameter(Storage::Details::c_HttpQuerySnapshot); } else { newClient.m_blobUrl.AppendQueryParameter( - Details::c_HttpQuerySnapshot, Details::UrlEncodeQueryParameter(snapshot)); + Storage::Details::c_HttpQuerySnapshot, + Storage::Details::UrlEncodeQueryParameter(snapshot)); } return newClient; } @@ -64,12 +65,13 @@ namespace Azure { namespace Storage { namespace Blobs { AppendBlobClient newClient(*this); if (versionId.empty()) { - newClient.m_blobUrl.RemoveQueryParameter(Details::c_HttpQueryVersionId); + newClient.m_blobUrl.RemoveQueryParameter(Storage::Details::c_HttpQueryVersionId); } else { newClient.m_blobUrl.AppendQueryParameter( - Details::c_HttpQueryVersionId, Details::UrlEncodeQueryParameter(versionId)); + Storage::Details::c_HttpQueryVersionId, + Storage::Details::UrlEncodeQueryParameter(versionId)); } return newClient; } @@ -77,7 +79,7 @@ namespace Azure { namespace Storage { namespace Blobs { Azure::Core::Response AppendBlobClient::Create( const CreateAppendBlobOptions& options) const { - BlobRestClient::AppendBlob::CreateAppendBlobOptions protocolLayerOptions; + Details::BlobRestClient::AppendBlob::CreateAppendBlobOptions protocolLayerOptions; protocolLayerOptions.HttpHeaders = options.HttpHeaders; protocolLayerOptions.Metadata = options.Metadata; protocolLayerOptions.LeaseId = options.AccessConditions.LeaseId; @@ -93,7 +95,7 @@ namespace Azure { namespace Storage { namespace Blobs { protocolLayerOptions.EncryptionAlgorithm = m_customerProvidedKey.GetValue().Algorithm; } protocolLayerOptions.EncryptionScope = m_encryptionScope; - return BlobRestClient::AppendBlob::Create( + return Details::BlobRestClient::AppendBlob::Create( options.Context, *m_pipeline, m_blobUrl, protocolLayerOptions); } @@ -101,7 +103,7 @@ namespace Azure { namespace Storage { namespace Blobs { Azure::Core::Http::BodyStream* content, const AppendBlockOptions& options) const { - BlobRestClient::AppendBlob::AppendBlockOptions protocolLayerOptions; + Details::BlobRestClient::AppendBlob::AppendBlockOptions protocolLayerOptions; protocolLayerOptions.TransactionalContentMd5 = options.TransactionalContentMd5; protocolLayerOptions.TransactionalContentCrc64 = options.TransactionalContentCrc64; protocolLayerOptions.LeaseId = options.AccessConditions.LeaseId; @@ -119,7 +121,7 @@ namespace Azure { namespace Storage { namespace Blobs { protocolLayerOptions.EncryptionAlgorithm = m_customerProvidedKey.GetValue().Algorithm; } protocolLayerOptions.EncryptionScope = m_encryptionScope; - return BlobRestClient::AppendBlob::AppendBlock( + return Details::BlobRestClient::AppendBlob::AppendBlock( options.Context, *m_pipeline, m_blobUrl, content, protocolLayerOptions); } @@ -127,7 +129,7 @@ namespace Azure { namespace Storage { namespace Blobs { const std::string& sourceUri, const AppendBlockFromUriOptions& options) const { - BlobRestClient::AppendBlob::AppendBlockFromUriOptions protocolLayerOptions; + Details::BlobRestClient::AppendBlob::AppendBlockFromUriOptions protocolLayerOptions; protocolLayerOptions.SourceUri = sourceUri; if (options.SourceOffset.HasValue() && options.SourceLength.HasValue()) { @@ -159,14 +161,14 @@ namespace Azure { namespace Storage { namespace Blobs { protocolLayerOptions.EncryptionAlgorithm = m_customerProvidedKey.GetValue().Algorithm; } protocolLayerOptions.EncryptionScope = m_encryptionScope; - return BlobRestClient::AppendBlob::AppendBlockFromUri( + return Details::BlobRestClient::AppendBlob::AppendBlockFromUri( options.Context, *m_pipeline, m_blobUrl, protocolLayerOptions); } Azure::Core::Response AppendBlobClient::Seal( const SealAppendBlobOptions& options) const { - BlobRestClient::AppendBlob::SealAppendBlobOptions protocolLayerOptions; + Details::BlobRestClient::AppendBlob::SealAppendBlobOptions protocolLayerOptions; protocolLayerOptions.LeaseId = options.AccessConditions.LeaseId; protocolLayerOptions.AppendPosition = options.AccessConditions.AppendPosition; protocolLayerOptions.IfModifiedSince = options.AccessConditions.IfModifiedSince; @@ -174,7 +176,7 @@ namespace Azure { namespace Storage { namespace Blobs { protocolLayerOptions.IfMatch = options.AccessConditions.IfMatch; protocolLayerOptions.IfNoneMatch = options.AccessConditions.IfNoneMatch; protocolLayerOptions.IfTags = options.AccessConditions.TagConditions; - return BlobRestClient::AppendBlob::Seal( + return Details::BlobRestClient::AppendBlob::Seal( options.Context, *m_pipeline, m_blobUrl, protocolLayerOptions); } diff --git a/sdk/storage/azure-storage-blobs/src/blob_batch_client.cpp b/sdk/storage/azure-storage-blobs/src/blob_batch_client.cpp index 1a455c11b..c327bf537 100644 --- a/sdk/storage/azure-storage-blobs/src/blob_batch_client.cpp +++ b/sdk/storage/azure-storage-blobs/src/blob_batch_client.cpp @@ -69,7 +69,7 @@ namespace Azure { namespace Storage { namespace Blobs { const std::string& connectionString, const BlobBatchClientOptions& options) { - auto parsedConnectionString = Details::ParseConnectionString(connectionString); + auto parsedConnectionString = Storage::Details::ParseConnectionString(connectionString); auto serviceUri = std::move(parsedConnectionString.BlobServiceUri); if (parsedConnectionString.KeyCredential) @@ -91,7 +91,7 @@ namespace Azure { namespace Storage { namespace Blobs { { std::vector> policies; policies.emplace_back(std::make_unique( - Details::c_BlobServicePackageName, Version::VersionString())); + Storage::Details::c_BlobServicePackageName, Version::VersionString())); policies.emplace_back(std::make_unique()); for (const auto& p : options.PerOperationPolicies) { @@ -131,7 +131,7 @@ namespace Azure { namespace Storage { namespace Blobs { { std::vector> policies; policies.emplace_back(std::make_unique( - Details::c_BlobServicePackageName, Version::VersionString())); + Storage::Details::c_BlobServicePackageName, Version::VersionString())); policies.emplace_back(std::make_unique()); for (const auto& p : options.PerOperationPolicies) { @@ -145,7 +145,7 @@ namespace Azure { namespace Storage { namespace Blobs { } policies.emplace_back(std::make_unique()); policies.emplace_back(std::make_unique( - credential, Details::c_StorageScope)); + credential, Storage::Details::c_StorageScope)); policies.emplace_back(std::make_unique()); m_pipeline = std::make_shared(policies); @@ -160,7 +160,7 @@ namespace Azure { namespace Storage { namespace Blobs { } policies.emplace_back(std::make_unique()); policies.emplace_back(std::make_unique( - credential, Details::c_StorageScope)); + credential, Storage::Details::c_StorageScope)); policies.emplace_back(std::make_unique()); m_subRequestPipeline = std::make_shared(policies); } @@ -172,7 +172,7 @@ namespace Azure { namespace Storage { namespace Blobs { { std::vector> policies; policies.emplace_back(std::make_unique( - Details::c_BlobServicePackageName, Version::VersionString())); + Storage::Details::c_BlobServicePackageName, Version::VersionString())); policies.emplace_back(std::make_unique()); for (const auto& p : options.PerOperationPolicies) { @@ -236,9 +236,9 @@ namespace Azure { namespace Storage { namespace Blobs { requestBody += getBatchBoundary(); auto blobUrl = m_serviceUrl; - blobUrl.AppendPath(Details::UrlEncodePath(subrequest.ContainerName)); - blobUrl.AppendPath(Details::UrlEncodePath(subrequest.BlobName)); - BlobRestClient::Blob::DeleteBlobOptions protocolLayerOptions; + blobUrl.AppendPath(Storage::Details::UrlEncodePath(subrequest.ContainerName)); + blobUrl.AppendPath(Storage::Details::UrlEncodePath(subrequest.BlobName)); + Details::BlobRestClient::Blob::DeleteBlobOptions protocolLayerOptions; protocolLayerOptions.DeleteSnapshots = subrequest.Options.DeleteSnapshots; protocolLayerOptions.IfModifiedSince = subrequest.Options.AccessConditions.IfModifiedSince; protocolLayerOptions.IfUnmodifiedSince @@ -246,8 +246,9 @@ namespace Azure { namespace Storage { namespace Blobs { protocolLayerOptions.IfMatch = subrequest.Options.AccessConditions.IfMatch; protocolLayerOptions.IfNoneMatch = subrequest.Options.AccessConditions.IfNoneMatch; protocolLayerOptions.LeaseId = subrequest.Options.AccessConditions.LeaseId; - auto message = BlobRestClient::Blob::DeleteCreateMessage(blobUrl, protocolLayerOptions); - message.RemoveHeader(Details::c_HttpHeaderXMsVersion); + auto message + = Details::BlobRestClient::Blob::DeleteCreateMessage(blobUrl, protocolLayerOptions); + message.RemoveHeader(Storage::Details::c_HttpHeaderXMsVersion); m_subRequestPipeline->Send(options.Context, message); requestBody += message.GetHTTPMessagePreBody(); } @@ -258,27 +259,27 @@ namespace Azure { namespace Storage { namespace Blobs { requestBody += getBatchBoundary(); auto blobUrl = m_serviceUrl; - blobUrl.AppendPath(Details::UrlEncodePath(subrequest.ContainerName)); - blobUrl.AppendPath(Details::UrlEncodePath(subrequest.BlobName)); - BlobRestClient::Blob::SetBlobAccessTierOptions protocolLayerOptions; + blobUrl.AppendPath(Storage::Details::UrlEncodePath(subrequest.ContainerName)); + blobUrl.AppendPath(Storage::Details::UrlEncodePath(subrequest.BlobName)); + Details::BlobRestClient::Blob::SetBlobAccessTierOptions protocolLayerOptions; protocolLayerOptions.Tier = subrequest.Tier; protocolLayerOptions.RehydratePriority = subrequest.Options.RehydratePriority; - auto message - = BlobRestClient::Blob::SetAccessTierCreateMessage(blobUrl, protocolLayerOptions); - message.RemoveHeader(Details::c_HttpHeaderXMsVersion); + auto message = Details::BlobRestClient::Blob::SetAccessTierCreateMessage( + blobUrl, protocolLayerOptions); + message.RemoveHeader(Storage::Details::c_HttpHeaderXMsVersion); m_subRequestPipeline->Send(options.Context, message); requestBody += message.GetHTTPMessagePreBody(); } requestBody += "--" + boundary + "--" + c_lineEnding; } - BlobRestClient::BlobBatch::SubmitBlobBatchOptions protocolLayerOptions; + Details::BlobRestClient::BlobBatch::SubmitBlobBatchOptions protocolLayerOptions; protocolLayerOptions.ContentType = c_contentTypePrefix + boundary; Azure::Core::Http::MemoryBodyStream requestBodyStream( reinterpret_cast(requestBody.data()), requestBody.length()); - auto rawResponse = BlobRestClient::BlobBatch::SubmitBatch( + auto rawResponse = Details::BlobRestClient::BlobBatch::SubmitBatch( options.Context, *m_pipeline, m_serviceUrl, &requestBodyStream, protocolLayerOptions); if (rawResponse->ContentType.substr(0, c_contentTypePrefix.length()) == c_contentTypePrefix) @@ -396,8 +397,9 @@ namespace Azure { namespace Storage { namespace Blobs { { try { - batchResult.DeleteBlobResults.emplace_back(BlobRestClient::Blob::DeleteCreateResponse( - options.Context, std::move(rawSubresponse))); + batchResult.DeleteBlobResults.emplace_back( + Details::BlobRestClient::Blob::DeleteCreateResponse( + options.Context, std::move(rawSubresponse))); } catch (StorageError& e) { @@ -410,7 +412,7 @@ namespace Azure { namespace Storage { namespace Blobs { try { batchResult.SetBlobAccessTierResults.emplace_back( - BlobRestClient::Blob::SetAccessTierCreateResponse( + Details::BlobRestClient::Blob::SetAccessTierCreateResponse( options.Context, std::move(rawSubresponse))); } catch (StorageError& e) diff --git a/sdk/storage/azure-storage-blobs/src/blob_client.cpp b/sdk/storage/azure-storage-blobs/src/blob_client.cpp index 1be914ad6..3553d554c 100644 --- a/sdk/storage/azure-storage-blobs/src/blob_client.cpp +++ b/sdk/storage/azure-storage-blobs/src/blob_client.cpp @@ -25,10 +25,10 @@ namespace Azure { namespace Storage { namespace Blobs { const std::string& blobName, const BlobClientOptions& options) { - auto parsedConnectionString = Details::ParseConnectionString(connectionString); + auto parsedConnectionString = Storage::Details::ParseConnectionString(connectionString); auto blobUri = std::move(parsedConnectionString.BlobServiceUri); - blobUri.AppendPath(Details::UrlEncodePath(containerName)); - blobUri.AppendPath(Details::UrlEncodePath(blobName)); + blobUri.AppendPath(Storage::Details::UrlEncodePath(containerName)); + blobUri.AppendPath(Storage::Details::UrlEncodePath(blobName)); if (parsedConnectionString.KeyCredential) { @@ -48,7 +48,7 @@ namespace Azure { namespace Storage { namespace Blobs { { std::vector> policies; policies.emplace_back(std::make_unique( - Details::c_BlobServicePackageName, Version::VersionString())); + Storage::Details::c_BlobServicePackageName, Version::VersionString())); policies.emplace_back(std::make_unique()); for (const auto& p : options.PerOperationPolicies) { @@ -73,7 +73,7 @@ namespace Azure { namespace Storage { namespace Blobs { { std::vector> policies; policies.emplace_back(std::make_unique( - Details::c_BlobServicePackageName, Version::VersionString())); + Storage::Details::c_BlobServicePackageName, Version::VersionString())); policies.emplace_back(std::make_unique()); for (const auto& p : options.PerOperationPolicies) { @@ -86,7 +86,7 @@ namespace Azure { namespace Storage { namespace Blobs { } policies.emplace_back(std::make_unique()); policies.emplace_back(std::make_unique( - credential, Details::c_StorageScope)); + credential, Storage::Details::c_StorageScope)); policies.emplace_back(std::make_unique()); m_pipeline = std::make_shared(policies); } @@ -97,7 +97,7 @@ namespace Azure { namespace Storage { namespace Blobs { { std::vector> policies; policies.emplace_back(std::make_unique( - Details::c_BlobServicePackageName, Version::VersionString())); + Storage::Details::c_BlobServicePackageName, Version::VersionString())); policies.emplace_back(std::make_unique()); for (const auto& p : options.PerOperationPolicies) { @@ -124,12 +124,13 @@ namespace Azure { namespace Storage { namespace Blobs { BlobClient newClient(*this); if (snapshot.empty()) { - newClient.m_blobUrl.RemoveQueryParameter(Details::c_HttpQuerySnapshot); + newClient.m_blobUrl.RemoveQueryParameter(Storage::Details::c_HttpQuerySnapshot); } else { newClient.m_blobUrl.AppendQueryParameter( - Details::c_HttpQuerySnapshot, Details::UrlEncodeQueryParameter(snapshot)); + Storage::Details::c_HttpQuerySnapshot, + Storage::Details::UrlEncodeQueryParameter(snapshot)); } return newClient; } @@ -139,12 +140,13 @@ namespace Azure { namespace Storage { namespace Blobs { BlobClient newClient(*this); if (versionId.empty()) { - newClient.m_blobUrl.RemoveQueryParameter(Details::c_HttpQueryVersionId); + newClient.m_blobUrl.RemoveQueryParameter(Storage::Details::c_HttpQueryVersionId); } else { newClient.m_blobUrl.AppendQueryParameter( - Details::c_HttpQueryVersionId, Details::UrlEncodeQueryParameter(versionId)); + Storage::Details::c_HttpQueryVersionId, + Storage::Details::UrlEncodeQueryParameter(versionId)); } return newClient; } @@ -152,7 +154,7 @@ namespace Azure { namespace Storage { namespace Blobs { Azure::Core::Response BlobClient::Download( const DownloadBlobOptions& options) const { - BlobRestClient::Blob::DownloadBlobOptions protocolLayerOptions; + Details::BlobRestClient::Blob::DownloadBlobOptions protocolLayerOptions; if (options.Offset.HasValue() && options.Length.HasValue()) { protocolLayerOptions.Range = std::make_pair( @@ -177,7 +179,7 @@ namespace Azure { namespace Storage { namespace Blobs { protocolLayerOptions.EncryptionAlgorithm = m_customerProvidedKey.GetValue().Algorithm; } - auto downloadResponse = BlobRestClient::Blob::Download( + auto downloadResponse = Details::BlobRestClient::Blob::Download( options.Context, *m_pipeline, m_blobUrl, protocolLayerOptions); { @@ -206,7 +208,7 @@ namespace Azure { namespace Storage { namespace Blobs { }; ReliableStreamOptions reliableStreamOptions; - reliableStreamOptions.MaxRetryRequests = Details::c_reliableStreamRetryCount; + reliableStreamOptions.MaxRetryRequests = Storage::Details::c_reliableStreamRetryCount; downloadResponse->BodyStream = std::make_unique( std::move(downloadResponse->BodyStream), reliableStreamOptions, retryFunction); } @@ -335,7 +337,7 @@ namespace Azure { namespace Storage { namespace Blobs { chunkSize = std::min(chunkSize, c_defaultChunkSize); } - Details::ConcurrentTransfer( + Storage::Details::ConcurrentTransfer( remainingOffset, remainingSize, chunkSize, options.Concurrency, downloadChunkFunc); ret->ContentLength = blobRangeSize; return ret; @@ -369,7 +371,7 @@ namespace Azure { namespace Storage { namespace Blobs { firstChunkOptions.Length = firstChunkLength; } - Details::FileWriter fileWriter(file); + Storage::Details::FileWriter fileWriter(file); auto firstChunk = Download(firstChunkOptions); @@ -393,7 +395,7 @@ namespace Azure { namespace Storage { namespace Blobs { firstChunkLength = std::min(firstChunkLength, blobRangeSize); auto bodyStreamToFile = [](Azure::Core::Http::BodyStream& stream, - Details::FileWriter& fileWriter, + Storage::Details::FileWriter& fileWriter, int64_t offset, int64_t length, Azure::Core::Context& context) { @@ -473,7 +475,7 @@ namespace Azure { namespace Storage { namespace Blobs { chunkSize = std::min(chunkSize, c_defaultChunkSize); } - Details::ConcurrentTransfer( + Storage::Details::ConcurrentTransfer( remainingOffset, remainingSize, chunkSize, options.Concurrency, downloadChunkFunc); ret->ContentLength = blobRangeSize; return ret; @@ -482,7 +484,7 @@ namespace Azure { namespace Storage { namespace Blobs { Azure::Core::Response BlobClient::GetProperties( const GetBlobPropertiesOptions& options) const { - BlobRestClient::Blob::GetBlobPropertiesOptions protocolLayerOptions; + Details::BlobRestClient::Blob::GetBlobPropertiesOptions protocolLayerOptions; protocolLayerOptions.LeaseId = options.AccessConditions.LeaseId; protocolLayerOptions.IfModifiedSince = options.AccessConditions.IfModifiedSince; protocolLayerOptions.IfUnmodifiedSince = options.AccessConditions.IfUnmodifiedSince; @@ -495,7 +497,7 @@ namespace Azure { namespace Storage { namespace Blobs { protocolLayerOptions.EncryptionKeySha256 = m_customerProvidedKey.GetValue().KeyHash; protocolLayerOptions.EncryptionAlgorithm = m_customerProvidedKey.GetValue().Algorithm; } - return BlobRestClient::Blob::GetProperties( + return Details::BlobRestClient::Blob::GetProperties( options.Context, *m_pipeline, m_blobUrl, protocolLayerOptions); } @@ -503,7 +505,7 @@ namespace Azure { namespace Storage { namespace Blobs { BlobHttpHeaders httpHeaders, const SetBlobHttpHeadersOptions& options) const { - BlobRestClient::Blob::SetBlobHttpHeadersOptions protocolLayerOptions; + Details::BlobRestClient::Blob::SetBlobHttpHeadersOptions protocolLayerOptions; protocolLayerOptions.HttpHeaders = std::move(httpHeaders); protocolLayerOptions.LeaseId = options.AccessConditions.LeaseId; protocolLayerOptions.IfModifiedSince = options.AccessConditions.IfModifiedSince; @@ -511,7 +513,7 @@ namespace Azure { namespace Storage { namespace Blobs { protocolLayerOptions.IfMatch = options.AccessConditions.IfMatch; protocolLayerOptions.IfNoneMatch = options.AccessConditions.IfNoneMatch; protocolLayerOptions.IfTags = options.AccessConditions.TagConditions; - return BlobRestClient::Blob::SetHttpHeaders( + return Details::BlobRestClient::Blob::SetHttpHeaders( options.Context, *m_pipeline, m_blobUrl, protocolLayerOptions); } @@ -519,7 +521,7 @@ namespace Azure { namespace Storage { namespace Blobs { std::map metadata, const SetBlobMetadataOptions& options) const { - BlobRestClient::Blob::SetBlobMetadataOptions protocolLayerOptions; + Details::BlobRestClient::Blob::SetBlobMetadataOptions protocolLayerOptions; protocolLayerOptions.Metadata = std::move(metadata); protocolLayerOptions.LeaseId = options.AccessConditions.LeaseId; protocolLayerOptions.IfModifiedSince = options.AccessConditions.IfModifiedSince; @@ -534,7 +536,7 @@ namespace Azure { namespace Storage { namespace Blobs { protocolLayerOptions.EncryptionAlgorithm = m_customerProvidedKey.GetValue().Algorithm; } protocolLayerOptions.EncryptionScope = m_encryptionScope; - return BlobRestClient::Blob::SetMetadata( + return Details::BlobRestClient::Blob::SetMetadata( options.Context, *m_pipeline, m_blobUrl, protocolLayerOptions); } @@ -542,10 +544,10 @@ namespace Azure { namespace Storage { namespace Blobs { AccessTier Tier, const SetBlobAccessTierOptions& options) const { - BlobRestClient::Blob::SetBlobAccessTierOptions protocolLayerOptions; + Details::BlobRestClient::Blob::SetBlobAccessTierOptions protocolLayerOptions; protocolLayerOptions.Tier = Tier; protocolLayerOptions.RehydratePriority = options.RehydratePriority; - return BlobRestClient::Blob::SetAccessTier( + return Details::BlobRestClient::Blob::SetAccessTier( options.Context, *m_pipeline, m_blobUrl, protocolLayerOptions); } @@ -553,7 +555,7 @@ namespace Azure { namespace Storage { namespace Blobs { const std::string& sourceUri, const StartCopyBlobFromUriOptions& options) const { - BlobRestClient::Blob::StartCopyBlobFromUriOptions protocolLayerOptions; + Details::BlobRestClient::Blob::StartCopyBlobFromUriOptions protocolLayerOptions; protocolLayerOptions.Metadata = options.Metadata; protocolLayerOptions.SourceUri = sourceUri; protocolLayerOptions.Tier = options.Tier; @@ -571,7 +573,7 @@ namespace Azure { namespace Storage { namespace Blobs { protocolLayerOptions.SourceIfNoneMatch = options.SourceConditions.IfNoneMatch; protocolLayerOptions.ShouldSealDestination = options.ShouldSealDestination; protocolLayerOptions.SourceIfTags = options.SourceConditions.TagConditions; - return BlobRestClient::Blob::StartCopyFromUri( + return Details::BlobRestClient::Blob::StartCopyFromUri( options.Context, *m_pipeline, m_blobUrl, protocolLayerOptions); } @@ -579,17 +581,17 @@ namespace Azure { namespace Storage { namespace Blobs { const std::string& copyId, const AbortCopyBlobFromUriOptions& options) const { - BlobRestClient::Blob::AbortCopyBlobFromUriOptions protocolLayerOptions; + Details::BlobRestClient::Blob::AbortCopyBlobFromUriOptions protocolLayerOptions; protocolLayerOptions.CopyId = copyId; protocolLayerOptions.LeaseId = options.AccessConditions.LeaseId; - return BlobRestClient::Blob::AbortCopyFromUri( + return Details::BlobRestClient::Blob::AbortCopyFromUri( options.Context, *m_pipeline, m_blobUrl, protocolLayerOptions); } Azure::Core::Response BlobClient::CreateSnapshot( const CreateBlobSnapshotOptions& options) const { - BlobRestClient::Blob::CreateBlobSnapshotOptions protocolLayerOptions; + Details::BlobRestClient::Blob::CreateBlobSnapshotOptions protocolLayerOptions; protocolLayerOptions.Metadata = options.Metadata; protocolLayerOptions.LeaseId = options.AccessConditions.LeaseId; protocolLayerOptions.IfModifiedSince = options.AccessConditions.IfModifiedSince; @@ -604,13 +606,13 @@ namespace Azure { namespace Storage { namespace Blobs { protocolLayerOptions.EncryptionAlgorithm = m_customerProvidedKey.GetValue().Algorithm; } protocolLayerOptions.EncryptionScope = m_encryptionScope; - return BlobRestClient::Blob::CreateSnapshot( + return Details::BlobRestClient::Blob::CreateSnapshot( options.Context, *m_pipeline, m_blobUrl, protocolLayerOptions); } Azure::Core::Response BlobClient::Delete(const DeleteBlobOptions& options) const { - BlobRestClient::Blob::DeleteBlobOptions protocolLayerOptions; + Details::BlobRestClient::Blob::DeleteBlobOptions protocolLayerOptions; protocolLayerOptions.DeleteSnapshots = options.DeleteSnapshots; protocolLayerOptions.LeaseId = options.AccessConditions.LeaseId; protocolLayerOptions.IfModifiedSince = options.AccessConditions.IfModifiedSince; @@ -618,15 +620,15 @@ namespace Azure { namespace Storage { namespace Blobs { protocolLayerOptions.IfMatch = options.AccessConditions.IfMatch; protocolLayerOptions.IfNoneMatch = options.AccessConditions.IfNoneMatch; protocolLayerOptions.IfTags = options.AccessConditions.TagConditions; - return BlobRestClient::Blob::Delete( + return Details::BlobRestClient::Blob::Delete( options.Context, *m_pipeline, m_blobUrl, protocolLayerOptions); } Azure::Core::Response BlobClient::Undelete( const UndeleteBlobOptions& options) const { - BlobRestClient::Blob::UndeleteBlobOptions protocolLayerOptions; - return BlobRestClient::Blob::Undelete( + Details::BlobRestClient::Blob::UndeleteBlobOptions protocolLayerOptions; + return Details::BlobRestClient::Blob::Undelete( options.Context, *m_pipeline, m_blobUrl, protocolLayerOptions); } @@ -635,7 +637,7 @@ namespace Azure { namespace Storage { namespace Blobs { int32_t duration, const AcquireBlobLeaseOptions& options) const { - BlobRestClient::Blob::AcquireBlobLeaseOptions protocolLayerOptions; + Details::BlobRestClient::Blob::AcquireBlobLeaseOptions protocolLayerOptions; protocolLayerOptions.ProposedLeaseId = proposedLeaseId; protocolLayerOptions.LeaseDuration = duration; protocolLayerOptions.IfModifiedSince = options.IfModifiedSince; @@ -643,7 +645,7 @@ namespace Azure { namespace Storage { namespace Blobs { protocolLayerOptions.IfMatch = options.IfMatch; protocolLayerOptions.IfNoneMatch = options.IfNoneMatch; protocolLayerOptions.IfTags = options.TagConditions; - return BlobRestClient::Blob::AcquireLease( + return Details::BlobRestClient::Blob::AcquireLease( options.Context, *m_pipeline, m_blobUrl, protocolLayerOptions); } @@ -651,14 +653,14 @@ namespace Azure { namespace Storage { namespace Blobs { const std::string& leaseId, const RenewBlobLeaseOptions& options) const { - BlobRestClient::Blob::RenewBlobLeaseOptions protocolLayerOptions; + Details::BlobRestClient::Blob::RenewBlobLeaseOptions protocolLayerOptions; protocolLayerOptions.LeaseId = leaseId; protocolLayerOptions.IfModifiedSince = options.IfModifiedSince; protocolLayerOptions.IfUnmodifiedSince = options.IfUnmodifiedSince; protocolLayerOptions.IfMatch = options.IfMatch; protocolLayerOptions.IfNoneMatch = options.IfNoneMatch; protocolLayerOptions.IfTags = options.TagConditions; - return BlobRestClient::Blob::RenewLease( + return Details::BlobRestClient::Blob::RenewLease( options.Context, *m_pipeline, m_blobUrl, protocolLayerOptions); } @@ -666,14 +668,14 @@ namespace Azure { namespace Storage { namespace Blobs { const std::string& leaseId, const ReleaseBlobLeaseOptions& options) const { - BlobRestClient::Blob::ReleaseBlobLeaseOptions protocolLayerOptions; + Details::BlobRestClient::Blob::ReleaseBlobLeaseOptions protocolLayerOptions; protocolLayerOptions.LeaseId = leaseId; protocolLayerOptions.IfModifiedSince = options.IfModifiedSince; protocolLayerOptions.IfUnmodifiedSince = options.IfUnmodifiedSince; protocolLayerOptions.IfMatch = options.IfMatch; protocolLayerOptions.IfNoneMatch = options.IfNoneMatch; protocolLayerOptions.IfTags = options.TagConditions; - return BlobRestClient::Blob::ReleaseLease( + return Details::BlobRestClient::Blob::ReleaseLease( options.Context, *m_pipeline, m_blobUrl, protocolLayerOptions); } @@ -682,7 +684,7 @@ namespace Azure { namespace Storage { namespace Blobs { const std::string& proposedLeaseId, const ChangeBlobLeaseOptions& options) const { - BlobRestClient::Blob::ChangeBlobLeaseOptions protocolLayerOptions; + Details::BlobRestClient::Blob::ChangeBlobLeaseOptions protocolLayerOptions; protocolLayerOptions.LeaseId = leaseId; protocolLayerOptions.ProposedLeaseId = proposedLeaseId; protocolLayerOptions.IfModifiedSince = options.IfModifiedSince; @@ -690,21 +692,21 @@ namespace Azure { namespace Storage { namespace Blobs { protocolLayerOptions.IfMatch = options.IfMatch; protocolLayerOptions.IfNoneMatch = options.IfNoneMatch; protocolLayerOptions.IfTags = options.TagConditions; - return BlobRestClient::Blob::ChangeLease( + return Details::BlobRestClient::Blob::ChangeLease( options.Context, *m_pipeline, m_blobUrl, protocolLayerOptions); } Azure::Core::Response BlobClient::BreakLease( const BreakBlobLeaseOptions& options) const { - BlobRestClient::Blob::BreakBlobLeaseOptions protocolLayerOptions; + Details::BlobRestClient::Blob::BreakBlobLeaseOptions protocolLayerOptions; protocolLayerOptions.BreakPeriod = options.BreakPeriod; protocolLayerOptions.IfModifiedSince = options.IfModifiedSince; protocolLayerOptions.IfUnmodifiedSince = options.IfUnmodifiedSince; protocolLayerOptions.IfMatch = options.IfMatch; protocolLayerOptions.IfNoneMatch = options.IfNoneMatch; protocolLayerOptions.IfTags = options.TagConditions; - return BlobRestClient::Blob::BreakLease( + return Details::BlobRestClient::Blob::BreakLease( options.Context, *m_pipeline, m_blobUrl, protocolLayerOptions); } @@ -712,19 +714,19 @@ namespace Azure { namespace Storage { namespace Blobs { std::map tags, const SetBlobTagsOptions& options) const { - BlobRestClient::Blob::SetBlobTagsOptions protocolLayerOptions; + Details::BlobRestClient::Blob::SetBlobTagsOptions protocolLayerOptions; protocolLayerOptions.Tags = std::move(tags); protocolLayerOptions.IfTags = options.TagConditions; - return BlobRestClient::Blob::SetTags( + return Details::BlobRestClient::Blob::SetTags( options.Context, *m_pipeline, m_blobUrl, protocolLayerOptions); } Azure::Core::Response BlobClient::GetTags( const GetBlobTagsOptions& options) const { - BlobRestClient::Blob::GetBlobTagsOptions protocolLayerOptions; + Details::BlobRestClient::Blob::GetBlobTagsOptions protocolLayerOptions; protocolLayerOptions.IfTags = options.TagConditions; - return BlobRestClient::Blob::GetTags( + return Details::BlobRestClient::Blob::GetTags( options.Context, *m_pipeline, m_blobUrl, protocolLayerOptions); } diff --git a/sdk/storage/azure-storage-blobs/src/blob_container_client.cpp b/sdk/storage/azure-storage-blobs/src/blob_container_client.cpp index 98387a012..ba7cd30ad 100644 --- a/sdk/storage/azure-storage-blobs/src/blob_container_client.cpp +++ b/sdk/storage/azure-storage-blobs/src/blob_container_client.cpp @@ -21,9 +21,9 @@ namespace Azure { namespace Storage { namespace Blobs { const std::string& containerName, const BlobContainerClientOptions& options) { - auto parsedConnectionString = Details::ParseConnectionString(connectionString); + auto parsedConnectionString = Storage::Details::ParseConnectionString(connectionString); auto containerUri = std::move(parsedConnectionString.BlobServiceUri); - containerUri.AppendPath(Details::UrlEncodePath(containerName)); + containerUri.AppendPath(Storage::Details::UrlEncodePath(containerName)); if (parsedConnectionString.KeyCredential) { @@ -44,7 +44,7 @@ namespace Azure { namespace Storage { namespace Blobs { { std::vector> policies; policies.emplace_back(std::make_unique( - Details::c_BlobServicePackageName, Version::VersionString())); + Storage::Details::c_BlobServicePackageName, Version::VersionString())); policies.emplace_back(std::make_unique()); for (const auto& p : options.PerOperationPolicies) { @@ -69,7 +69,7 @@ namespace Azure { namespace Storage { namespace Blobs { { std::vector> policies; policies.emplace_back(std::make_unique( - Details::c_BlobServicePackageName, Version::VersionString())); + Storage::Details::c_BlobServicePackageName, Version::VersionString())); policies.emplace_back(std::make_unique()); for (const auto& p : options.PerOperationPolicies) { @@ -82,7 +82,7 @@ namespace Azure { namespace Storage { namespace Blobs { } policies.emplace_back(std::make_unique()); policies.emplace_back(std::make_unique( - credential, Details::c_StorageScope)); + credential, Storage::Details::c_StorageScope)); policies.emplace_back(std::make_unique()); m_pipeline = std::make_shared(policies); } @@ -95,7 +95,7 @@ namespace Azure { namespace Storage { namespace Blobs { { std::vector> policies; policies.emplace_back(std::make_unique( - Details::c_BlobServicePackageName, Version::VersionString())); + Storage::Details::c_BlobServicePackageName, Version::VersionString())); policies.emplace_back(std::make_unique()); for (const auto& p : options.PerOperationPolicies) { @@ -114,7 +114,7 @@ namespace Azure { namespace Storage { namespace Blobs { BlobClient BlobContainerClient::GetBlobClient(const std::string& blobName) const { auto blobUri = m_containerUrl; - blobUri.AppendPath(Details::UrlEncodePath(blobName)); + blobUri.AppendPath(Storage::Details::UrlEncodePath(blobName)); return BlobClient(std::move(blobUri), m_pipeline, m_customerProvidedKey, m_encryptionScope); } @@ -136,23 +136,23 @@ namespace Azure { namespace Storage { namespace Blobs { Azure::Core::Response BlobContainerClient::Create( const CreateContainerOptions& options) const { - BlobRestClient::Container::CreateContainerOptions protocolLayerOptions; + Details::BlobRestClient::Container::CreateContainerOptions protocolLayerOptions; protocolLayerOptions.AccessType = options.AccessType; protocolLayerOptions.Metadata = options.Metadata; protocolLayerOptions.DefaultEncryptionScope = options.DefaultEncryptionScope; protocolLayerOptions.PreventEncryptionScopeOverride = options.PreventEncryptionScopeOverride; - return BlobRestClient::Container::Create( + return Details::BlobRestClient::Container::Create( options.Context, *m_pipeline, m_containerUrl, protocolLayerOptions); } Azure::Core::Response BlobContainerClient::Delete( const DeleteContainerOptions& options) const { - BlobRestClient::Container::DeleteContainerOptions protocolLayerOptions; + Details::BlobRestClient::Container::DeleteContainerOptions protocolLayerOptions; protocolLayerOptions.LeaseId = options.AccessConditions.LeaseId; protocolLayerOptions.IfModifiedSince = options.AccessConditions.IfModifiedSince; protocolLayerOptions.IfUnmodifiedSince = options.AccessConditions.IfUnmodifiedSince; - return BlobRestClient::Container::Delete( + return Details::BlobRestClient::Container::Delete( options.Context, *m_pipeline, m_containerUrl, protocolLayerOptions); } @@ -161,19 +161,19 @@ namespace Azure { namespace Storage { namespace Blobs { const std::string& deletedContainerVersion, const UndeleteContainerOptions& options) const { - BlobRestClient::Container::UndeleteContainerOptions protocolLayerOptions; + Details::BlobRestClient::Container::UndeleteContainerOptions protocolLayerOptions; protocolLayerOptions.DeletedContainerName = deletedContainerName; protocolLayerOptions.DeletedContainerVersion = deletedContainerVersion; - return BlobRestClient::Container::Undelete( + return Details::BlobRestClient::Container::Undelete( options.Context, *m_pipeline, m_containerUrl, protocolLayerOptions); } Azure::Core::Response BlobContainerClient::GetProperties( const GetContainerPropertiesOptions& options) const { - BlobRestClient::Container::GetContainerPropertiesOptions protocolLayerOptions; + Details::BlobRestClient::Container::GetContainerPropertiesOptions protocolLayerOptions; protocolLayerOptions.LeaseId = options.AccessConditions.LeaseId; - return BlobRestClient::Container::GetProperties( + return Details::BlobRestClient::Container::GetProperties( options.Context, *m_pipeline, m_containerUrl, protocolLayerOptions); } @@ -181,7 +181,7 @@ namespace Azure { namespace Storage { namespace Blobs { std::map metadata, SetContainerMetadataOptions options) const { - BlobRestClient::Container::SetContainerMetadataOptions protocolLayerOptions; + Details::BlobRestClient::Container::SetContainerMetadataOptions protocolLayerOptions; protocolLayerOptions.Metadata = metadata; protocolLayerOptions.LeaseId = options.AccessConditions.LeaseId; protocolLayerOptions.IfModifiedSince = options.AccessConditions.IfModifiedSince; @@ -191,19 +191,19 @@ namespace Azure { namespace Storage { namespace Blobs { // If-Modified-Since throw std::runtime_error("this operation doesn't support unmodified since access condition."); } - return BlobRestClient::Container::SetMetadata( + return Details::BlobRestClient::Container::SetMetadata( options.Context, *m_pipeline, m_containerUrl, protocolLayerOptions); } Azure::Core::Response BlobContainerClient::ListBlobsFlatSegment( const ListBlobsSegmentOptions& options) const { - BlobRestClient::Container::ListBlobsFlatSegmentOptions protocolLayerOptions; + Details::BlobRestClient::Container::ListBlobsFlatSegmentOptions protocolLayerOptions; protocolLayerOptions.Prefix = options.Prefix; protocolLayerOptions.ContinuationToken = options.ContinuationToken; protocolLayerOptions.MaxResults = options.MaxResults; protocolLayerOptions.Include = options.Include; - auto response = BlobRestClient::Container::ListBlobsFlat( + auto response = Details::BlobRestClient::Container::ListBlobsFlat( options.Context, *m_pipeline, m_containerUrl, protocolLayerOptions); for (auto& i : response->Items) { @@ -220,13 +220,13 @@ namespace Azure { namespace Storage { namespace Blobs { const std::string& delimiter, const ListBlobsSegmentOptions& options) const { - BlobRestClient::Container::ListBlobsByHierarchySegmentOptions protocolLayerOptions; + Details::BlobRestClient::Container::ListBlobsByHierarchySegmentOptions protocolLayerOptions; protocolLayerOptions.Prefix = options.Prefix; protocolLayerOptions.Delimiter = delimiter; protocolLayerOptions.ContinuationToken = options.ContinuationToken; protocolLayerOptions.MaxResults = options.MaxResults; protocolLayerOptions.Include = options.Include; - auto response = BlobRestClient::Container::ListBlobsByHierarchy( + auto response = Details::BlobRestClient::Container::ListBlobsByHierarchy( options.Context, *m_pipeline, m_containerUrl, protocolLayerOptions); for (auto& i : response->Items) { @@ -241,22 +241,22 @@ namespace Azure { namespace Storage { namespace Blobs { Azure::Core::Response BlobContainerClient::GetAccessPolicy( const GetContainerAccessPolicyOptions& options) const { - BlobRestClient::Container::GetContainerAccessPolicyOptions protocolLayerOptions; + Details::BlobRestClient::Container::GetContainerAccessPolicyOptions protocolLayerOptions; protocolLayerOptions.LeaseId = options.AccessConditions.LeaseId; - return BlobRestClient::Container::GetAccessPolicy( + return Details::BlobRestClient::Container::GetAccessPolicy( options.Context, *m_pipeline, m_containerUrl, protocolLayerOptions); } Azure::Core::Response BlobContainerClient::SetAccessPolicy( const SetContainerAccessPolicyOptions& options) const { - BlobRestClient::Container::SetContainerAccessPolicyOptions protocolLayerOptions; + Details::BlobRestClient::Container::SetContainerAccessPolicyOptions protocolLayerOptions; protocolLayerOptions.AccessType = options.AccessType; protocolLayerOptions.SignedIdentifiers = options.SignedIdentifiers; protocolLayerOptions.LeaseId = options.AccessConditions.LeaseId; protocolLayerOptions.IfModifiedSince = options.AccessConditions.IfModifiedSince; protocolLayerOptions.IfUnmodifiedSince = options.AccessConditions.IfUnmodifiedSince; - return BlobRestClient::Container::SetAccessPolicy( + return Details::BlobRestClient::Container::SetAccessPolicy( options.Context, *m_pipeline, m_containerUrl, protocolLayerOptions); } @@ -265,12 +265,12 @@ namespace Azure { namespace Storage { namespace Blobs { int32_t duration, const AcquireContainerLeaseOptions& options) const { - BlobRestClient::Container::AcquireContainerLeaseOptions protocolLayerOptions; + Details::BlobRestClient::Container::AcquireContainerLeaseOptions protocolLayerOptions; protocolLayerOptions.ProposedLeaseId = proposedLeaseId; protocolLayerOptions.LeaseDuration = duration; protocolLayerOptions.IfModifiedSince = options.IfModifiedSince; protocolLayerOptions.IfUnmodifiedSince = options.IfUnmodifiedSince; - return BlobRestClient::Container::AcquireLease( + return Details::BlobRestClient::Container::AcquireLease( options.Context, *m_pipeline, m_containerUrl, protocolLayerOptions); } @@ -278,11 +278,11 @@ namespace Azure { namespace Storage { namespace Blobs { const std::string& leaseId, const RenewContainerLeaseOptions& options) const { - BlobRestClient::Container::RenewContainerLeaseOptions protocolLayerOptions; + Details::BlobRestClient::Container::RenewContainerLeaseOptions protocolLayerOptions; protocolLayerOptions.LeaseId = leaseId; protocolLayerOptions.IfModifiedSince = options.IfModifiedSince; protocolLayerOptions.IfUnmodifiedSince = options.IfUnmodifiedSince; - return BlobRestClient::Container::RenewLease( + return Details::BlobRestClient::Container::RenewLease( options.Context, *m_pipeline, m_containerUrl, protocolLayerOptions); } @@ -290,11 +290,11 @@ namespace Azure { namespace Storage { namespace Blobs { const std::string& leaseId, const ReleaseContainerLeaseOptions& options) const { - BlobRestClient::Container::ReleaseContainerLeaseOptions protocolLayerOptions; + Details::BlobRestClient::Container::ReleaseContainerLeaseOptions protocolLayerOptions; protocolLayerOptions.LeaseId = leaseId; protocolLayerOptions.IfModifiedSince = options.IfModifiedSince; protocolLayerOptions.IfUnmodifiedSince = options.IfUnmodifiedSince; - return BlobRestClient::Container::ReleaseLease( + return Details::BlobRestClient::Container::ReleaseLease( options.Context, *m_pipeline, m_containerUrl, protocolLayerOptions); } @@ -303,23 +303,23 @@ namespace Azure { namespace Storage { namespace Blobs { const std::string& proposedLeaseId, const ChangeContainerLeaseOptions& options) const { - BlobRestClient::Container::ChangeContainerLeaseOptions protocolLayerOptions; + Details::BlobRestClient::Container::ChangeContainerLeaseOptions protocolLayerOptions; protocolLayerOptions.LeaseId = leaseId; protocolLayerOptions.ProposedLeaseId = proposedLeaseId; protocolLayerOptions.IfModifiedSince = options.IfModifiedSince; protocolLayerOptions.IfUnmodifiedSince = options.IfUnmodifiedSince; - return BlobRestClient::Container::ChangeLease( + return Details::BlobRestClient::Container::ChangeLease( options.Context, *m_pipeline, m_containerUrl, protocolLayerOptions); } Azure::Core::Response BlobContainerClient::BreakLease( const BreakContainerLeaseOptions& options) const { - BlobRestClient::Container::BreakContainerLeaseOptions protocolLayerOptions; + Details::BlobRestClient::Container::BreakContainerLeaseOptions protocolLayerOptions; protocolLayerOptions.BreakPeriod = options.BreakPeriod; protocolLayerOptions.IfModifiedSince = options.IfModifiedSince; protocolLayerOptions.IfUnmodifiedSince = options.IfUnmodifiedSince; - return BlobRestClient::Container::BreakLease( + return Details::BlobRestClient::Container::BreakLease( options.Context, *m_pipeline, m_containerUrl, protocolLayerOptions); } diff --git a/sdk/storage/azure-storage-blobs/src/blob_sas_builder.cpp b/sdk/storage/azure-storage-blobs/src/blob_sas_builder.cpp index e88afcaa5..f3db73938 100644 --- a/sdk/storage/azure-storage-blobs/src/blob_sas_builder.cpp +++ b/sdk/storage/azure-storage-blobs/src/blob_sas_builder.cpp @@ -134,53 +134,58 @@ namespace Azure { namespace Storage { namespace Blobs { + resource + "\n" + snapshotVersion + "\n" + CacheControl + "\n" + ContentDisposition + "\n" + ContentEncoding + "\n" + ContentLanguage + "\n" + ContentType; - std::string signature - = Base64Encode(Details::HmacSha256(stringToSign, Base64Decode(credential.GetAccountKey()))); + std::string signature = Base64Encode( + Storage::Details::HmacSha256(stringToSign, Base64Decode(credential.GetAccountKey()))); Azure::Core::Http::Url builder; - builder.AppendQueryParameter("sv", Details::UrlEncodeQueryParameter(Version)); - builder.AppendQueryParameter("spr", Details::UrlEncodeQueryParameter(protocol)); + builder.AppendQueryParameter("sv", Storage::Details::UrlEncodeQueryParameter(Version)); + builder.AppendQueryParameter("spr", Storage::Details::UrlEncodeQueryParameter(protocol)); if (StartsOn.HasValue()) { - builder.AppendQueryParameter("st", Details::UrlEncodeQueryParameter(StartsOn.GetValue())); + builder.AppendQueryParameter( + "st", Storage::Details::UrlEncodeQueryParameter(StartsOn.GetValue())); } if (!ExpiresOn.empty()) { - builder.AppendQueryParameter("se", Details::UrlEncodeQueryParameter(ExpiresOn)); + builder.AppendQueryParameter("se", Storage::Details::UrlEncodeQueryParameter(ExpiresOn)); } if (IPRange.HasValue()) { - builder.AppendQueryParameter("sip", Details::UrlEncodeQueryParameter(IPRange.GetValue())); + builder.AppendQueryParameter( + "sip", Storage::Details::UrlEncodeQueryParameter(IPRange.GetValue())); } if (!Identifier.empty()) { - builder.AppendQueryParameter("si", Details::UrlEncodeQueryParameter(Identifier)); + builder.AppendQueryParameter("si", Storage::Details::UrlEncodeQueryParameter(Identifier)); } - builder.AppendQueryParameter("sr", Details::UrlEncodeQueryParameter(resource)); + builder.AppendQueryParameter("sr", Storage::Details::UrlEncodeQueryParameter(resource)); if (!Permissions.empty()) { - builder.AppendQueryParameter("sp", Details::UrlEncodeQueryParameter(Permissions)); + builder.AppendQueryParameter("sp", Storage::Details::UrlEncodeQueryParameter(Permissions)); } - builder.AppendQueryParameter("sig", Details::UrlEncodeQueryParameter(signature)); + builder.AppendQueryParameter("sig", Storage::Details::UrlEncodeQueryParameter(signature)); if (!CacheControl.empty()) { - builder.AppendQueryParameter("rscc", Details::UrlEncodeQueryParameter(CacheControl)); + builder.AppendQueryParameter("rscc", Storage::Details::UrlEncodeQueryParameter(CacheControl)); } if (!ContentDisposition.empty()) { - builder.AppendQueryParameter("rscd", Details::UrlEncodeQueryParameter(ContentDisposition)); + builder.AppendQueryParameter( + "rscd", Storage::Details::UrlEncodeQueryParameter(ContentDisposition)); } if (!ContentEncoding.empty()) { - builder.AppendQueryParameter("rsce", Details::UrlEncodeQueryParameter(ContentEncoding)); + builder.AppendQueryParameter( + "rsce", Storage::Details::UrlEncodeQueryParameter(ContentEncoding)); } if (!ContentLanguage.empty()) { - builder.AppendQueryParameter("rscl", Details::UrlEncodeQueryParameter(ContentLanguage)); + builder.AppendQueryParameter( + "rscl", Storage::Details::UrlEncodeQueryParameter(ContentLanguage)); } if (!ContentType.empty()) { - builder.AppendQueryParameter("rsct", Details::UrlEncodeQueryParameter(ContentType)); + builder.AppendQueryParameter("rsct", Storage::Details::UrlEncodeQueryParameter(ContentType)); } return builder.GetAbsoluteUrl(); @@ -218,56 +223,61 @@ namespace Azure { namespace Storage { namespace Blobs { + resource + "\n" + snapshotVersion + "\n" + CacheControl + "\n" + ContentDisposition + "\n" + ContentEncoding + "\n" + ContentLanguage + "\n" + ContentType; - std::string signature - = Base64Encode(Details::HmacSha256(stringToSign, Base64Decode(userDelegationKey.Value))); + std::string signature = Base64Encode( + Storage::Details::HmacSha256(stringToSign, Base64Decode(userDelegationKey.Value))); Azure::Core::Http::Url builder; - builder.AppendQueryParameter("sv", Details::UrlEncodeQueryParameter(Version)); - builder.AppendQueryParameter("sr", Details::UrlEncodeQueryParameter(resource)); + builder.AppendQueryParameter("sv", Storage::Details::UrlEncodeQueryParameter(Version)); + builder.AppendQueryParameter("sr", Storage::Details::UrlEncodeQueryParameter(resource)); if (StartsOn.HasValue()) { - builder.AppendQueryParameter("st", Details::UrlEncodeQueryParameter(StartsOn.GetValue())); + builder.AppendQueryParameter( + "st", Storage::Details::UrlEncodeQueryParameter(StartsOn.GetValue())); } - builder.AppendQueryParameter("se", Details::UrlEncodeQueryParameter(ExpiresOn)); - builder.AppendQueryParameter("sp", Details::UrlEncodeQueryParameter(Permissions)); + builder.AppendQueryParameter("se", Storage::Details::UrlEncodeQueryParameter(ExpiresOn)); + builder.AppendQueryParameter("sp", Storage::Details::UrlEncodeQueryParameter(Permissions)); if (IPRange.HasValue()) { - builder.AppendQueryParameter("sip", Details::UrlEncodeQueryParameter(IPRange.GetValue())); + builder.AppendQueryParameter( + "sip", Storage::Details::UrlEncodeQueryParameter(IPRange.GetValue())); } - builder.AppendQueryParameter("spr", Details::UrlEncodeQueryParameter(protocol)); + builder.AppendQueryParameter("spr", Storage::Details::UrlEncodeQueryParameter(protocol)); builder.AppendQueryParameter( - "skoid", Details::UrlEncodeQueryParameter(userDelegationKey.SignedObjectId)); + "skoid", Storage::Details::UrlEncodeQueryParameter(userDelegationKey.SignedObjectId)); builder.AppendQueryParameter( - "sktid", Details::UrlEncodeQueryParameter(userDelegationKey.SignedTenantId)); + "sktid", Storage::Details::UrlEncodeQueryParameter(userDelegationKey.SignedTenantId)); builder.AppendQueryParameter( - "skt", Details::UrlEncodeQueryParameter(userDelegationKey.SignedStartsOn)); + "skt", Storage::Details::UrlEncodeQueryParameter(userDelegationKey.SignedStartsOn)); builder.AppendQueryParameter( - "ske", Details::UrlEncodeQueryParameter(userDelegationKey.SignedExpiresOn)); + "ske", Storage::Details::UrlEncodeQueryParameter(userDelegationKey.SignedExpiresOn)); builder.AppendQueryParameter( - "sks", Details::UrlEncodeQueryParameter(userDelegationKey.SignedService)); + "sks", Storage::Details::UrlEncodeQueryParameter(userDelegationKey.SignedService)); builder.AppendQueryParameter( - "skv", Details::UrlEncodeQueryParameter(userDelegationKey.SignedVersion)); + "skv", Storage::Details::UrlEncodeQueryParameter(userDelegationKey.SignedVersion)); if (!CacheControl.empty()) { - builder.AppendQueryParameter("rscc", Details::UrlEncodeQueryParameter(CacheControl)); + builder.AppendQueryParameter("rscc", Storage::Details::UrlEncodeQueryParameter(CacheControl)); } if (!ContentDisposition.empty()) { - builder.AppendQueryParameter("rscd", Details::UrlEncodeQueryParameter(ContentDisposition)); + builder.AppendQueryParameter( + "rscd", Storage::Details::UrlEncodeQueryParameter(ContentDisposition)); } if (!ContentEncoding.empty()) { - builder.AppendQueryParameter("rsce", Details::UrlEncodeQueryParameter(ContentEncoding)); + builder.AppendQueryParameter( + "rsce", Storage::Details::UrlEncodeQueryParameter(ContentEncoding)); } if (!ContentLanguage.empty()) { - builder.AppendQueryParameter("rscl", Details::UrlEncodeQueryParameter(ContentLanguage)); + builder.AppendQueryParameter( + "rscl", Storage::Details::UrlEncodeQueryParameter(ContentLanguage)); } if (!ContentType.empty()) { - builder.AppendQueryParameter("rsct", Details::UrlEncodeQueryParameter(ContentType)); + builder.AppendQueryParameter("rsct", Storage::Details::UrlEncodeQueryParameter(ContentType)); } - builder.AppendQueryParameter("sig", Details::UrlEncodeQueryParameter(signature)); + builder.AppendQueryParameter("sig", Storage::Details::UrlEncodeQueryParameter(signature)); return builder.GetAbsoluteUrl(); } diff --git a/sdk/storage/azure-storage-blobs/src/blob_service_client.cpp b/sdk/storage/azure-storage-blobs/src/blob_service_client.cpp index 3ccdf77ca..ede5495f0 100644 --- a/sdk/storage/azure-storage-blobs/src/blob_service_client.cpp +++ b/sdk/storage/azure-storage-blobs/src/blob_service_client.cpp @@ -17,7 +17,7 @@ namespace Azure { namespace Storage { namespace Blobs { const std::string& connectionString, const BlobServiceClientOptions& options) { - auto parsedConnectionString = Details::ParseConnectionString(connectionString); + auto parsedConnectionString = Storage::Details::ParseConnectionString(connectionString); auto serviceUri = std::move(parsedConnectionString.BlobServiceUri); if (parsedConnectionString.KeyCredential) @@ -39,7 +39,7 @@ namespace Azure { namespace Storage { namespace Blobs { { std::vector> policies; policies.emplace_back(std::make_unique( - Details::c_BlobServicePackageName, Version::VersionString())); + Storage::Details::c_BlobServicePackageName, Version::VersionString())); policies.emplace_back(std::make_unique()); for (const auto& p : options.PerOperationPolicies) { @@ -64,7 +64,7 @@ namespace Azure { namespace Storage { namespace Blobs { { std::vector> policies; policies.emplace_back(std::make_unique( - Details::c_BlobServicePackageName, Version::VersionString())); + Storage::Details::c_BlobServicePackageName, Version::VersionString())); policies.emplace_back(std::make_unique()); for (const auto& p : options.PerOperationPolicies) { @@ -77,7 +77,7 @@ namespace Azure { namespace Storage { namespace Blobs { } policies.emplace_back(std::make_unique()); policies.emplace_back(std::make_unique( - credential, Details::c_StorageScope)); + credential, Storage::Details::c_StorageScope)); policies.emplace_back(std::make_unique()); m_pipeline = std::make_shared(policies); } @@ -89,7 +89,7 @@ namespace Azure { namespace Storage { namespace Blobs { { std::vector> policies; policies.emplace_back(std::make_unique( - Details::c_BlobServicePackageName, Version::VersionString())); + Storage::Details::c_BlobServicePackageName, Version::VersionString())); policies.emplace_back(std::make_unique()); for (const auto& p : options.PerOperationPolicies) { @@ -109,19 +109,19 @@ namespace Azure { namespace Storage { namespace Blobs { const std::string& containerName) const { auto containerUri = m_serviceUrl; - containerUri.AppendPath(Details::UrlEncodePath(containerName)); + containerUri.AppendPath(Storage::Details::UrlEncodePath(containerName)); return BlobContainerClient(std::move(containerUri), m_pipeline); } Azure::Core::Response BlobServiceClient::ListBlobContainersSegment( const ListContainersSegmentOptions& options) const { - BlobRestClient::Service::ListContainersSegmentOptions protocolLayerOptions; + Details::BlobRestClient::Service::ListContainersSegmentOptions protocolLayerOptions; protocolLayerOptions.Prefix = options.Prefix; protocolLayerOptions.ContinuationToken = options.ContinuationToken; protocolLayerOptions.MaxResults = options.MaxResults; protocolLayerOptions.Include = options.Include; - return BlobRestClient::Service::ListBlobContainers( + return Details::BlobRestClient::Service::ListBlobContainers( options.Context, *m_pipeline, m_serviceUrl, protocolLayerOptions); } @@ -130,10 +130,10 @@ namespace Azure { namespace Storage { namespace Blobs { const std::string& expiresOn, const GetUserDelegationKeyOptions& options) const { - BlobRestClient::Service::GetUserDelegationKeyOptions protocolLayerOptions; + Details::BlobRestClient::Service::GetUserDelegationKeyOptions protocolLayerOptions; protocolLayerOptions.StartsOn = startsOn; protocolLayerOptions.ExpiresOn = expiresOn; - return BlobRestClient::Service::GetUserDelegationKey( + return Details::BlobRestClient::Service::GetUserDelegationKey( options.Context, *m_pipeline, m_serviceUrl, protocolLayerOptions); } @@ -141,33 +141,33 @@ namespace Azure { namespace Storage { namespace Blobs { BlobServiceProperties properties, const SetServicePropertiesOptions& options) const { - BlobRestClient::Service::SetServicePropertiesOptions protocolLayerOptions; + Details::BlobRestClient::Service::SetServicePropertiesOptions protocolLayerOptions; protocolLayerOptions.Properties = std::move(properties); - return BlobRestClient::Service::SetProperties( + return Details::BlobRestClient::Service::SetProperties( options.Context, *m_pipeline, m_serviceUrl, protocolLayerOptions); } Azure::Core::Response BlobServiceClient::GetProperties( const GetServicePropertiesOptions& options) const { - BlobRestClient::Service::GetServicePropertiesOptions protocolLayerOptions; - return BlobRestClient::Service::GetProperties( + Details::BlobRestClient::Service::GetServicePropertiesOptions protocolLayerOptions; + return Details::BlobRestClient::Service::GetProperties( options.Context, *m_pipeline, m_serviceUrl, protocolLayerOptions); } Azure::Core::Response BlobServiceClient::GetAccountInfo( const GetAccountInfoOptions& options) const { - BlobRestClient::Service::GetAccountInfoOptions protocolLayerOptions; - return BlobRestClient::Service::GetAccountInfo( + Details::BlobRestClient::Service::GetAccountInfoOptions protocolLayerOptions; + return Details::BlobRestClient::Service::GetAccountInfo( options.Context, *m_pipeline, m_serviceUrl, protocolLayerOptions); } Azure::Core::Response BlobServiceClient::GetStatistics( const GetBlobServiceStatisticsOptions& options) const { - BlobRestClient::Service::GetServiceStatisticsOptions protocolLayerOptions; - return BlobRestClient::Service::GetStatistics( + Details::BlobRestClient::Service::GetServiceStatisticsOptions protocolLayerOptions; + return Details::BlobRestClient::Service::GetStatistics( options.Context, *m_pipeline, m_serviceUrl, protocolLayerOptions); } @@ -175,11 +175,11 @@ namespace Azure { namespace Storage { namespace Blobs { const std::string& tagFilterSqlExpression, const FindBlobsByTagsOptions& options) const { - BlobRestClient::Service::FilterBlobsSegmentOptions protocolLayerOptions; + Details::BlobRestClient::Service::FilterBlobsSegmentOptions protocolLayerOptions; protocolLayerOptions.Where = tagFilterSqlExpression; protocolLayerOptions.ContinuationToken = options.ContinuationToken; protocolLayerOptions.MaxResults = options.MaxResults; - return BlobRestClient::Service::FilterBlobs( + return Details::BlobRestClient::Service::FilterBlobs( options.Context, *m_pipeline, m_serviceUrl, protocolLayerOptions); } diff --git a/sdk/storage/azure-storage-blobs/src/block_blob_client.cpp b/sdk/storage/azure-storage-blobs/src/block_blob_client.cpp index cecced55e..35e4f7c9b 100644 --- a/sdk/storage/azure-storage-blobs/src/block_blob_client.cpp +++ b/sdk/storage/azure-storage-blobs/src/block_blob_client.cpp @@ -52,12 +52,13 @@ namespace Azure { namespace Storage { namespace Blobs { BlockBlobClient newClient(*this); if (snapshot.empty()) { - newClient.m_blobUrl.RemoveQueryParameter(Details::c_HttpQuerySnapshot); + newClient.m_blobUrl.RemoveQueryParameter(Storage::Details::c_HttpQuerySnapshot); } else { newClient.m_blobUrl.AppendQueryParameter( - Details::c_HttpQuerySnapshot, Details::UrlEncodeQueryParameter(snapshot)); + Storage::Details::c_HttpQuerySnapshot, + Storage::Details::UrlEncodeQueryParameter(snapshot)); } return newClient; } @@ -67,12 +68,13 @@ namespace Azure { namespace Storage { namespace Blobs { BlockBlobClient newClient(*this); if (versionId.empty()) { - newClient.m_blobUrl.RemoveQueryParameter(Details::c_HttpQueryVersionId); + newClient.m_blobUrl.RemoveQueryParameter(Storage::Details::c_HttpQueryVersionId); } else { newClient.m_blobUrl.AppendQueryParameter( - Details::c_HttpQueryVersionId, Details::UrlEncodeQueryParameter(versionId)); + Storage::Details::c_HttpQueryVersionId, + Storage::Details::UrlEncodeQueryParameter(versionId)); } return newClient; } @@ -81,7 +83,7 @@ namespace Azure { namespace Storage { namespace Blobs { Azure::Core::Http::BodyStream* content, const UploadBlockBlobOptions& options) const { - BlobRestClient::BlockBlob::UploadBlockBlobOptions protocolLayerOptions; + Details::BlobRestClient::BlockBlob::UploadBlockBlobOptions protocolLayerOptions; protocolLayerOptions.TransactionalContentMd5 = options.TransactionalContentMd5; protocolLayerOptions.TransactionalContentCrc64 = options.TransactionalContentCrc64; protocolLayerOptions.HttpHeaders = options.HttpHeaders; @@ -100,7 +102,7 @@ namespace Azure { namespace Storage { namespace Blobs { protocolLayerOptions.EncryptionAlgorithm = m_customerProvidedKey.GetValue().Algorithm; } protocolLayerOptions.EncryptionScope = m_encryptionScope; - return BlobRestClient::BlockBlob::Upload( + return Details::BlobRestClient::BlockBlob::Upload( options.Context, *m_pipeline, m_blobUrl, content, protocolLayerOptions); } @@ -155,7 +157,8 @@ namespace Azure { namespace Storage { namespace Blobs { } }; - Details::ConcurrentTransfer(0, bufferSize, chunkSize, options.Concurrency, uploadBlockFunc); + Storage::Details::ConcurrentTransfer( + 0, bufferSize, chunkSize, options.Concurrency, uploadBlockFunc); for (std::size_t i = 0; i < blockIds.size(); ++i) { @@ -190,7 +193,7 @@ namespace Azure { namespace Storage { namespace Blobs { constexpr int64_t c_maximumNumberBlocks = 50000; constexpr int64_t c_grainSize = 4 * 1024; - Details::FileReader fileReader(file); + Storage::Details::FileReader fileReader(file); int64_t chunkSize = c_defaultBlockSize; if (options.ChunkSize.HasValue()) @@ -236,7 +239,7 @@ namespace Azure { namespace Storage { namespace Blobs { } }; - Details::ConcurrentTransfer( + Storage::Details::ConcurrentTransfer( 0, fileReader.GetFileSize(), chunkSize, options.Concurrency, uploadBlockFunc); for (std::size_t i = 0; i < blockIds.size(); ++i) @@ -269,7 +272,7 @@ namespace Azure { namespace Storage { namespace Blobs { Azure::Core::Http::BodyStream* content, const StageBlockOptions& options) const { - BlobRestClient::BlockBlob::StageBlockOptions protocolLayerOptions; + Details::BlobRestClient::BlockBlob::StageBlockOptions protocolLayerOptions; protocolLayerOptions.BlockId = blockId; protocolLayerOptions.TransactionalContentMd5 = options.TransactionalContentMd5; protocolLayerOptions.TransactionalContentCrc64 = options.TransactionalContentCrc64; @@ -281,7 +284,7 @@ namespace Azure { namespace Storage { namespace Blobs { protocolLayerOptions.EncryptionAlgorithm = m_customerProvidedKey.GetValue().Algorithm; } protocolLayerOptions.EncryptionScope = m_encryptionScope; - return BlobRestClient::BlockBlob::StageBlock( + return Details::BlobRestClient::BlockBlob::StageBlock( options.Context, *m_pipeline, m_blobUrl, content, protocolLayerOptions); } @@ -290,7 +293,7 @@ namespace Azure { namespace Storage { namespace Blobs { const std::string& sourceUri, const StageBlockFromUriOptions& options) const { - BlobRestClient::BlockBlob::StageBlockFromUriOptions protocolLayerOptions; + Details::BlobRestClient::BlockBlob::StageBlockFromUriOptions protocolLayerOptions; protocolLayerOptions.BlockId = blockId; protocolLayerOptions.SourceUri = sourceUri; if (options.SourceOffset.HasValue() && options.SourceLength.HasValue()) @@ -320,7 +323,7 @@ namespace Azure { namespace Storage { namespace Blobs { protocolLayerOptions.EncryptionAlgorithm = m_customerProvidedKey.GetValue().Algorithm; } protocolLayerOptions.EncryptionScope = m_encryptionScope; - return BlobRestClient::BlockBlob::StageBlockFromUri( + return Details::BlobRestClient::BlockBlob::StageBlockFromUri( options.Context, *m_pipeline, m_blobUrl, protocolLayerOptions); } @@ -328,7 +331,7 @@ namespace Azure { namespace Storage { namespace Blobs { const std::vector>& blockIds, const CommitBlockListOptions& options) const { - BlobRestClient::BlockBlob::CommitBlockListOptions protocolLayerOptions; + Details::BlobRestClient::BlockBlob::CommitBlockListOptions protocolLayerOptions; protocolLayerOptions.BlockList = blockIds; protocolLayerOptions.HttpHeaders = options.HttpHeaders; protocolLayerOptions.Metadata = options.Metadata; @@ -346,18 +349,18 @@ namespace Azure { namespace Storage { namespace Blobs { protocolLayerOptions.EncryptionAlgorithm = m_customerProvidedKey.GetValue().Algorithm; } protocolLayerOptions.EncryptionScope = m_encryptionScope; - return BlobRestClient::BlockBlob::CommitBlockList( + return Details::BlobRestClient::BlockBlob::CommitBlockList( options.Context, *m_pipeline, m_blobUrl, protocolLayerOptions); } Azure::Core::Response BlockBlobClient::GetBlockList( const GetBlockListOptions& options) const { - BlobRestClient::BlockBlob::GetBlockListOptions protocolLayerOptions; + Details::BlobRestClient::BlockBlob::GetBlockListOptions protocolLayerOptions; protocolLayerOptions.ListType = options.ListType; protocolLayerOptions.LeaseId = options.AccessConditions.LeaseId; protocolLayerOptions.IfTags = options.AccessConditions.TagConditions; - return BlobRestClient::BlockBlob::GetBlockList( + return Details::BlobRestClient::BlockBlob::GetBlockList( options.Context, *m_pipeline, m_blobUrl, protocolLayerOptions); } diff --git a/sdk/storage/azure-storage-blobs/src/page_blob_client.cpp b/sdk/storage/azure-storage-blobs/src/page_blob_client.cpp index d9bcd4189..19de6699c 100644 --- a/sdk/storage/azure-storage-blobs/src/page_blob_client.cpp +++ b/sdk/storage/azure-storage-blobs/src/page_blob_client.cpp @@ -49,12 +49,13 @@ namespace Azure { namespace Storage { namespace Blobs { PageBlobClient newClient(*this); if (snapshot.empty()) { - newClient.m_blobUrl.RemoveQueryParameter(Details::c_HttpQuerySnapshot); + newClient.m_blobUrl.RemoveQueryParameter(Storage::Details::c_HttpQuerySnapshot); } else { newClient.m_blobUrl.AppendQueryParameter( - Details::c_HttpQuerySnapshot, Details::UrlEncodeQueryParameter(snapshot)); + Storage::Details::c_HttpQuerySnapshot, + Storage::Details::UrlEncodeQueryParameter(snapshot)); } return newClient; } @@ -64,12 +65,13 @@ namespace Azure { namespace Storage { namespace Blobs { PageBlobClient newClient(*this); if (versionId.empty()) { - newClient.m_blobUrl.RemoveQueryParameter(Details::c_HttpQueryVersionId); + newClient.m_blobUrl.RemoveQueryParameter(Storage::Details::c_HttpQueryVersionId); } else { newClient.m_blobUrl.AppendQueryParameter( - Details::c_HttpQueryVersionId, Details::UrlEncodeQueryParameter(versionId)); + Storage::Details::c_HttpQueryVersionId, + Storage::Details::UrlEncodeQueryParameter(versionId)); } return newClient; } @@ -78,7 +80,7 @@ namespace Azure { namespace Storage { namespace Blobs { int64_t blobContentLength, const CreatePageBlobOptions& options) const { - BlobRestClient::PageBlob::CreatePageBlobOptions protocolLayerOptions; + Details::BlobRestClient::PageBlob::CreatePageBlobOptions protocolLayerOptions; protocolLayerOptions.BlobContentLength = blobContentLength; protocolLayerOptions.SequenceNumber = options.SequenceNumber; protocolLayerOptions.HttpHeaders = options.HttpHeaders; @@ -97,7 +99,7 @@ namespace Azure { namespace Storage { namespace Blobs { protocolLayerOptions.EncryptionAlgorithm = m_customerProvidedKey.GetValue().Algorithm; } protocolLayerOptions.EncryptionScope = m_encryptionScope; - return BlobRestClient::PageBlob::Create( + return Details::BlobRestClient::PageBlob::Create( options.Context, *m_pipeline, m_blobUrl, protocolLayerOptions); } @@ -106,7 +108,7 @@ namespace Azure { namespace Storage { namespace Blobs { Azure::Core::Http::BodyStream* content, const UploadPageBlobPagesOptions& options) const { - BlobRestClient::PageBlob::UploadPageBlobPagesOptions protocolLayerOptions; + Details::BlobRestClient::PageBlob::UploadPageBlobPagesOptions protocolLayerOptions; protocolLayerOptions.Range = std::make_pair(offset, offset + content->Length() - 1); protocolLayerOptions.TransactionalContentMd5 = options.TransactionalContentMd5; protocolLayerOptions.TransactionalContentCrc64 = options.TransactionalContentCrc64; @@ -123,7 +125,7 @@ namespace Azure { namespace Storage { namespace Blobs { protocolLayerOptions.EncryptionAlgorithm = m_customerProvidedKey.GetValue().Algorithm; } protocolLayerOptions.EncryptionScope = m_encryptionScope; - return BlobRestClient::PageBlob::UploadPages( + return Details::BlobRestClient::PageBlob::UploadPages( options.Context, *m_pipeline, m_blobUrl, content, protocolLayerOptions); } @@ -134,7 +136,7 @@ namespace Azure { namespace Storage { namespace Blobs { int64_t sourceLength, const UploadPageBlobPagesFromUriOptions& options) const { - BlobRestClient::PageBlob::UploadPageBlobPagesFromUriOptions protocolLayerOptions; + Details::BlobRestClient::PageBlob::UploadPageBlobPagesFromUriOptions protocolLayerOptions; protocolLayerOptions.SourceUri = sourceUri; protocolLayerOptions.SourceRange = std::make_pair(sourceOffset, sourceOffset + sourceLength - 1); @@ -155,7 +157,7 @@ namespace Azure { namespace Storage { namespace Blobs { protocolLayerOptions.EncryptionAlgorithm = m_customerProvidedKey.GetValue().Algorithm; } protocolLayerOptions.EncryptionScope = m_encryptionScope; - return BlobRestClient::PageBlob::UploadPagesFromUri( + return Details::BlobRestClient::PageBlob::UploadPagesFromUri( options.Context, *m_pipeline, m_blobUrl, protocolLayerOptions); } @@ -164,7 +166,7 @@ namespace Azure { namespace Storage { namespace Blobs { int64_t length, const ClearPageBlobPagesOptions& options) const { - BlobRestClient::PageBlob::ClearPageBlobPagesOptions protocolLayerOptions; + Details::BlobRestClient::PageBlob::ClearPageBlobPagesOptions protocolLayerOptions; protocolLayerOptions.Range = std::make_pair(offset, offset + length - 1); protocolLayerOptions.LeaseId = options.AccessConditions.LeaseId; protocolLayerOptions.IfModifiedSince = options.AccessConditions.IfModifiedSince; @@ -179,7 +181,7 @@ namespace Azure { namespace Storage { namespace Blobs { protocolLayerOptions.EncryptionAlgorithm = m_customerProvidedKey.GetValue().Algorithm; } protocolLayerOptions.EncryptionScope = m_encryptionScope; - return BlobRestClient::PageBlob::ClearPages( + return Details::BlobRestClient::PageBlob::ClearPages( options.Context, *m_pipeline, m_blobUrl, protocolLayerOptions); } @@ -187,7 +189,7 @@ namespace Azure { namespace Storage { namespace Blobs { int64_t blobContentLength, const ResizePageBlobOptions& options) const { - BlobRestClient::PageBlob::ResizePageBlobOptions protocolLayerOptions; + Details::BlobRestClient::PageBlob::ResizePageBlobOptions protocolLayerOptions; protocolLayerOptions.BlobContentLength = blobContentLength; protocolLayerOptions.LeaseId = options.AccessConditions.LeaseId; protocolLayerOptions.IfModifiedSince = options.AccessConditions.IfModifiedSince; @@ -202,14 +204,14 @@ namespace Azure { namespace Storage { namespace Blobs { protocolLayerOptions.EncryptionAlgorithm = m_customerProvidedKey.GetValue().Algorithm; } protocolLayerOptions.EncryptionScope = m_encryptionScope; - return BlobRestClient::PageBlob::Resize( + return Details::BlobRestClient::PageBlob::Resize( options.Context, *m_pipeline, m_blobUrl, protocolLayerOptions); } Azure::Core::Response PageBlobClient::GetPageRanges( const GetPageBlobPageRangesOptions& options) const { - BlobRestClient::PageBlob::GetPageBlobPageRangesOptions protocolLayerOptions; + Details::BlobRestClient::PageBlob::GetPageBlobPageRangesOptions protocolLayerOptions; protocolLayerOptions.PreviousSnapshot = options.PreviousSnapshot; protocolLayerOptions.PreviousSnapshotUrl = options.PreviousSnapshotUrl; if (options.Offset.HasValue() && options.Length.HasValue()) @@ -223,7 +225,7 @@ namespace Azure { namespace Storage { namespace Blobs { protocolLayerOptions.IfMatch = options.AccessConditions.IfMatch; protocolLayerOptions.IfNoneMatch = options.AccessConditions.IfNoneMatch; protocolLayerOptions.IfTags = options.AccessConditions.TagConditions; - auto protocolLayerResponse = BlobRestClient::PageBlob::GetPageRanges( + auto protocolLayerResponse = Details::BlobRestClient::PageBlob::GetPageRanges( options.Context, *m_pipeline, m_blobUrl, protocolLayerOptions); GetPageBlobPageRangesResult ret; @@ -248,14 +250,14 @@ namespace Azure { namespace Storage { namespace Blobs { const std::string& sourceUri, const StartCopyPageBlobIncrementalOptions& options) const { - BlobRestClient::PageBlob::StartCopyPageBlobIncrementalOptions protocolLayerOptions; + Details::BlobRestClient::PageBlob::StartCopyPageBlobIncrementalOptions protocolLayerOptions; protocolLayerOptions.CopySource = sourceUri; protocolLayerOptions.IfModifiedSince = options.AccessConditions.IfModifiedSince; protocolLayerOptions.IfUnmodifiedSince = options.AccessConditions.IfUnmodifiedSince; protocolLayerOptions.IfMatch = options.AccessConditions.IfMatch; protocolLayerOptions.IfNoneMatch = options.AccessConditions.IfNoneMatch; protocolLayerOptions.IfTags = options.AccessConditions.TagConditions; - return BlobRestClient::PageBlob::StartCopyIncremental( + return Details::BlobRestClient::PageBlob::StartCopyIncremental( options.Context, *m_pipeline, m_blobUrl, protocolLayerOptions); } diff --git a/sdk/storage/azure-storage-blobs/test/blob_service_client_test.cpp b/sdk/storage/azure-storage-blobs/test/blob_service_client_test.cpp index bfa770513..6896cb6c7 100644 --- a/sdk/storage/azure-storage-blobs/test/blob_service_client_test.cpp +++ b/sdk/storage/azure-storage-blobs/test/blob_service_client_test.cpp @@ -234,7 +234,7 @@ namespace Azure { namespace Storage { namespace Test { properties.MinuteMetrics.RetentionPolicy.Days = 4; properties.MinuteMetrics.IncludeApis = true; - properties.DefaultServiceVersion = Blobs::c_ApiVersion; + properties.DefaultServiceVersion = Blobs::Details::c_ApiVersion; properties.StaticWebsite.Enabled = true; properties.StaticWebsite.IndexDocument = "index.html"; diff --git a/sdk/storage/azure-storage-blobs/test/storage_retry_policy_test.cpp b/sdk/storage/azure-storage-blobs/test/storage_retry_policy_test.cpp index efed4554e..157c6b4bf 100644 --- a/sdk/storage/azure-storage-blobs/test/storage_retry_policy_test.cpp +++ b/sdk/storage/azure-storage-blobs/test/storage_retry_policy_test.cpp @@ -84,7 +84,7 @@ namespace Azure { namespace Storage { namespace Test { response->AddHeader("content-length", std::to_string(errorResponseBody.length())); response->AddHeader("content-type", "application/xml"); response->AddHeader("x-ms-request-id", Core::Uuid::CreateUuid().GetUuidString()); - response->AddHeader("x-ms-version", Blobs::c_ApiVersion); + response->AddHeader("x-ms-version", Blobs::Details::c_ApiVersion); response->AddHeader("x-ms-error-code", "BlobNotFound"); response->AddHeader("date", ToRfc1123(std::chrono::system_clock::now())); return response; @@ -106,7 +106,7 @@ namespace Azure { namespace Storage { namespace Test { response->AddHeader("content-length", std::to_string(errorResponseBody.length())); response->AddHeader("content-type", "application/xml"); response->AddHeader("x-ms-request-id", Core::Uuid::CreateUuid().GetUuidString()); - response->AddHeader("x-ms-version", Blobs::c_ApiVersion); + response->AddHeader("x-ms-version", Blobs::Details::c_ApiVersion); response->AddHeader("x-ms-error-code", "ConditionNotMet"); response->AddHeader("date", ToRfc1123(std::chrono::system_clock::now())); return response; @@ -129,7 +129,7 @@ namespace Azure { namespace Storage { namespace Test { response->AddHeader("etag", m_primaryETag); response->AddHeader("last-modified", "Thu 27 Aug 2001 07:00:00 GMT"); response->AddHeader("x-ms-request-id", Core::Uuid::CreateUuid().GetUuidString()); - response->AddHeader("x-ms-version", Blobs::c_ApiVersion); + response->AddHeader("x-ms-version", Blobs::Details::c_ApiVersion); response->AddHeader("x-ms-creation-time", "Thu 27 Aug 2002 07:00:00 GMT"); response->AddHeader("x-ms-lease-status", "unlocked"); response->AddHeader("x-ms-lease-state", "available"); @@ -156,7 +156,7 @@ namespace Azure { namespace Storage { namespace Test { response->AddHeader("etag", m_secondaryETag); response->AddHeader("last-modified", "Thu 27 Aug 2001 07:00:00 GMT"); response->AddHeader("x-ms-request-id", Core::Uuid::CreateUuid().GetUuidString()); - response->AddHeader("x-ms-version", Blobs::c_ApiVersion); + response->AddHeader("x-ms-version", Blobs::Details::c_ApiVersion); response->AddHeader("x-ms-creation-time", "Thu 27 Aug 2002 07:00:00 GMT"); response->AddHeader("x-ms-lease-status", "unlocked"); response->AddHeader("x-ms-lease-state", "available"); diff --git a/sdk/storage/azure-storage-files-datalake/src/datalake_file_client.cpp b/sdk/storage/azure-storage-files-datalake/src/datalake_file_client.cpp index 6ec5b3588..4d4b25875 100644 --- a/sdk/storage/azure-storage-files-datalake/src/datalake_file_client.cpp +++ b/sdk/storage/azure-storage-files-datalake/src/datalake_file_client.cpp @@ -397,7 +397,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { ScheduleFileExpiryOriginType expiryOrigin, const ScheduleFileDeletionOptions& options) const { - Blobs::BlobRestClient::Blob::SetBlobExpiryOptions protocolLayerOptions; + Blobs::Details::BlobRestClient::Blob::SetBlobExpiryOptions protocolLayerOptions; protocolLayerOptions.ExpiryOrigin = expiryOrigin; if (options.ExpiresOn.HasValue() && options.TimeToExpireInMs.HasValue()) { @@ -411,7 +411,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { { protocolLayerOptions.ExpiryTime = std::to_string(options.TimeToExpireInMs.GetValue()); } - return Blobs::BlobRestClient::Blob::ScheduleDeletion( + return Blobs::Details::BlobRestClient::Blob::ScheduleDeletion( options.Context, *m_pipeline, m_blobClient.m_blobUrl, protocolLayerOptions); }