12 #include <type_traits>
15 #include <azure/core/context.hpp>
16 #include <azure/core/datetime.hpp>
17 #include <azure/core/etag.hpp>
18 #include <azure/core/http/http.hpp>
19 #include <azure/core/internal/http/pipeline.hpp>
20 #include <azure/core/internal/strings.hpp>
21 #include <azure/core/nullable.hpp>
22 #include <azure/core/response.hpp>
23 #include <azure/storage/common/crypt.hpp>
24 #include <azure/storage/common/internal/xml_wrapper.hpp>
25 #include <azure/storage/common/storage_common.hpp>
26 #include <azure/storage/common/storage_exception.hpp>
30 namespace Azure {
namespace Storage {
namespace Blobs {
33 constexpr
static const char* ApiVersion =
"2020-02-10";
44 explicit AccountKind(std::string value) : m_value(std::move(value)) {}
45 bool operator==(
const AccountKind& other)
const {
return m_value == other.m_value; }
46 bool operator!=(
const AccountKind& other)
const {
return !(*
this == other); }
47 const std::string& ToString()
const {
return m_value; }
94 explicit CopyStatus(std::string value) : m_value(std::move(value)) {}
95 bool operator==(
const CopyStatus& other)
const {
return m_value == other.m_value; }
96 bool operator!=(
const CopyStatus& other)
const {
return !(*
this == other); }
97 const std::string& ToString()
const {
return m_value; }
120 const std::string& ToString()
const {
return m_value; }
145 bool operator==(
const LeaseDurationType& other)
const {
return m_value == other.m_value; }
146 bool operator!=(
const LeaseDurationType& other)
const {
return !(*
this == other); }
147 const std::string& ToString()
const {
return m_value; }
167 explicit LeaseState(std::string value) : m_value(std::move(value)) {}
168 bool operator==(
const LeaseState& other)
const {
return m_value == other.m_value; }
169 bool operator!=(
const LeaseState& other)
const {
return !(*
this == other); }
170 const std::string& ToString()
const {
return m_value; }
203 explicit LeaseStatus(std::string value) : m_value(std::move(value)) {}
204 bool operator==(
const LeaseStatus& other)
const {
return m_value == other.m_value; }
205 bool operator!=(
const LeaseStatus& other)
const {
return !(*
this == other); }
206 const std::string& ToString()
const {
return m_value; }
229 return m_value == other.m_value;
232 const std::string& ToString()
const {
return m_value; }
254 bool operator==(
const PublicAccessType& other)
const {
return m_value == other.m_value; }
255 bool operator!=(
const PublicAccessType& other)
const {
return !(*
this == other); }
256 const std::string& ToString()
const {
return m_value; }
323 explicit SkuName(std::string value) : m_value(std::move(value)) {}
324 bool operator==(
const SkuName& other)
const {
return m_value == other.m_value; }
325 bool operator!=(
const SkuName& other)
const {
return !(*
this == other); }
326 const std::string& ToString()
const {
return m_value; }
584 explicit AccessTier(std::string value) : m_value(std::move(value)) {}
585 bool operator==(
const AccessTier& other)
const {
return m_value == other.m_value; }
586 bool operator!=(
const AccessTier& other)
const {
return !(*
this == other); }
587 const std::string& ToString()
const {
return m_value; }
669 explicit ArchiveStatus(std::string value) : m_value(std::move(value)) {}
670 bool operator==(
const ArchiveStatus& other)
const {
return m_value == other.m_value; }
671 bool operator!=(
const ArchiveStatus& other)
const {
return !(*
this == other); }
672 const std::string& ToString()
const {
return m_value; }
748 explicit BlobType(std::string value) : m_value(std::move(value)) {}
749 bool operator==(
const BlobType& other)
const {
return m_value == other.m_value; }
750 bool operator!=(
const BlobType& other)
const {
return !(*
this == other); }
751 const std::string& ToString()
const {
return m_value; }
784 std::vector<ObjectReplicationRule>
Rules;
794 bool operator==(
const RehydratePriority& other)
const {
return m_value == other.m_value; }
795 bool operator!=(
const RehydratePriority& other)
const {
return !(*
this == other); }
796 const std::string& ToString()
const {
return m_value; }
1466 explicit BlockListType(std::string value) : m_value(std::move(value)) {}
1467 bool operator==(
const BlockListType& other)
const {
return m_value == other.m_value; }
1468 bool operator!=(
const BlockListType& other)
const {
return !(*
this == other); }
1469 const std::string& ToString()
const {
return m_value; }
1484 std::string m_value;
1493 explicit BlockType(std::string value) : m_value(std::move(value)) {}
1494 bool operator==(
const BlockType& other)
const {
return m_value == other.m_value; }
1495 bool operator!=(
const BlockType& other)
const {
return !(*
this == other); }
1496 const std::string& ToString()
const {
return m_value; }
1512 std::string m_value;
1643 std::string Snapshot;
1752 const std::string& ToString()
const {
return m_value; }
1763 std::string m_value;
1806 return m_value == other.m_value;
1809 const std::string& ToString()
const {
return m_value; }
1816 std::string m_value;
1848 enum class ListBlobContainersIncludeFlags
1864 inline ListBlobContainersIncludeFlags operator|(
1865 ListBlobContainersIncludeFlags lhs,
1866 ListBlobContainersIncludeFlags rhs)
1868 using type = std::underlying_type_t<ListBlobContainersIncludeFlags>;
1869 return static_cast<ListBlobContainersIncludeFlags
>(
1870 static_cast<type
>(lhs) |
static_cast<type
>(rhs));
1873 inline ListBlobContainersIncludeFlags& operator|=(
1874 ListBlobContainersIncludeFlags& lhs,
1875 ListBlobContainersIncludeFlags rhs)
1881 inline ListBlobContainersIncludeFlags operator&(
1882 ListBlobContainersIncludeFlags lhs,
1883 ListBlobContainersIncludeFlags rhs)
1885 using type = std::underlying_type_t<ListBlobContainersIncludeFlags>;
1886 return static_cast<ListBlobContainersIncludeFlags
>(
1887 static_cast<type
>(lhs) &
static_cast<type
>(rhs));
1890 inline ListBlobContainersIncludeFlags& operator&=(
1891 ListBlobContainersIncludeFlags& lhs,
1892 ListBlobContainersIncludeFlags rhs)
1898 enum class ListBlobsIncludeFlags
1927 UncomittedBlobs = 32,
1930 inline ListBlobsIncludeFlags operator|(ListBlobsIncludeFlags lhs, ListBlobsIncludeFlags rhs)
1932 using type = std::underlying_type_t<ListBlobsIncludeFlags>;
1933 return static_cast<ListBlobsIncludeFlags
>(
static_cast<type
>(lhs) |
static_cast<type
>(rhs));
1936 inline ListBlobsIncludeFlags& operator|=(ListBlobsIncludeFlags& lhs, ListBlobsIncludeFlags rhs)
1942 inline ListBlobsIncludeFlags operator&(ListBlobsIncludeFlags lhs, ListBlobsIncludeFlags rhs)
1944 using type = std::underlying_type_t<ListBlobsIncludeFlags>;
1945 return static_cast<ListBlobsIncludeFlags
>(
static_cast<type
>(lhs) &
static_cast<type
>(rhs));
1948 inline ListBlobsIncludeFlags& operator&=(ListBlobsIncludeFlags& lhs, ListBlobsIncludeFlags rhs)
1985 return m_value == other.m_value;
1988 const std::string& ToString()
const {
return m_value; }
2007 std::string m_value;
2362 struct AcquireBlobContainerLeaseResult final
2373 Azure::DateTime LastModified;
2377 std::string LeaseId;
2382 struct AcquireBlobLeaseResult final
2393 Azure::DateTime LastModified;
2397 std::string LeaseId;
2402 struct BreakBlobContainerLeaseResult final
2413 Azure::DateTime LastModified;
2417 int32_t LeaseTime = 0;
2422 struct BreakBlobLeaseResult final
2433 Azure::DateTime LastModified;
2437 int32_t LeaseTime = 0;
2442 struct ChangeBlobContainerLeaseResult final
2453 Azure::DateTime LastModified;
2457 std::string LeaseId;
2462 struct ChangeBlobLeaseResult final
2473 Azure::DateTime LastModified;
2477 std::string LeaseId;
2482 struct FindBlobsByTagsResult final
2484 std::string ServiceEndpoint;
2485 Azure::Nullable<std::string> ContinuationToken;
2486 std::vector<TaggedBlobItem> Items;
2491 struct GetBlobTagsResult final
2493 std::map<std::string, std::string> Tags;
2498 struct GetPageRangesResult final
2509 Azure::DateTime LastModified;
2513 int64_t BlobSize = 0;
2514 std::vector<Azure::Core::Http::HttpRange> PageRanges;
2515 std::vector<Azure::Core::Http::HttpRange> ClearRanges;
2520 struct ListBlobContainersResult final
2522 std::string ServiceEndpoint;
2524 Azure::Nullable<std::string> ContinuationToken;
2525 std::vector<BlobContainerItem> Items;
2530 struct ListBlobsByHierarchyResult final
2532 std::string ServiceEndpoint;
2533 std::string BlobContainerName;
2535 std::string Delimiter;
2536 Azure::Nullable<std::string> ContinuationToken;
2537 std::vector<BlobItem> Items;
2538 std::vector<std::string> BlobPrefixes;
2543 struct ListBlobsResult final
2545 std::string ServiceEndpoint;
2546 std::string BlobContainerName;
2548 Azure::Nullable<std::string> ContinuationToken;
2549 std::vector<BlobItem> Items;
2554 struct ReleaseBlobContainerLeaseResult final
2565 Azure::DateTime LastModified;
2570 struct ReleaseBlobLeaseResult final
2581 Azure::DateTime LastModified;
2586 Azure::Nullable<int64_t> SequenceNumber;
2591 struct RenewBlobContainerLeaseResult final
2602 Azure::DateTime LastModified;
2606 std::string LeaseId;
2611 struct RenewBlobLeaseResult final
2622 Azure::DateTime LastModified;
2626 std::string LeaseId;
2631 struct StartBlobCopyFromUriResult final
2642 Azure::DateTime LastModified;
2655 Models::CopyStatus CopyStatus;
2660 Azure::Nullable<std::string> VersionId;
2665 struct StartBlobCopyIncrementalResult final
2676 Azure::DateTime LastModified;
2689 Models::CopyStatus CopyStatus;
2694 Azure::Nullable<std::string> VersionId;
2699 struct SubmitBlobBatchResult final
2701 std::string ContentType;
2706 struct UndeleteBlobContainerResult final
2715 using namespace Models;
2717 inline std::string ListBlobContainersIncludeFlagsToString(
2718 const ListBlobContainersIncludeFlags& val)
2720 ListBlobContainersIncludeFlags value_list[] = {
2721 ListBlobContainersIncludeFlags::Metadata,
2722 ListBlobContainersIncludeFlags::Deleted,
2724 const char* string_list[] = {
2729 for (
size_t i = 0; i <
sizeof(value_list) /
sizeof(ListBlobContainersIncludeFlags); ++i)
2731 if ((val & value_list[i]) == value_list[i])
2737 ret += string_list[i];
2743 inline std::string ListBlobsIncludeFlagsToString(
const ListBlobsIncludeFlags& val)
2745 ListBlobsIncludeFlags value_list[] = {
2746 ListBlobsIncludeFlags::Copy,
2747 ListBlobsIncludeFlags::Deleted,
2748 ListBlobsIncludeFlags::Metadata,
2749 ListBlobsIncludeFlags::Snapshots,
2750 ListBlobsIncludeFlags::Versions,
2751 ListBlobsIncludeFlags::UncomittedBlobs,
2753 const char* string_list[] = {
2762 for (
size_t i = 0; i <
sizeof(value_list) /
sizeof(ListBlobsIncludeFlags); ++i)
2764 if ((val & value_list[i]) == value_list[i])
2770 ret += string_list[i];
2776 class BlobRestClient final {
2778 class Service final {
2780 struct ListBlobContainersOptions final
2782 Azure::Nullable<int32_t> Timeout;
2783 Azure::Nullable<std::string> Prefix;
2784 Azure::Nullable<std::string> ContinuationToken;
2785 Azure::Nullable<int32_t> MaxResults;
2786 ListBlobContainersIncludeFlags Include = ListBlobContainersIncludeFlags::None;
2789 static Azure::Response<Models::_detail::ListBlobContainersResult> ListBlobContainers(
2790 Azure::Core::Http::_internal::HttpPipeline& pipeline,
2791 const Azure::Core::Url& url,
2792 const ListBlobContainersOptions& options,
2793 const Azure::Core::Context& context)
2796 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url);
2797 request.SetHeader(
"x-ms-version",
"2020-02-10");
2798 if (options.Timeout.HasValue())
2800 request.GetUrl().AppendQueryParameter(
2801 "timeout", std::to_string(options.Timeout.Value()));
2803 request.GetUrl().AppendQueryParameter(
"comp",
"list");
2804 if (options.Prefix.HasValue())
2806 request.GetUrl().AppendQueryParameter(
2807 "prefix", _internal::UrlEncodeQueryParameter(options.Prefix.Value()));
2809 if (options.ContinuationToken.HasValue())
2811 request.GetUrl().AppendQueryParameter(
2812 "marker", _internal::UrlEncodeQueryParameter(options.ContinuationToken.Value()));
2814 if (options.MaxResults.HasValue())
2816 request.GetUrl().AppendQueryParameter(
2817 "maxresults", std::to_string(options.MaxResults.Value()));
2819 std::string list_blob_containers_include_flags
2820 = ListBlobContainersIncludeFlagsToString(options.Include);
2821 if (!list_blob_containers_include_flags.empty())
2823 request.GetUrl().AppendQueryParameter(
2824 "include", _internal::UrlEncodeQueryParameter(list_blob_containers_include_flags));
2826 auto pHttpResponse = pipeline.Send(request, context);
2827 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
2828 Models::_detail::ListBlobContainersResult response;
2829 auto http_status_code
2830 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
2831 httpResponse.GetStatusCode());
2832 if (!(http_status_code == 200))
2834 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
2837 const auto& httpResponseBody = httpResponse.GetBody();
2838 _internal::XmlReader reader(
2839 reinterpret_cast<const char*
>(httpResponseBody.data()), httpResponseBody.size());
2840 response = ListBlobContainersResultInternalFromXml(reader);
2842 return Azure::Response<Models::_detail::ListBlobContainersResult>(
2843 std::move(response), std::move(pHttpResponse));
2846 struct GetUserDelegationKeyOptions final
2848 Azure::Nullable<int32_t> Timeout;
2849 Azure::DateTime StartsOn;
2850 Azure::DateTime ExpiresOn;
2853 static Azure::Response<UserDelegationKey> GetUserDelegationKey(
2854 Azure::Core::Http::_internal::HttpPipeline& pipeline,
2855 const Azure::Core::Url& url,
2856 const GetUserDelegationKeyOptions& options,
2857 const Azure::Core::Context& context)
2860 std::string xml_body;
2862 _internal::XmlWriter writer;
2863 GetUserDelegationKeyOptionsToXml(writer, options);
2864 xml_body = writer.GetDocument();
2865 writer.Write(_internal::XmlNode{_internal::XmlNodeType::End});
2867 Azure::Core::IO::MemoryBodyStream xml_body_stream(
2868 reinterpret_cast<const uint8_t*
>(xml_body.data()), xml_body.length());
2869 auto request = Azure::Core::Http::Request(
2870 Azure::Core::Http::HttpMethod::Post, url, &xml_body_stream);
2871 request.SetHeader(
"Content-Length", std::to_string(xml_body_stream.Length()));
2872 request.GetUrl().AppendQueryParameter(
"restype",
"service");
2873 request.GetUrl().AppendQueryParameter(
"comp",
"userdelegationkey");
2874 request.SetHeader(
"x-ms-version",
"2020-02-10");
2875 if (options.Timeout.HasValue())
2877 request.GetUrl().AppendQueryParameter(
2878 "timeout", std::to_string(options.Timeout.Value()));
2880 auto pHttpResponse = pipeline.Send(request, context);
2881 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
2882 UserDelegationKey response;
2883 auto http_status_code
2884 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
2885 httpResponse.GetStatusCode());
2886 if (!(http_status_code == 200))
2888 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
2891 const auto& httpResponseBody = httpResponse.GetBody();
2892 _internal::XmlReader reader(
2893 reinterpret_cast<const char*
>(httpResponseBody.data()), httpResponseBody.size());
2894 response = UserDelegationKeyFromXml(reader);
2896 return Azure::Response<UserDelegationKey>(std::move(response), std::move(pHttpResponse));
2899 struct GetServicePropertiesOptions final
2901 Azure::Nullable<int32_t> Timeout;
2904 static Azure::Response<BlobServiceProperties> GetProperties(
2905 Azure::Core::Http::_internal::HttpPipeline& pipeline,
2906 const Azure::Core::Url& url,
2907 const GetServicePropertiesOptions& options,
2908 const Azure::Core::Context& context)
2911 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url);
2912 request.GetUrl().AppendQueryParameter(
"restype",
"service");
2913 request.GetUrl().AppendQueryParameter(
"comp",
"properties");
2914 request.SetHeader(
"x-ms-version",
"2020-02-10");
2915 if (options.Timeout.HasValue())
2917 request.GetUrl().AppendQueryParameter(
2918 "timeout", std::to_string(options.Timeout.Value()));
2920 auto pHttpResponse = pipeline.Send(request, context);
2921 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
2922 BlobServiceProperties response;
2923 auto http_status_code
2924 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
2925 httpResponse.GetStatusCode());
2926 if (!(http_status_code == 200))
2928 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
2931 const auto& httpResponseBody = httpResponse.GetBody();
2932 _internal::XmlReader reader(
2933 reinterpret_cast<const char*
>(httpResponseBody.data()), httpResponseBody.size());
2934 response = BlobServicePropertiesFromXml(reader);
2936 return Azure::Response<BlobServiceProperties>(
2937 std::move(response), std::move(pHttpResponse));
2940 struct SetServicePropertiesOptions final
2942 Azure::Nullable<int32_t> Timeout;
2943 BlobServiceProperties Properties;
2946 static Azure::Response<SetServicePropertiesResult> SetProperties(
2947 Azure::Core::Http::_internal::HttpPipeline& pipeline,
2948 const Azure::Core::Url& url,
2949 const SetServicePropertiesOptions& options,
2950 const Azure::Core::Context& context)
2953 std::string xml_body;
2955 _internal::XmlWriter writer;
2956 SetServicePropertiesOptionsToXml(writer, options);
2957 xml_body = writer.GetDocument();
2958 writer.Write(_internal::XmlNode{_internal::XmlNodeType::End});
2960 Azure::Core::IO::MemoryBodyStream xml_body_stream(
2961 reinterpret_cast<const uint8_t*
>(xml_body.data()), xml_body.length());
2962 auto request = Azure::Core::Http::Request(
2963 Azure::Core::Http::HttpMethod::Put, url, &xml_body_stream);
2964 request.SetHeader(
"Content-Length", std::to_string(xml_body_stream.Length()));
2965 request.GetUrl().AppendQueryParameter(
"restype",
"service");
2966 request.GetUrl().AppendQueryParameter(
"comp",
"properties");
2967 request.SetHeader(
"x-ms-version",
"2020-02-10");
2968 if (options.Timeout.HasValue())
2970 request.GetUrl().AppendQueryParameter(
2971 "timeout", std::to_string(options.Timeout.Value()));
2973 auto pHttpResponse = pipeline.Send(request, context);
2974 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
2975 SetServicePropertiesResult response;
2976 auto http_status_code
2977 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
2978 httpResponse.GetStatusCode());
2979 if (!(http_status_code == 202))
2981 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
2983 return Azure::Response<SetServicePropertiesResult>(
2984 std::move(response), std::move(pHttpResponse));
2987 struct GetAccountInfoOptions final
2989 Azure::Nullable<int32_t> Timeout;
2992 static Azure::Response<AccountInfo> GetAccountInfo(
2993 Azure::Core::Http::_internal::HttpPipeline& pipeline,
2994 const Azure::Core::Url& url,
2995 const GetAccountInfoOptions& options,
2996 const Azure::Core::Context& context)
2999 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Head, url);
3000 request.GetUrl().AppendQueryParameter(
"restype",
"account");
3001 request.GetUrl().AppendQueryParameter(
"comp",
"properties");
3002 request.SetHeader(
"x-ms-version",
"2020-02-10");
3003 if (options.Timeout.HasValue())
3005 request.GetUrl().AppendQueryParameter(
3006 "timeout", std::to_string(options.Timeout.Value()));
3008 auto pHttpResponse = pipeline.Send(request, context);
3009 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
3010 AccountInfo response;
3011 auto http_status_code
3012 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
3013 httpResponse.GetStatusCode());
3014 if (!(http_status_code == 200))
3016 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
3018 response.SkuName = SkuName(httpResponse.GetHeaders().at(
"x-ms-sku-name"));
3019 response.AccountKind = AccountKind(httpResponse.GetHeaders().at(
"x-ms-account-kind"));
3020 response.IsHierarchicalNamespaceEnabled
3021 = httpResponse.GetHeaders().at(
"x-ms-is-hns-enabled") ==
"true";
3022 return Azure::Response<AccountInfo>(std::move(response), std::move(pHttpResponse));
3025 struct GetServiceStatisticsOptions final
3027 Azure::Nullable<int32_t> Timeout;
3030 static Azure::Response<ServiceStatistics> GetStatistics(
3031 Azure::Core::Http::_internal::HttpPipeline& pipeline,
3032 const Azure::Core::Url& url,
3033 const GetServiceStatisticsOptions& options,
3034 const Azure::Core::Context& context)
3037 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url);
3038 request.GetUrl().AppendQueryParameter(
"restype",
"service");
3039 request.GetUrl().AppendQueryParameter(
"comp",
"stats");
3040 request.SetHeader(
"x-ms-version",
"2020-02-10");
3041 if (options.Timeout.HasValue())
3043 request.GetUrl().AppendQueryParameter(
3044 "timeout", std::to_string(options.Timeout.Value()));
3046 auto pHttpResponse = pipeline.Send(request, context);
3047 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
3048 ServiceStatistics response;
3049 auto http_status_code
3050 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
3051 httpResponse.GetStatusCode());
3052 if (!(http_status_code == 200))
3054 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
3057 const auto& httpResponseBody = httpResponse.GetBody();
3058 _internal::XmlReader reader(
3059 reinterpret_cast<const char*
>(httpResponseBody.data()), httpResponseBody.size());
3060 response = ServiceStatisticsFromXml(reader);
3062 return Azure::Response<ServiceStatistics>(std::move(response), std::move(pHttpResponse));
3065 struct FindBlobsByTagsOptions final
3067 Azure::Nullable<int32_t> Timeout;
3069 Azure::Nullable<std::string> ContinuationToken;
3070 Azure::Nullable<int32_t> MaxResults;
3073 static Azure::Response<Models::_detail::FindBlobsByTagsResult> FindBlobsByTags(
3074 Azure::Core::Http::_internal::HttpPipeline& pipeline,
3075 const Azure::Core::Url& url,
3076 const FindBlobsByTagsOptions& options,
3077 const Azure::Core::Context& context)
3080 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url);
3081 request.SetHeader(
"x-ms-version",
"2020-02-10");
3082 if (options.Timeout.HasValue())
3084 request.GetUrl().AppendQueryParameter(
3085 "timeout", std::to_string(options.Timeout.Value()));
3087 request.GetUrl().AppendQueryParameter(
"comp",
"blobs");
3088 request.GetUrl().AppendQueryParameter(
3089 "where", _internal::UrlEncodeQueryParameter(options.Where));
3090 if (options.ContinuationToken.HasValue())
3092 request.GetUrl().AppendQueryParameter(
3093 "marker", _internal::UrlEncodeQueryParameter(options.ContinuationToken.Value()));
3095 if (options.MaxResults.HasValue())
3097 request.GetUrl().AppendQueryParameter(
3098 "maxresults", std::to_string(options.MaxResults.Value()));
3100 auto pHttpResponse = pipeline.Send(request, context);
3101 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
3102 Models::_detail::FindBlobsByTagsResult response;
3103 auto http_status_code
3104 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
3105 httpResponse.GetStatusCode());
3106 if (!(http_status_code == 200))
3108 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
3111 const auto& httpResponseBody = httpResponse.GetBody();
3112 _internal::XmlReader reader(
3113 reinterpret_cast<const char*
>(httpResponseBody.data()), httpResponseBody.size());
3114 response = FindBlobsByTagsResultInternalFromXml(reader);
3116 return Azure::Response<Models::_detail::FindBlobsByTagsResult>(
3117 std::move(response), std::move(pHttpResponse));
3121 static BlobServiceProperties BlobServicePropertiesFromXml(_internal::XmlReader& reader)
3123 BlobServiceProperties ret;
3124 enum class XmlTagName
3126 k_StorageServiceProperties,
3132 k_DefaultServiceVersion,
3133 k_DeleteRetentionPolicy,
3137 std::vector<XmlTagName> path;
3140 auto node = reader.Read();
3141 if (node.Type == _internal::XmlNodeType::End)
3145 else if (node.Type == _internal::XmlNodeType::EndTag)
3147 if (path.size() > 0)
3156 else if (node.Type == _internal::XmlNodeType::StartTag)
3158 if (std::strcmp(node.Name,
"StorageServiceProperties") == 0)
3160 path.emplace_back(XmlTagName::k_StorageServiceProperties);
3162 else if (std::strcmp(node.Name,
"Logging") == 0)
3164 path.emplace_back(XmlTagName::k_Logging);
3166 else if (std::strcmp(node.Name,
"HourMetrics") == 0)
3168 path.emplace_back(XmlTagName::k_HourMetrics);
3170 else if (std::strcmp(node.Name,
"MinuteMetrics") == 0)
3172 path.emplace_back(XmlTagName::k_MinuteMetrics);
3174 else if (std::strcmp(node.Name,
"Cors") == 0)
3176 path.emplace_back(XmlTagName::k_Cors);
3178 else if (std::strcmp(node.Name,
"CorsRule") == 0)
3180 path.emplace_back(XmlTagName::k_CorsRule);
3182 else if (std::strcmp(node.Name,
"DefaultServiceVersion") == 0)
3184 path.emplace_back(XmlTagName::k_DefaultServiceVersion);
3186 else if (std::strcmp(node.Name,
"DeleteRetentionPolicy") == 0)
3188 path.emplace_back(XmlTagName::k_DeleteRetentionPolicy);
3190 else if (std::strcmp(node.Name,
"StaticWebsite") == 0)
3192 path.emplace_back(XmlTagName::k_StaticWebsite);
3196 path.emplace_back(XmlTagName::k_Unknown);
3198 if (path.size() == 2 && path[0] == XmlTagName::k_StorageServiceProperties
3199 && path[1] == XmlTagName::k_Logging)
3201 ret.Logging = AnalyticsLoggingFromXml(reader);
3205 path.size() == 2 && path[0] == XmlTagName::k_StorageServiceProperties
3206 && path[1] == XmlTagName::k_HourMetrics)
3208 ret.HourMetrics = MetricsFromXml(reader);
3212 path.size() == 2 && path[0] == XmlTagName::k_StorageServiceProperties
3213 && path[1] == XmlTagName::k_MinuteMetrics)
3215 ret.MinuteMetrics = MetricsFromXml(reader);
3219 path.size() == 3 && path[0] == XmlTagName::k_StorageServiceProperties
3220 && path[1] == XmlTagName::k_Cors && path[2] == XmlTagName::k_CorsRule)
3222 ret.Cors.emplace_back(CorsRuleFromXml(reader));
3226 path.size() == 2 && path[0] == XmlTagName::k_StorageServiceProperties
3227 && path[1] == XmlTagName::k_DeleteRetentionPolicy)
3229 ret.DeleteRetentionPolicy = RetentionPolicyFromXml(reader);
3233 path.size() == 2 && path[0] == XmlTagName::k_StorageServiceProperties
3234 && path[1] == XmlTagName::k_StaticWebsite)
3236 ret.StaticWebsite = StaticWebsiteFromXml(reader);
3240 else if (node.Type == _internal::XmlNodeType::Text)
3242 if (path.size() == 2 && path[0] == XmlTagName::k_StorageServiceProperties
3243 && path[1] == XmlTagName::k_DefaultServiceVersion)
3245 ret.DefaultServiceVersion = node.Value;
3252 static Models::_detail::FindBlobsByTagsResult FindBlobsByTagsResultInternalFromXml(
3253 _internal::XmlReader& reader)
3255 Models::_detail::FindBlobsByTagsResult ret;
3256 enum class XmlTagName
3258 k_EnumerationResults,
3264 std::vector<XmlTagName> path;
3267 auto node = reader.Read();
3268 if (node.Type == _internal::XmlNodeType::End)
3272 else if (node.Type == _internal::XmlNodeType::EndTag)
3274 if (path.size() > 0)
3283 else if (node.Type == _internal::XmlNodeType::StartTag)
3285 if (std::strcmp(node.Name,
"EnumerationResults") == 0)
3287 path.emplace_back(XmlTagName::k_EnumerationResults);
3289 else if (std::strcmp(node.Name,
"NextMarker") == 0)
3291 path.emplace_back(XmlTagName::k_NextMarker);
3293 else if (std::strcmp(node.Name,
"Blobs") == 0)
3295 path.emplace_back(XmlTagName::k_Blobs);
3297 else if (std::strcmp(node.Name,
"Blob") == 0)
3299 path.emplace_back(XmlTagName::k_Blob);
3303 path.emplace_back(XmlTagName::k_Unknown);
3305 if (path.size() == 3 && path[0] == XmlTagName::k_EnumerationResults
3306 && path[1] == XmlTagName::k_Blobs && path[2] == XmlTagName::k_Blob)
3308 ret.Items.emplace_back(TaggedBlobItemFromXml(reader));
3312 else if (node.Type == _internal::XmlNodeType::Text)
3314 if (path.size() == 2 && path[0] == XmlTagName::k_EnumerationResults
3315 && path[1] == XmlTagName::k_NextMarker)
3317 ret.ContinuationToken = node.Value;
3320 else if (node.Type == _internal::XmlNodeType::Attribute)
3322 if (path.size() == 1 && path[0] == XmlTagName::k_EnumerationResults
3323 && std::strcmp(node.Name,
"ServiceEndpoint") == 0)
3325 ret.ServiceEndpoint = node.Value;
3332 static Models::_detail::ListBlobContainersResult ListBlobContainersResultInternalFromXml(
3333 _internal::XmlReader& reader)
3335 Models::_detail::ListBlobContainersResult ret;
3336 enum class XmlTagName
3338 k_EnumerationResults,
3345 std::vector<XmlTagName> path;
3348 auto node = reader.Read();
3349 if (node.Type == _internal::XmlNodeType::End)
3353 else if (node.Type == _internal::XmlNodeType::EndTag)
3355 if (path.size() > 0)
3364 else if (node.Type == _internal::XmlNodeType::StartTag)
3366 if (std::strcmp(node.Name,
"EnumerationResults") == 0)
3368 path.emplace_back(XmlTagName::k_EnumerationResults);
3370 else if (std::strcmp(node.Name,
"Prefix") == 0)
3372 path.emplace_back(XmlTagName::k_Prefix);
3374 else if (std::strcmp(node.Name,
"NextMarker") == 0)
3376 path.emplace_back(XmlTagName::k_NextMarker);
3378 else if (std::strcmp(node.Name,
"Containers") == 0)
3380 path.emplace_back(XmlTagName::k_Containers);
3382 else if (std::strcmp(node.Name,
"Container") == 0)
3384 path.emplace_back(XmlTagName::k_Container);
3388 path.emplace_back(XmlTagName::k_Unknown);
3390 if (path.size() == 3 && path[0] == XmlTagName::k_EnumerationResults
3391 && path[1] == XmlTagName::k_Containers && path[2] == XmlTagName::k_Container)
3393 ret.Items.emplace_back(BlobContainerItemFromXml(reader));
3397 else if (node.Type == _internal::XmlNodeType::Text)
3399 if (path.size() == 2 && path[0] == XmlTagName::k_EnumerationResults
3400 && path[1] == XmlTagName::k_Prefix)
3402 ret.Prefix = node.Value;
3405 path.size() == 2 && path[0] == XmlTagName::k_EnumerationResults
3406 && path[1] == XmlTagName::k_NextMarker)
3408 ret.ContinuationToken = node.Value;
3411 else if (node.Type == _internal::XmlNodeType::Attribute)
3413 if (path.size() == 1 && path[0] == XmlTagName::k_EnumerationResults
3414 && std::strcmp(node.Name,
"ServiceEndpoint") == 0)
3416 ret.ServiceEndpoint = node.Value;
3423 static ServiceStatistics ServiceStatisticsFromXml(_internal::XmlReader& reader)
3425 ServiceStatistics ret;
3426 enum class XmlTagName
3428 k_StorageServiceStats,
3432 std::vector<XmlTagName> path;
3435 auto node = reader.Read();
3436 if (node.Type == _internal::XmlNodeType::End)
3440 else if (node.Type == _internal::XmlNodeType::EndTag)
3442 if (path.size() > 0)
3451 else if (node.Type == _internal::XmlNodeType::StartTag)
3453 if (std::strcmp(node.Name,
"StorageServiceStats") == 0)
3455 path.emplace_back(XmlTagName::k_StorageServiceStats);
3457 else if (std::strcmp(node.Name,
"GeoReplication") == 0)
3459 path.emplace_back(XmlTagName::k_GeoReplication);
3463 path.emplace_back(XmlTagName::k_Unknown);
3465 if (path.size() == 2 && path[0] == XmlTagName::k_StorageServiceStats
3466 && path[1] == XmlTagName::k_GeoReplication)
3468 ret.GeoReplication = GeoReplicationFromXml(reader);
3472 else if (node.Type == _internal::XmlNodeType::Text)
3479 static UserDelegationKey UserDelegationKeyFromXml(_internal::XmlReader& reader)
3481 UserDelegationKey ret;
3482 enum class XmlTagName
3484 k_UserDelegationKey,
3494 std::vector<XmlTagName> path;
3497 auto node = reader.Read();
3498 if (node.Type == _internal::XmlNodeType::End)
3502 else if (node.Type == _internal::XmlNodeType::EndTag)
3504 if (path.size() > 0)
3513 else if (node.Type == _internal::XmlNodeType::StartTag)
3515 if (std::strcmp(node.Name,
"UserDelegationKey") == 0)
3517 path.emplace_back(XmlTagName::k_UserDelegationKey);
3519 else if (std::strcmp(node.Name,
"SignedOid") == 0)
3521 path.emplace_back(XmlTagName::k_SignedOid);
3523 else if (std::strcmp(node.Name,
"SignedTid") == 0)
3525 path.emplace_back(XmlTagName::k_SignedTid);
3527 else if (std::strcmp(node.Name,
"SignedStart") == 0)
3529 path.emplace_back(XmlTagName::k_SignedStart);
3531 else if (std::strcmp(node.Name,
"SignedExpiry") == 0)
3533 path.emplace_back(XmlTagName::k_SignedExpiry);
3535 else if (std::strcmp(node.Name,
"SignedService") == 0)
3537 path.emplace_back(XmlTagName::k_SignedService);
3539 else if (std::strcmp(node.Name,
"SignedVersion") == 0)
3541 path.emplace_back(XmlTagName::k_SignedVersion);
3543 else if (std::strcmp(node.Name,
"Value") == 0)
3545 path.emplace_back(XmlTagName::k_Value);
3549 path.emplace_back(XmlTagName::k_Unknown);
3552 else if (node.Type == _internal::XmlNodeType::Text)
3554 if (path.size() == 2 && path[0] == XmlTagName::k_UserDelegationKey
3555 && path[1] == XmlTagName::k_SignedOid)
3557 ret.SignedObjectId = node.Value;
3560 path.size() == 2 && path[0] == XmlTagName::k_UserDelegationKey
3561 && path[1] == XmlTagName::k_SignedTid)
3563 ret.SignedTenantId = node.Value;
3566 path.size() == 2 && path[0] == XmlTagName::k_UserDelegationKey
3567 && path[1] == XmlTagName::k_SignedStart)
3570 = Azure::DateTime::Parse(node.Value, Azure::DateTime::DateFormat::Rfc3339);
3573 path.size() == 2 && path[0] == XmlTagName::k_UserDelegationKey
3574 && path[1] == XmlTagName::k_SignedExpiry)
3577 = Azure::DateTime::Parse(node.Value, Azure::DateTime::DateFormat::Rfc3339);
3580 path.size() == 2 && path[0] == XmlTagName::k_UserDelegationKey
3581 && path[1] == XmlTagName::k_SignedService)
3583 ret.SignedService = node.Value;
3586 path.size() == 2 && path[0] == XmlTagName::k_UserDelegationKey
3587 && path[1] == XmlTagName::k_SignedVersion)
3589 ret.SignedVersion = node.Value;
3592 path.size() == 2 && path[0] == XmlTagName::k_UserDelegationKey
3593 && path[1] == XmlTagName::k_Value)
3595 ret.Value = node.Value;
3602 static AnalyticsLogging AnalyticsLoggingFromXml(_internal::XmlReader& reader)
3604 AnalyticsLogging ret;
3605 enum class XmlTagName
3614 std::vector<XmlTagName> path;
3617 auto node = reader.Read();
3618 if (node.Type == _internal::XmlNodeType::End)
3622 else if (node.Type == _internal::XmlNodeType::EndTag)
3624 if (path.size() > 0)
3633 else if (node.Type == _internal::XmlNodeType::StartTag)
3635 if (std::strcmp(node.Name,
"Version") == 0)
3637 path.emplace_back(XmlTagName::k_Version);
3639 else if (std::strcmp(node.Name,
"Delete") == 0)
3641 path.emplace_back(XmlTagName::k_Delete);
3643 else if (std::strcmp(node.Name,
"Read") == 0)
3645 path.emplace_back(XmlTagName::k_Read);
3647 else if (std::strcmp(node.Name,
"Write") == 0)
3649 path.emplace_back(XmlTagName::k_Write);
3651 else if (std::strcmp(node.Name,
"RetentionPolicy") == 0)
3653 path.emplace_back(XmlTagName::k_RetentionPolicy);
3657 path.emplace_back(XmlTagName::k_Unknown);
3659 if (path.size() == 1 && path[0] == XmlTagName::k_RetentionPolicy)
3661 ret.RetentionPolicy = RetentionPolicyFromXml(reader);
3665 else if (node.Type == _internal::XmlNodeType::Text)
3667 if (path.size() == 1 && path[0] == XmlTagName::k_Version)
3669 ret.Version = node.Value;
3671 else if (path.size() == 1 && path[0] == XmlTagName::k_Delete)
3673 ret.Delete = std::strcmp(node.Value,
"true") == 0;
3675 else if (path.size() == 1 && path[0] == XmlTagName::k_Read)
3677 ret.Read = std::strcmp(node.Value,
"true") == 0;
3679 else if (path.size() == 1 && path[0] == XmlTagName::k_Write)
3681 ret.Write = std::strcmp(node.Value,
"true") == 0;
3688 static BlobContainerItem BlobContainerItemFromXml(_internal::XmlReader& reader)
3690 BlobContainerItem ret;
3691 enum class XmlTagName
3698 k_HasImmutabilityPolicy,
3703 k_DefaultEncryptionScope,
3704 k_DenyEncryptionScopeOverride,
3709 k_RemainingRetentionDays,
3712 std::vector<XmlTagName> path;
3715 auto node = reader.Read();
3716 if (node.Type == _internal::XmlNodeType::End)
3720 else if (node.Type == _internal::XmlNodeType::EndTag)
3722 if (path.size() > 0)
3731 else if (node.Type == _internal::XmlNodeType::StartTag)
3733 if (std::strcmp(node.Name,
"Name") == 0)
3735 path.emplace_back(XmlTagName::k_Name);
3737 else if (std::strcmp(node.Name,
"Properties") == 0)
3739 path.emplace_back(XmlTagName::k_Properties);
3741 else if (std::strcmp(node.Name,
"Etag") == 0)
3743 path.emplace_back(XmlTagName::k_Etag);
3745 else if (std::strcmp(node.Name,
"Last-Modified") == 0)
3747 path.emplace_back(XmlTagName::k_LastModified);
3749 else if (std::strcmp(node.Name,
"PublicAccess") == 0)
3751 path.emplace_back(XmlTagName::k_PublicAccess);
3753 else if (std::strcmp(node.Name,
"HasImmutabilityPolicy") == 0)
3755 path.emplace_back(XmlTagName::k_HasImmutabilityPolicy);
3757 else if (std::strcmp(node.Name,
"HasLegalHold") == 0)
3759 path.emplace_back(XmlTagName::k_HasLegalHold);
3761 else if (std::strcmp(node.Name,
"LeaseStatus") == 0)
3763 path.emplace_back(XmlTagName::k_LeaseStatus);
3765 else if (std::strcmp(node.Name,
"LeaseState") == 0)
3767 path.emplace_back(XmlTagName::k_LeaseState);
3769 else if (std::strcmp(node.Name,
"LeaseDuration") == 0)
3771 path.emplace_back(XmlTagName::k_LeaseDuration);
3773 else if (std::strcmp(node.Name,
"DefaultEncryptionScope") == 0)
3775 path.emplace_back(XmlTagName::k_DefaultEncryptionScope);
3777 else if (std::strcmp(node.Name,
"DenyEncryptionScopeOverride") == 0)
3779 path.emplace_back(XmlTagName::k_DenyEncryptionScopeOverride);
3781 else if (std::strcmp(node.Name,
"Metadata") == 0)
3783 path.emplace_back(XmlTagName::k_Metadata);
3785 else if (std::strcmp(node.Name,
"Deleted") == 0)
3787 path.emplace_back(XmlTagName::k_Deleted);
3789 else if (std::strcmp(node.Name,
"Version") == 0)
3791 path.emplace_back(XmlTagName::k_Version);
3793 else if (std::strcmp(node.Name,
"DeletedTime") == 0)
3795 path.emplace_back(XmlTagName::k_DeletedTime);
3797 else if (std::strcmp(node.Name,
"RemainingRetentionDays") == 0)
3799 path.emplace_back(XmlTagName::k_RemainingRetentionDays);
3803 path.emplace_back(XmlTagName::k_Unknown);
3805 if (path.size() == 1 && path[0] == XmlTagName::k_Metadata)
3807 ret.Details.Metadata = MetadataFromXml(reader);
3811 else if (node.Type == _internal::XmlNodeType::Text)
3813 if (path.size() == 1 && path[0] == XmlTagName::k_Name)
3815 ret.Name = node.Value;
3818 path.size() == 2 && path[0] == XmlTagName::k_Properties
3819 && path[1] == XmlTagName::k_Etag)
3821 ret.Details.ETag = Azure::ETag(node.Value);
3824 path.size() == 2 && path[0] == XmlTagName::k_Properties
3825 && path[1] == XmlTagName::k_LastModified)
3827 ret.Details.LastModified
3828 = Azure::DateTime::Parse(node.Value, Azure::DateTime::DateFormat::Rfc1123);
3831 path.size() == 2 && path[0] == XmlTagName::k_Properties
3832 && path[1] == XmlTagName::k_PublicAccess)
3834 ret.Details.AccessType = PublicAccessType(node.Value);
3837 path.size() == 2 && path[0] == XmlTagName::k_Properties
3838 && path[1] == XmlTagName::k_HasImmutabilityPolicy)
3840 ret.Details.HasImmutabilityPolicy = std::strcmp(node.Value,
"true") == 0;
3843 path.size() == 2 && path[0] == XmlTagName::k_Properties
3844 && path[1] == XmlTagName::k_HasLegalHold)
3846 ret.Details.HasLegalHold = std::strcmp(node.Value,
"true") == 0;
3849 path.size() == 2 && path[0] == XmlTagName::k_Properties
3850 && path[1] == XmlTagName::k_LeaseStatus)
3852 ret.Details.LeaseStatus = LeaseStatus(node.Value);
3855 path.size() == 2 && path[0] == XmlTagName::k_Properties
3856 && path[1] == XmlTagName::k_LeaseState)
3858 ret.Details.LeaseState = LeaseState(node.Value);
3861 path.size() == 2 && path[0] == XmlTagName::k_Properties
3862 && path[1] == XmlTagName::k_LeaseDuration)
3864 ret.Details.LeaseDuration = LeaseDurationType(node.Value);
3867 path.size() == 2 && path[0] == XmlTagName::k_Properties
3868 && path[1] == XmlTagName::k_DefaultEncryptionScope)
3870 ret.Details.DefaultEncryptionScope = node.Value;
3873 path.size() == 2 && path[0] == XmlTagName::k_Properties
3874 && path[1] == XmlTagName::k_DenyEncryptionScopeOverride)
3876 ret.Details.PreventEncryptionScopeOverride = std::strcmp(node.Value,
"true") == 0;
3878 else if (path.size() == 1 && path[0] == XmlTagName::k_Deleted)
3880 ret.IsDeleted = std::strcmp(node.Value,
"true") == 0;
3882 else if (path.size() == 1 && path[0] == XmlTagName::k_Version)
3884 ret.VersionId = node.Value;
3887 path.size() == 2 && path[0] == XmlTagName::k_Properties
3888 && path[1] == XmlTagName::k_DeletedTime)
3890 ret.Details.DeletedOn
3891 = Azure::DateTime::Parse(node.Value, Azure::DateTime::DateFormat::Rfc1123);
3894 path.size() == 2 && path[0] == XmlTagName::k_Properties
3895 && path[1] == XmlTagName::k_RemainingRetentionDays)
3897 ret.Details.RemainingRetentionDays = std::stoi(node.Value);
3904 static CorsRule CorsRuleFromXml(_internal::XmlReader& reader)
3907 enum class XmlTagName
3916 std::vector<XmlTagName> path;
3919 auto node = reader.Read();
3920 if (node.Type == _internal::XmlNodeType::End)
3924 else if (node.Type == _internal::XmlNodeType::EndTag)
3926 if (path.size() > 0)
3935 else if (node.Type == _internal::XmlNodeType::StartTag)
3937 if (std::strcmp(node.Name,
"AllowedOrigins") == 0)
3939 path.emplace_back(XmlTagName::k_AllowedOrigins);
3941 else if (std::strcmp(node.Name,
"AllowedMethods") == 0)
3943 path.emplace_back(XmlTagName::k_AllowedMethods);
3945 else if (std::strcmp(node.Name,
"MaxAgeInSeconds") == 0)
3947 path.emplace_back(XmlTagName::k_MaxAgeInSeconds);
3949 else if (std::strcmp(node.Name,
"ExposedHeaders") == 0)
3951 path.emplace_back(XmlTagName::k_ExposedHeaders);
3953 else if (std::strcmp(node.Name,
"AllowedHeaders") == 0)
3955 path.emplace_back(XmlTagName::k_AllowedHeaders);
3959 path.emplace_back(XmlTagName::k_Unknown);
3962 else if (node.Type == _internal::XmlNodeType::Text)
3964 if (path.size() == 1 && path[0] == XmlTagName::k_AllowedOrigins)
3966 ret.AllowedOrigins = node.Value;
3968 else if (path.size() == 1 && path[0] == XmlTagName::k_AllowedMethods)
3970 ret.AllowedMethods = node.Value;
3972 else if (path.size() == 1 && path[0] == XmlTagName::k_MaxAgeInSeconds)
3974 ret.MaxAgeInSeconds = std::stoi(node.Value);
3976 else if (path.size() == 1 && path[0] == XmlTagName::k_ExposedHeaders)
3978 ret.ExposedHeaders = node.Value;
3980 else if (path.size() == 1 && path[0] == XmlTagName::k_AllowedHeaders)
3982 ret.AllowedHeaders = node.Value;
3989 static GeoReplication GeoReplicationFromXml(_internal::XmlReader& reader)
3992 enum class XmlTagName
3998 std::vector<XmlTagName> path;
4001 auto node = reader.Read();
4002 if (node.Type == _internal::XmlNodeType::End)
4006 else if (node.Type == _internal::XmlNodeType::EndTag)
4008 if (path.size() > 0)
4017 else if (node.Type == _internal::XmlNodeType::StartTag)
4019 if (std::strcmp(node.Name,
"Status") == 0)
4021 path.emplace_back(XmlTagName::k_Status);
4023 else if (std::strcmp(node.Name,
"LastSyncTime") == 0)
4025 path.emplace_back(XmlTagName::k_LastSyncTime);
4029 path.emplace_back(XmlTagName::k_Unknown);
4032 else if (node.Type == _internal::XmlNodeType::Text)
4034 if (path.size() == 1 && path[0] == XmlTagName::k_Status)
4036 ret.Status = GeoReplicationStatus(node.Value);
4038 else if (path.size() == 1 && path[0] == XmlTagName::k_LastSyncTime)
4041 = Azure::DateTime::Parse(node.Value, Azure::DateTime::DateFormat::Rfc1123);
4048 static Metrics MetricsFromXml(_internal::XmlReader& reader)
4051 enum class XmlTagName
4059 std::vector<XmlTagName> path;
4062 auto node = reader.Read();
4063 if (node.Type == _internal::XmlNodeType::End)
4067 else if (node.Type == _internal::XmlNodeType::EndTag)
4069 if (path.size() > 0)
4078 else if (node.Type == _internal::XmlNodeType::StartTag)
4080 if (std::strcmp(node.Name,
"Version") == 0)
4082 path.emplace_back(XmlTagName::k_Version);
4084 else if (std::strcmp(node.Name,
"Enabled") == 0)
4086 path.emplace_back(XmlTagName::k_Enabled);
4088 else if (std::strcmp(node.Name,
"IncludeAPIs") == 0)
4090 path.emplace_back(XmlTagName::k_IncludeAPIs);
4092 else if (std::strcmp(node.Name,
"RetentionPolicy") == 0)
4094 path.emplace_back(XmlTagName::k_RetentionPolicy);
4098 path.emplace_back(XmlTagName::k_Unknown);
4100 if (path.size() == 1 && path[0] == XmlTagName::k_RetentionPolicy)
4102 ret.RetentionPolicy = RetentionPolicyFromXml(reader);
4106 else if (node.Type == _internal::XmlNodeType::Text)
4108 if (path.size() == 1 && path[0] == XmlTagName::k_Version)
4110 ret.Version = node.Value;
4112 else if (path.size() == 1 && path[0] == XmlTagName::k_Enabled)
4114 ret.IsEnabled = std::strcmp(node.Value,
"true") == 0;
4116 else if (path.size() == 1 && path[0] == XmlTagName::k_IncludeAPIs)
4118 ret.IncludeApis = std::strcmp(node.Value,
"true") == 0;
4125 static RetentionPolicy RetentionPolicyFromXml(_internal::XmlReader& reader)
4127 RetentionPolicy ret;
4128 enum class XmlTagName
4134 std::vector<XmlTagName> path;
4137 auto node = reader.Read();
4138 if (node.Type == _internal::XmlNodeType::End)
4142 else if (node.Type == _internal::XmlNodeType::EndTag)
4144 if (path.size() > 0)
4153 else if (node.Type == _internal::XmlNodeType::StartTag)
4155 if (std::strcmp(node.Name,
"Enabled") == 0)
4157 path.emplace_back(XmlTagName::k_Enabled);
4159 else if (std::strcmp(node.Name,
"Days") == 0)
4161 path.emplace_back(XmlTagName::k_Days);
4165 path.emplace_back(XmlTagName::k_Unknown);
4168 else if (node.Type == _internal::XmlNodeType::Text)
4170 if (path.size() == 1 && path[0] == XmlTagName::k_Enabled)
4172 ret.IsEnabled = std::strcmp(node.Value,
"true") == 0;
4174 else if (path.size() == 1 && path[0] == XmlTagName::k_Days)
4176 ret.Days = std::stoi(node.Value);
4183 static StaticWebsite StaticWebsiteFromXml(_internal::XmlReader& reader)
4186 enum class XmlTagName
4190 k_DefaultIndexDocumentPath,
4191 k_ErrorDocument404Path,
4194 std::vector<XmlTagName> path;
4197 auto node = reader.Read();
4198 if (node.Type == _internal::XmlNodeType::End)
4202 else if (node.Type == _internal::XmlNodeType::EndTag)
4204 if (path.size() > 0)
4213 else if (node.Type == _internal::XmlNodeType::StartTag)
4215 if (std::strcmp(node.Name,
"Enabled") == 0)
4217 path.emplace_back(XmlTagName::k_Enabled);
4219 else if (std::strcmp(node.Name,
"IndexDocument") == 0)
4221 path.emplace_back(XmlTagName::k_IndexDocument);
4223 else if (std::strcmp(node.Name,
"DefaultIndexDocumentPath") == 0)
4225 path.emplace_back(XmlTagName::k_DefaultIndexDocumentPath);
4227 else if (std::strcmp(node.Name,
"ErrorDocument404Path") == 0)
4229 path.emplace_back(XmlTagName::k_ErrorDocument404Path);
4233 path.emplace_back(XmlTagName::k_Unknown);
4236 else if (node.Type == _internal::XmlNodeType::Text)
4238 if (path.size() == 1 && path[0] == XmlTagName::k_Enabled)
4240 ret.IsEnabled = std::strcmp(node.Value,
"true") == 0;
4242 else if (path.size() == 1 && path[0] == XmlTagName::k_IndexDocument)
4244 ret.IndexDocument = node.Value;
4246 else if (path.size() == 1 && path[0] == XmlTagName::k_DefaultIndexDocumentPath)
4248 ret.DefaultIndexDocumentPath = node.Value;
4250 else if (path.size() == 1 && path[0] == XmlTagName::k_ErrorDocument404Path)
4252 ret.ErrorDocument404Path = node.Value;
4259 static TaggedBlobItem TaggedBlobItemFromXml(_internal::XmlReader& reader)
4262 enum class XmlTagName
4268 std::vector<XmlTagName> path;
4271 auto node = reader.Read();
4272 if (node.Type == _internal::XmlNodeType::End)
4276 else if (node.Type == _internal::XmlNodeType::EndTag)
4278 if (path.size() > 0)
4287 else if (node.Type == _internal::XmlNodeType::StartTag)
4289 if (std::strcmp(node.Name,
"Name") == 0)
4291 path.emplace_back(XmlTagName::k_Name);
4293 else if (std::strcmp(node.Name,
"ContainerName") == 0)
4295 path.emplace_back(XmlTagName::k_ContainerName);
4299 path.emplace_back(XmlTagName::k_Unknown);
4302 else if (node.Type == _internal::XmlNodeType::Text)
4304 if (path.size() == 1 && path[0] == XmlTagName::k_Name)
4306 ret.BlobName = node.Value;
4308 else if (path.size() == 1 && path[0] == XmlTagName::k_ContainerName)
4310 ret.BlobContainerName = node.Value;
4317 static Metadata MetadataFromXml(_internal::XmlReader& reader)
4324 auto node = reader.Read();
4325 if (node.Type == _internal::XmlNodeType::End)
4329 else if (node.Type == _internal::XmlNodeType::StartTag)
4336 else if (node.Type == _internal::XmlNodeType::EndTag)
4343 else if (depth == 1 && node.Type == _internal::XmlNodeType::Text)
4345 ret.emplace(std::move(key), std::string(node.Value));
4351 static void GetUserDelegationKeyOptionsToXml(
4352 _internal::XmlWriter& writer,
4353 const GetUserDelegationKeyOptions& options)
4355 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"KeyInfo"});
4356 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"Start"});
4357 writer.Write(_internal::XmlNode{
4358 _internal::XmlNodeType::Text,
4362 Azure::DateTime::DateFormat::Rfc3339,
4363 Azure::DateTime::TimeFractionFormat::Truncate)
4365 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
4366 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"Expiry"});
4367 writer.Write(_internal::XmlNode{
4368 _internal::XmlNodeType::Text,
4372 Azure::DateTime::DateFormat::Rfc3339,
4373 Azure::DateTime::TimeFractionFormat::Truncate)
4375 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
4376 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
4379 static void SetServicePropertiesOptionsToXml(
4380 _internal::XmlWriter& writer,
4381 const SetServicePropertiesOptions& options)
4384 _internal::XmlNode{_internal::XmlNodeType::StartTag,
"StorageServiceProperties"});
4385 BlobServicePropertiesToXml(writer, options.Properties);
4386 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
4389 static void BlobServicePropertiesToXml(
4390 _internal::XmlWriter& writer,
4391 const BlobServiceProperties& options)
4393 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"Logging"});
4394 AnalyticsLoggingToXml(writer, options.Logging);
4395 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
4396 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"HourMetrics"});
4397 MetricsToXml(writer, options.HourMetrics);
4398 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
4399 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"MinuteMetrics"});
4400 MetricsToXml(writer, options.MinuteMetrics);
4401 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
4402 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"Cors"});
4403 for (
const auto& i : options.Cors)
4405 CorsRuleToXml(writer, i);
4407 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
4408 if (options.DefaultServiceVersion.HasValue())
4411 _internal::XmlNode{_internal::XmlNodeType::StartTag,
"DefaultServiceVersion"});
4412 writer.Write(_internal::XmlNode{
4413 _internal::XmlNodeType::Text,
4415 options.DefaultServiceVersion.Value().data()});
4416 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
4419 _internal::XmlNode{_internal::XmlNodeType::StartTag,
"DeleteRetentionPolicy"});
4420 RetentionPolicyToXml(writer, options.DeleteRetentionPolicy);
4421 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
4422 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"StaticWebsite"});
4423 StaticWebsiteToXml(writer, options.StaticWebsite);
4424 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
4427 static void AnalyticsLoggingToXml(
4428 _internal::XmlWriter& writer,
4429 const AnalyticsLogging& options)
4431 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"Version"});
4433 _internal::XmlNode{_internal::XmlNodeType::Text,
nullptr, options.Version.data()});
4434 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
4435 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"Delete"});
4436 writer.Write(_internal::XmlNode{
4437 _internal::XmlNodeType::Text,
nullptr, options.Delete ?
"true" :
"false"});
4438 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
4439 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"Read"});
4440 writer.Write(_internal::XmlNode{
4441 _internal::XmlNodeType::Text,
nullptr, options.Read ?
"true" :
"false"});
4442 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
4443 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"Write"});
4444 writer.Write(_internal::XmlNode{
4445 _internal::XmlNodeType::Text,
nullptr, options.Write ?
"true" :
"false"});
4446 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
4447 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"RetentionPolicy"});
4448 RetentionPolicyToXml(writer, options.RetentionPolicy);
4449 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
4452 static void CorsRuleToXml(_internal::XmlWriter& writer,
const CorsRule& options)
4454 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"CorsRule"});
4455 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"AllowedOrigins"});
4456 writer.Write(_internal::XmlNode{
4457 _internal::XmlNodeType::Text,
nullptr, options.AllowedOrigins.data()});
4458 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
4459 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"AllowedMethods"});
4460 writer.Write(_internal::XmlNode{
4461 _internal::XmlNodeType::Text,
nullptr, options.AllowedMethods.data()});
4462 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
4463 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"AllowedHeaders"});
4464 writer.Write(_internal::XmlNode{
4465 _internal::XmlNodeType::Text,
nullptr, options.AllowedHeaders.data()});
4466 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
4467 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"ExposedHeaders"});
4468 writer.Write(_internal::XmlNode{
4469 _internal::XmlNodeType::Text,
nullptr, options.ExposedHeaders.data()});
4470 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
4471 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"MaxAgeInSeconds"});
4472 writer.Write(_internal::XmlNode{
4473 _internal::XmlNodeType::Text,
4475 std::to_string(options.MaxAgeInSeconds).data()});
4476 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
4477 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
4480 static void MetricsToXml(_internal::XmlWriter& writer,
const Metrics& options)
4482 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"Version"});
4484 _internal::XmlNode{_internal::XmlNodeType::Text,
nullptr, options.Version.data()});
4485 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
4486 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"Enabled"});
4487 writer.Write(_internal::XmlNode{
4488 _internal::XmlNodeType::Text,
nullptr, options.IsEnabled ?
"true" :
"false"});
4489 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
4490 if (options.IncludeApis.HasValue())
4492 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"IncludeAPIs"});
4493 writer.Write(_internal::XmlNode{
4494 _internal::XmlNodeType::Text,
4496 options.IncludeApis.Value() ?
"true" :
"false"});
4497 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
4499 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"RetentionPolicy"});
4500 RetentionPolicyToXml(writer, options.RetentionPolicy);
4501 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
4504 static void RetentionPolicyToXml(
4505 _internal::XmlWriter& writer,
4506 const RetentionPolicy& options)
4508 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"Enabled"});
4509 writer.Write(_internal::XmlNode{
4510 _internal::XmlNodeType::Text,
nullptr, options.IsEnabled ?
"true" :
"false"});
4511 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
4512 if (options.Days.HasValue())
4514 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"Days"});
4515 writer.Write(_internal::XmlNode{
4516 _internal::XmlNodeType::Text,
4518 std::to_string(options.Days.Value()).data()});
4519 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
4523 static void StaticWebsiteToXml(_internal::XmlWriter& writer,
const StaticWebsite& options)
4525 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"Enabled"});
4526 writer.Write(_internal::XmlNode{
4527 _internal::XmlNodeType::Text,
nullptr, options.IsEnabled ?
"true" :
"false"});
4528 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
4529 if (options.IndexDocument.HasValue())
4531 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"IndexDocument"});
4532 writer.Write(_internal::XmlNode{
4533 _internal::XmlNodeType::Text,
nullptr, options.IndexDocument.Value().data()});
4534 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
4536 if (options.DefaultIndexDocumentPath.HasValue())
4539 _internal::XmlNode{_internal::XmlNodeType::StartTag,
"DefaultIndexDocumentPath"});
4540 writer.Write(_internal::XmlNode{
4541 _internal::XmlNodeType::Text,
4543 options.DefaultIndexDocumentPath.Value().data()});
4544 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
4546 if (options.ErrorDocument404Path.HasValue())
4549 _internal::XmlNode{_internal::XmlNodeType::StartTag,
"ErrorDocument404Path"});
4550 writer.Write(_internal::XmlNode{
4551 _internal::XmlNodeType::Text,
4553 options.ErrorDocument404Path.Value().data()});
4554 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
4560 class BlobContainer final {
4562 struct CreateBlobContainerOptions final
4564 Azure::Nullable<int32_t> Timeout;
4566 Storage::Metadata Metadata;
4567 Azure::Nullable<std::string> DefaultEncryptionScope;
4568 Azure::Nullable<bool> PreventEncryptionScopeOverride;
4571 static Azure::Response<CreateBlobContainerResult> Create(
4572 Azure::Core::Http::_internal::HttpPipeline& pipeline,
4573 const Azure::Core::Url& url,
4574 const CreateBlobContainerOptions& options,
4575 const Azure::Core::Context& context)
4578 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
4579 request.SetHeader(
"Content-Length",
"0");
4580 request.GetUrl().AppendQueryParameter(
"restype",
"container");
4581 request.SetHeader(
"x-ms-version",
"2020-02-10");
4582 if (options.Timeout.HasValue())
4584 request.GetUrl().AppendQueryParameter(
4585 "timeout", std::to_string(options.Timeout.Value()));
4587 for (
const auto& pair : options.Metadata)
4589 request.SetHeader(
"x-ms-meta-" + pair.first, pair.second);
4591 if (!options.AccessType.ToString().empty())
4593 request.SetHeader(
"x-ms-blob-public-access", options.AccessType.ToString());
4595 if (options.DefaultEncryptionScope.HasValue())
4598 "x-ms-default-encryption-scope", options.DefaultEncryptionScope.Value());
4600 if (options.PreventEncryptionScopeOverride.HasValue())
4603 "x-ms-deny-encryption-scope-override",
4604 options.PreventEncryptionScopeOverride.Value() ?
"true" :
"false");
4606 auto pHttpResponse = pipeline.Send(request, context);
4607 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
4608 CreateBlobContainerResult response;
4609 auto http_status_code
4610 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
4611 httpResponse.GetStatusCode());
4612 if (!(http_status_code == 201))
4614 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
4616 response.ETag = Azure::ETag(httpResponse.GetHeaders().at(
"etag"));
4617 response.LastModified = Azure::DateTime::Parse(
4618 httpResponse.GetHeaders().at(
"last-modified"), Azure::DateTime::DateFormat::Rfc1123);
4619 return Azure::Response<CreateBlobContainerResult>(
4620 std::move(response), std::move(pHttpResponse));
4623 struct DeleteBlobContainerOptions final
4625 Azure::Nullable<int32_t> Timeout;
4626 Azure::Nullable<std::string> LeaseId;
4627 Azure::Nullable<Azure::DateTime> IfModifiedSince;
4628 Azure::Nullable<Azure::DateTime> IfUnmodifiedSince;
4631 static Azure::Response<DeleteBlobContainerResult> Delete(
4632 Azure::Core::Http::_internal::HttpPipeline& pipeline,
4633 const Azure::Core::Url& url,
4634 const DeleteBlobContainerOptions& options,
4635 const Azure::Core::Context& context)
4638 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Delete, url);
4639 request.GetUrl().AppendQueryParameter(
"restype",
"container");
4640 request.SetHeader(
"x-ms-version",
"2020-02-10");
4641 if (options.Timeout.HasValue())
4643 request.GetUrl().AppendQueryParameter(
4644 "timeout", std::to_string(options.Timeout.Value()));
4646 if (options.LeaseId.HasValue())
4648 request.SetHeader(
"x-ms-lease-id", options.LeaseId.Value());
4650 if (options.IfModifiedSince.HasValue())
4653 "If-Modified-Since",
4654 options.IfModifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
4656 if (options.IfUnmodifiedSince.HasValue())
4659 "If-Unmodified-Since",
4660 options.IfUnmodifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
4662 auto pHttpResponse = pipeline.Send(request, context);
4663 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
4664 DeleteBlobContainerResult response;
4665 auto http_status_code
4666 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
4667 httpResponse.GetStatusCode());
4668 if (!(http_status_code == 202))
4670 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
4672 return Azure::Response<DeleteBlobContainerResult>(
4673 std::move(response), std::move(pHttpResponse));
4676 struct UndeleteBlobContainerOptions final
4678 Azure::Nullable<int32_t> Timeout;
4679 std::string DeletedBlobContainerName;
4680 std::string DeletedBlobContainerVersion;
4683 static Azure::Response<Models::_detail::UndeleteBlobContainerResult> Undelete(
4684 Azure::Core::Http::_internal::HttpPipeline& pipeline,
4685 const Azure::Core::Url& url,
4686 const UndeleteBlobContainerOptions& options,
4687 const Azure::Core::Context& context)
4690 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
4691 request.SetHeader(
"Content-Length",
"0");
4692 request.GetUrl().AppendQueryParameter(
"restype",
"container");
4693 request.GetUrl().AppendQueryParameter(
"comp",
"undelete");
4694 request.SetHeader(
"x-ms-version",
"2020-02-10");
4695 if (options.Timeout.HasValue())
4697 request.GetUrl().AppendQueryParameter(
4698 "timeout", std::to_string(options.Timeout.Value()));
4700 request.SetHeader(
"x-ms-deleted-container-name", options.DeletedBlobContainerName);
4701 request.SetHeader(
"x-ms-deleted-container-version", options.DeletedBlobContainerVersion);
4702 auto pHttpResponse = pipeline.Send(request, context);
4703 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
4704 Models::_detail::UndeleteBlobContainerResult response;
4705 auto http_status_code
4706 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
4707 httpResponse.GetStatusCode());
4708 if (!(http_status_code == 201))
4710 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
4712 return Azure::Response<Models::_detail::UndeleteBlobContainerResult>(
4713 std::move(response), std::move(pHttpResponse));
4716 struct GetBlobContainerPropertiesOptions final
4718 Azure::Nullable<int32_t> Timeout;
4719 Azure::Nullable<std::string> LeaseId;
4722 static Azure::Response<BlobContainerProperties> GetProperties(
4723 Azure::Core::Http::_internal::HttpPipeline& pipeline,
4724 const Azure::Core::Url& url,
4725 const GetBlobContainerPropertiesOptions& options,
4726 const Azure::Core::Context& context)
4729 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Head, url);
4730 request.GetUrl().AppendQueryParameter(
"restype",
"container");
4731 request.SetHeader(
"x-ms-version",
"2020-02-10");
4732 if (options.Timeout.HasValue())
4734 request.GetUrl().AppendQueryParameter(
4735 "timeout", std::to_string(options.Timeout.Value()));
4737 if (options.LeaseId.HasValue())
4739 request.SetHeader(
"x-ms-lease-id", options.LeaseId.Value());
4741 auto pHttpResponse = pipeline.Send(request, context);
4742 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
4743 BlobContainerProperties response;
4744 auto http_status_code
4745 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
4746 httpResponse.GetStatusCode());
4747 if (!(http_status_code == 200))
4749 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
4751 response.ETag = Azure::ETag(httpResponse.GetHeaders().at(
"etag"));
4752 response.LastModified = Azure::DateTime::Parse(
4753 httpResponse.GetHeaders().at(
"last-modified"), Azure::DateTime::DateFormat::Rfc1123);
4754 for (
auto i = httpResponse.GetHeaders().lower_bound(
"x-ms-meta-");
4755 i != httpResponse.GetHeaders().end() && i->first.substr(0, 10) ==
"x-ms-meta-";
4758 response.Metadata.emplace(i->first.substr(10), i->second);
4760 auto x_ms_blob_public_access__iterator
4761 = httpResponse.GetHeaders().find(
"x-ms-blob-public-access");
4762 if (x_ms_blob_public_access__iterator != httpResponse.GetHeaders().end())
4764 response.AccessType = PublicAccessType(x_ms_blob_public_access__iterator->second);
4766 response.HasImmutabilityPolicy
4767 = httpResponse.GetHeaders().at(
"x-ms-has-immutability-policy") ==
"true";
4768 response.HasLegalHold = httpResponse.GetHeaders().at(
"x-ms-has-legal-hold") ==
"true";
4769 response.LeaseStatus = LeaseStatus(httpResponse.GetHeaders().at(
"x-ms-lease-status"));
4770 response.LeaseState = LeaseState(httpResponse.GetHeaders().at(
"x-ms-lease-state"));
4771 auto x_ms_lease_duration__iterator
4772 = httpResponse.GetHeaders().find(
"x-ms-lease-duration");
4773 if (x_ms_lease_duration__iterator != httpResponse.GetHeaders().end())
4775 response.LeaseDuration = LeaseDurationType(x_ms_lease_duration__iterator->second);
4777 response.DefaultEncryptionScope
4778 = httpResponse.GetHeaders().at(
"x-ms-default-encryption-scope");
4779 response.PreventEncryptionScopeOverride
4780 = httpResponse.GetHeaders().at(
"x-ms-deny-encryption-scope-override") ==
"true";
4781 return Azure::Response<BlobContainerProperties>(
4782 std::move(response), std::move(pHttpResponse));
4785 struct SetBlobContainerMetadataOptions final
4787 Azure::Nullable<int32_t> Timeout;
4788 Storage::Metadata Metadata;
4789 Azure::Nullable<std::string> LeaseId;
4790 Azure::Nullable<Azure::DateTime> IfModifiedSince;
4793 static Azure::Response<SetBlobContainerMetadataResult> SetMetadata(
4794 Azure::Core::Http::_internal::HttpPipeline& pipeline,
4795 const Azure::Core::Url& url,
4796 const SetBlobContainerMetadataOptions& options,
4797 const Azure::Core::Context& context)
4800 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
4801 request.SetHeader(
"Content-Length",
"0");
4802 request.GetUrl().AppendQueryParameter(
"restype",
"container");
4803 request.GetUrl().AppendQueryParameter(
"comp",
"metadata");
4804 request.SetHeader(
"x-ms-version",
"2020-02-10");
4805 if (options.Timeout.HasValue())
4807 request.GetUrl().AppendQueryParameter(
4808 "timeout", std::to_string(options.Timeout.Value()));
4810 for (
const auto& pair : options.Metadata)
4812 request.SetHeader(
"x-ms-meta-" + pair.first, pair.second);
4814 if (options.LeaseId.HasValue())
4816 request.SetHeader(
"x-ms-lease-id", options.LeaseId.Value());
4818 if (options.IfModifiedSince.HasValue())
4821 "If-Modified-Since",
4822 options.IfModifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
4824 auto pHttpResponse = pipeline.Send(request, context);
4825 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
4826 SetBlobContainerMetadataResult response;
4827 auto http_status_code
4828 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
4829 httpResponse.GetStatusCode());
4830 if (!(http_status_code == 200))
4832 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
4834 response.ETag = Azure::ETag(httpResponse.GetHeaders().at(
"etag"));
4835 response.LastModified = Azure::DateTime::Parse(
4836 httpResponse.GetHeaders().at(
"last-modified"), Azure::DateTime::DateFormat::Rfc1123);
4837 return Azure::Response<SetBlobContainerMetadataResult>(
4838 std::move(response), std::move(pHttpResponse));
4841 struct ListBlobsOptions final
4843 Azure::Nullable<int32_t> Timeout;
4844 Azure::Nullable<std::string> Prefix;
4845 Azure::Nullable<std::string> ContinuationToken;
4846 Azure::Nullable<int32_t> MaxResults;
4847 ListBlobsIncludeFlags Include = ListBlobsIncludeFlags::None;
4850 static Azure::Response<Models::_detail::ListBlobsResult> ListBlobs(
4851 Azure::Core::Http::_internal::HttpPipeline& pipeline,
4852 const Azure::Core::Url& url,
4853 const ListBlobsOptions& options,
4854 const Azure::Core::Context& context)
4857 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url);
4858 request.SetHeader(
"x-ms-version",
"2020-02-10");
4859 if (options.Timeout.HasValue())
4861 request.GetUrl().AppendQueryParameter(
4862 "timeout", std::to_string(options.Timeout.Value()));
4864 request.GetUrl().AppendQueryParameter(
"restype",
"container");
4865 request.GetUrl().AppendQueryParameter(
"comp",
"list");
4866 if (options.Prefix.HasValue())
4868 request.GetUrl().AppendQueryParameter(
4869 "prefix", _internal::UrlEncodeQueryParameter(options.Prefix.Value()));
4871 if (options.ContinuationToken.HasValue())
4873 request.GetUrl().AppendQueryParameter(
4874 "marker", _internal::UrlEncodeQueryParameter(options.ContinuationToken.Value()));
4876 if (options.MaxResults.HasValue())
4878 request.GetUrl().AppendQueryParameter(
4879 "maxresults", std::to_string(options.MaxResults.Value()));
4881 std::string list_blobs_include_flags = ListBlobsIncludeFlagsToString(options.Include);
4882 if (!list_blobs_include_flags.empty())
4884 request.GetUrl().AppendQueryParameter(
4885 "include", _internal::UrlEncodeQueryParameter(list_blobs_include_flags));
4887 auto pHttpResponse = pipeline.Send(request, context);
4888 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
4889 Models::_detail::ListBlobsResult response;
4890 auto http_status_code
4891 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
4892 httpResponse.GetStatusCode());
4893 if (!(http_status_code == 200))
4895 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
4898 const auto& httpResponseBody = httpResponse.GetBody();
4899 _internal::XmlReader reader(
4900 reinterpret_cast<const char*
>(httpResponseBody.data()), httpResponseBody.size());
4901 response = ListBlobsResultInternalFromXml(reader);
4903 return Azure::Response<Models::_detail::ListBlobsResult>(
4904 std::move(response), std::move(pHttpResponse));
4907 struct ListBlobsByHierarchyOptions final
4909 Azure::Nullable<int32_t> Timeout;
4910 Azure::Nullable<std::string> Prefix;
4911 Azure::Nullable<std::string> Delimiter;
4912 Azure::Nullable<std::string> ContinuationToken;
4913 Azure::Nullable<int32_t> MaxResults;
4914 ListBlobsIncludeFlags Include = ListBlobsIncludeFlags::None;
4917 static Azure::Response<Models::_detail::ListBlobsByHierarchyResult> ListBlobsByHierarchy(
4918 Azure::Core::Http::_internal::HttpPipeline& pipeline,
4919 const Azure::Core::Url& url,
4920 const ListBlobsByHierarchyOptions& options,
4921 const Azure::Core::Context& context)
4924 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url);
4925 request.SetHeader(
"x-ms-version",
"2020-02-10");
4926 if (options.Timeout.HasValue())
4928 request.GetUrl().AppendQueryParameter(
4929 "timeout", std::to_string(options.Timeout.Value()));
4931 request.GetUrl().AppendQueryParameter(
"restype",
"container");
4932 request.GetUrl().AppendQueryParameter(
"comp",
"list");
4933 if (options.Prefix.HasValue())
4935 request.GetUrl().AppendQueryParameter(
4936 "prefix", _internal::UrlEncodeQueryParameter(options.Prefix.Value()));
4938 if (options.Delimiter.HasValue())
4940 request.GetUrl().AppendQueryParameter(
4941 "delimiter", _internal::UrlEncodeQueryParameter(options.Delimiter.Value()));
4943 if (options.ContinuationToken.HasValue())
4945 request.GetUrl().AppendQueryParameter(
4946 "marker", _internal::UrlEncodeQueryParameter(options.ContinuationToken.Value()));
4948 if (options.MaxResults.HasValue())
4950 request.GetUrl().AppendQueryParameter(
4951 "maxresults", std::to_string(options.MaxResults.Value()));
4953 std::string list_blobs_include_flags = ListBlobsIncludeFlagsToString(options.Include);
4954 if (!list_blobs_include_flags.empty())
4956 request.GetUrl().AppendQueryParameter(
4957 "include", _internal::UrlEncodeQueryParameter(list_blobs_include_flags));
4959 auto pHttpResponse = pipeline.Send(request, context);
4960 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
4961 Models::_detail::ListBlobsByHierarchyResult response;
4962 auto http_status_code
4963 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
4964 httpResponse.GetStatusCode());
4965 if (!(http_status_code == 200))
4967 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
4970 const auto& httpResponseBody = httpResponse.GetBody();
4971 _internal::XmlReader reader(
4972 reinterpret_cast<const char*
>(httpResponseBody.data()), httpResponseBody.size());
4973 response = ListBlobsByHierarchyResultInternalFromXml(reader);
4975 return Azure::Response<Models::_detail::ListBlobsByHierarchyResult>(
4976 std::move(response), std::move(pHttpResponse));
4979 struct GetBlobContainerAccessPolicyOptions final
4981 Azure::Nullable<int32_t> Timeout;
4982 Azure::Nullable<std::string> LeaseId;
4985 static Azure::Response<BlobContainerAccessPolicy> GetAccessPolicy(
4986 Azure::Core::Http::_internal::HttpPipeline& pipeline,
4987 const Azure::Core::Url& url,
4988 const GetBlobContainerAccessPolicyOptions& options,
4989 const Azure::Core::Context& context)
4992 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url);
4993 request.SetHeader(
"x-ms-version",
"2020-02-10");
4994 if (options.Timeout.HasValue())
4996 request.GetUrl().AppendQueryParameter(
4997 "timeout", std::to_string(options.Timeout.Value()));
4999 request.GetUrl().AppendQueryParameter(
"restype",
"container");
5000 request.GetUrl().AppendQueryParameter(
"comp",
"acl");
5001 auto pHttpResponse = pipeline.Send(request, context);
5002 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
5003 BlobContainerAccessPolicy response;
5004 auto http_status_code
5005 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
5006 httpResponse.GetStatusCode());
5007 if (!(http_status_code == 200))
5009 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
5012 const auto& httpResponseBody = httpResponse.GetBody();
5013 _internal::XmlReader reader(
5014 reinterpret_cast<const char*
>(httpResponseBody.data()), httpResponseBody.size());
5015 response = BlobContainerAccessPolicyFromXml(reader);
5017 auto x_ms_blob_public_access__iterator
5018 = httpResponse.GetHeaders().find(
"x-ms-blob-public-access");
5019 if (x_ms_blob_public_access__iterator != httpResponse.GetHeaders().end())
5021 response.AccessType = PublicAccessType(x_ms_blob_public_access__iterator->second);
5023 return Azure::Response<BlobContainerAccessPolicy>(
5024 std::move(response), std::move(pHttpResponse));
5027 struct SetBlobContainerAccessPolicyOptions final
5029 Azure::Nullable<int32_t> Timeout;
5031 Azure::Nullable<std::string> LeaseId;
5032 Azure::Nullable<Azure::DateTime> IfModifiedSince;
5033 Azure::Nullable<Azure::DateTime> IfUnmodifiedSince;
5034 std::vector<SignedIdentifier> SignedIdentifiers;
5037 static Azure::Response<SetBlobContainerAccessPolicyResult> SetAccessPolicy(
5038 Azure::Core::Http::_internal::HttpPipeline& pipeline,
5039 const Azure::Core::Url& url,
5040 const SetBlobContainerAccessPolicyOptions& options,
5041 const Azure::Core::Context& context)
5044 std::string xml_body;
5046 _internal::XmlWriter writer;
5047 SetBlobContainerAccessPolicyOptionsToXml(writer, options);
5048 xml_body = writer.GetDocument();
5049 writer.Write(_internal::XmlNode{_internal::XmlNodeType::End});
5051 Azure::Core::IO::MemoryBodyStream xml_body_stream(
5052 reinterpret_cast<const uint8_t*
>(xml_body.data()), xml_body.length());
5053 auto request = Azure::Core::Http::Request(
5054 Azure::Core::Http::HttpMethod::Put, url, &xml_body_stream);
5055 request.SetHeader(
"Content-Length", std::to_string(xml_body_stream.Length()));
5056 request.SetHeader(
"x-ms-version",
"2020-02-10");
5057 if (options.Timeout.HasValue())
5059 request.GetUrl().AppendQueryParameter(
5060 "timeout", std::to_string(options.Timeout.Value()));
5062 request.GetUrl().AppendQueryParameter(
"restype",
"container");
5063 request.GetUrl().AppendQueryParameter(
"comp",
"acl");
5064 if (!options.AccessType.ToString().empty())
5066 request.SetHeader(
"x-ms-blob-public-access", options.AccessType.ToString());
5068 if (options.LeaseId.HasValue())
5070 request.SetHeader(
"x-ms-lease-id", options.LeaseId.Value());
5072 if (options.IfModifiedSince.HasValue())
5075 "If-Modified-Since",
5076 options.IfModifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
5078 if (options.IfUnmodifiedSince.HasValue())
5081 "If-Unmodified-Since",
5082 options.IfUnmodifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
5084 auto pHttpResponse = pipeline.Send(request, context);
5085 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
5086 SetBlobContainerAccessPolicyResult response;
5087 auto http_status_code
5088 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
5089 httpResponse.GetStatusCode());
5090 if (!(http_status_code == 200))
5092 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
5094 response.ETag = Azure::ETag(httpResponse.GetHeaders().at(
"etag"));
5095 response.LastModified = Azure::DateTime::Parse(
5096 httpResponse.GetHeaders().at(
"last-modified"), Azure::DateTime::DateFormat::Rfc1123);
5097 return Azure::Response<SetBlobContainerAccessPolicyResult>(
5098 std::move(response), std::move(pHttpResponse));
5101 struct AcquireBlobContainerLeaseOptions final
5103 Azure::Nullable<int32_t> Timeout;
5104 std::chrono::seconds LeaseDuration;
5105 Azure::Nullable<std::string> ProposedLeaseId;
5106 Azure::Nullable<Azure::DateTime> IfModifiedSince;
5107 Azure::Nullable<Azure::DateTime> IfUnmodifiedSince;
5110 static Azure::Response<Models::_detail::AcquireBlobContainerLeaseResult> AcquireLease(
5111 Azure::Core::Http::_internal::HttpPipeline& pipeline,
5112 const Azure::Core::Url& url,
5113 const AcquireBlobContainerLeaseOptions& options,
5114 const Azure::Core::Context& context)
5117 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
5118 request.SetHeader(
"Content-Length",
"0");
5119 request.SetHeader(
"x-ms-version",
"2020-02-10");
5120 if (options.Timeout.HasValue())
5122 request.GetUrl().AppendQueryParameter(
5123 "timeout", std::to_string(options.Timeout.Value()));
5125 request.GetUrl().AppendQueryParameter(
"restype",
"container");
5126 request.GetUrl().AppendQueryParameter(
"comp",
"lease");
5127 request.SetHeader(
"x-ms-lease-action",
"acquire");
5128 request.SetHeader(
"x-ms-lease-duration", std::to_string(options.LeaseDuration.count()));
5129 if (options.ProposedLeaseId.HasValue())
5131 request.SetHeader(
"x-ms-proposed-lease-id", options.ProposedLeaseId.Value());
5133 if (options.IfModifiedSince.HasValue())
5136 "If-Modified-Since",
5137 options.IfModifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
5139 if (options.IfUnmodifiedSince.HasValue())
5142 "If-Unmodified-Since",
5143 options.IfUnmodifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
5145 auto pHttpResponse = pipeline.Send(request, context);
5146 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
5147 Models::_detail::AcquireBlobContainerLeaseResult response;
5148 auto http_status_code
5149 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
5150 httpResponse.GetStatusCode());
5151 if (!(http_status_code == 201))
5153 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
5155 response.ETag = Azure::ETag(httpResponse.GetHeaders().at(
"etag"));
5156 response.LastModified = Azure::DateTime::Parse(
5157 httpResponse.GetHeaders().at(
"last-modified"), Azure::DateTime::DateFormat::Rfc1123);
5158 response.LeaseId = httpResponse.GetHeaders().at(
"x-ms-lease-id");
5159 return Azure::Response<Models::_detail::AcquireBlobContainerLeaseResult>(
5160 std::move(response), std::move(pHttpResponse));
5163 struct RenewBlobContainerLeaseOptions final
5165 Azure::Nullable<int32_t> Timeout;
5166 std::string LeaseId;
5167 Azure::Nullable<Azure::DateTime> IfModifiedSince;
5168 Azure::Nullable<Azure::DateTime> IfUnmodifiedSince;
5171 static Azure::Response<Models::_detail::RenewBlobContainerLeaseResult> RenewLease(
5172 Azure::Core::Http::_internal::HttpPipeline& pipeline,
5173 const Azure::Core::Url& url,
5174 const RenewBlobContainerLeaseOptions& options,
5175 const Azure::Core::Context& context)
5178 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
5179 request.SetHeader(
"Content-Length",
"0");
5180 request.SetHeader(
"x-ms-version",
"2020-02-10");
5181 if (options.Timeout.HasValue())
5183 request.GetUrl().AppendQueryParameter(
5184 "timeout", std::to_string(options.Timeout.Value()));
5186 request.GetUrl().AppendQueryParameter(
"restype",
"container");
5187 request.GetUrl().AppendQueryParameter(
"comp",
"lease");
5188 request.SetHeader(
"x-ms-lease-action",
"renew");
5189 request.SetHeader(
"x-ms-lease-id", options.LeaseId);
5190 if (options.IfModifiedSince.HasValue())
5193 "If-Modified-Since",
5194 options.IfModifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
5196 if (options.IfUnmodifiedSince.HasValue())
5199 "If-Unmodified-Since",
5200 options.IfUnmodifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
5202 auto pHttpResponse = pipeline.Send(request, context);
5203 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
5204 Models::_detail::RenewBlobContainerLeaseResult response;
5205 auto http_status_code
5206 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
5207 httpResponse.GetStatusCode());
5208 if (!(http_status_code == 200))
5210 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
5212 response.ETag = Azure::ETag(httpResponse.GetHeaders().at(
"etag"));
5213 response.LastModified = Azure::DateTime::Parse(
5214 httpResponse.GetHeaders().at(
"last-modified"), Azure::DateTime::DateFormat::Rfc1123);
5215 response.LeaseId = httpResponse.GetHeaders().at(
"x-ms-lease-id");
5216 return Azure::Response<Models::_detail::RenewBlobContainerLeaseResult>(
5217 std::move(response), std::move(pHttpResponse));
5220 struct ChangeBlobContainerLeaseOptions final
5222 Azure::Nullable<int32_t> Timeout;
5223 std::string LeaseId;
5224 std::string ProposedLeaseId;
5225 Azure::Nullable<Azure::DateTime> IfModifiedSince;
5226 Azure::Nullable<Azure::DateTime> IfUnmodifiedSince;
5229 static Azure::Response<Models::_detail::ChangeBlobContainerLeaseResult> ChangeLease(
5230 Azure::Core::Http::_internal::HttpPipeline& pipeline,
5231 const Azure::Core::Url& url,
5232 const ChangeBlobContainerLeaseOptions& options,
5233 const Azure::Core::Context& context)
5236 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
5237 request.SetHeader(
"Content-Length",
"0");
5238 request.SetHeader(
"x-ms-version",
"2020-02-10");
5239 if (options.Timeout.HasValue())
5241 request.GetUrl().AppendQueryParameter(
5242 "timeout", std::to_string(options.Timeout.Value()));
5244 request.GetUrl().AppendQueryParameter(
"restype",
"container");
5245 request.GetUrl().AppendQueryParameter(
"comp",
"lease");
5246 request.SetHeader(
"x-ms-lease-action",
"change");
5247 request.SetHeader(
"x-ms-lease-id", options.LeaseId);
5248 request.SetHeader(
"x-ms-proposed-lease-id", options.ProposedLeaseId);
5249 if (options.IfModifiedSince.HasValue())
5252 "If-Modified-Since",
5253 options.IfModifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
5255 if (options.IfUnmodifiedSince.HasValue())
5258 "If-Unmodified-Since",
5259 options.IfUnmodifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
5261 auto pHttpResponse = pipeline.Send(request, context);
5262 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
5263 Models::_detail::ChangeBlobContainerLeaseResult response;
5264 auto http_status_code
5265 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
5266 httpResponse.GetStatusCode());
5267 if (!(http_status_code == 200))
5269 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
5271 response.ETag = Azure::ETag(httpResponse.GetHeaders().at(
"etag"));
5272 response.LastModified = Azure::DateTime::Parse(
5273 httpResponse.GetHeaders().at(
"last-modified"), Azure::DateTime::DateFormat::Rfc1123);
5274 response.LeaseId = httpResponse.GetHeaders().at(
"x-ms-lease-id");
5275 return Azure::Response<Models::_detail::ChangeBlobContainerLeaseResult>(
5276 std::move(response), std::move(pHttpResponse));
5279 struct ReleaseBlobContainerLeaseOptions final
5281 Azure::Nullable<int32_t> Timeout;
5282 std::string LeaseId;
5283 Azure::Nullable<Azure::DateTime> IfModifiedSince;
5284 Azure::Nullable<Azure::DateTime> IfUnmodifiedSince;
5287 static Azure::Response<Models::_detail::ReleaseBlobContainerLeaseResult> ReleaseLease(
5288 Azure::Core::Http::_internal::HttpPipeline& pipeline,
5289 const Azure::Core::Url& url,
5290 const ReleaseBlobContainerLeaseOptions& options,
5291 const Azure::Core::Context& context)
5294 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
5295 request.SetHeader(
"Content-Length",
"0");
5296 request.SetHeader(
"x-ms-version",
"2020-02-10");
5297 if (options.Timeout.HasValue())
5299 request.GetUrl().AppendQueryParameter(
5300 "timeout", std::to_string(options.Timeout.Value()));
5302 request.GetUrl().AppendQueryParameter(
"restype",
"container");
5303 request.GetUrl().AppendQueryParameter(
"comp",
"lease");
5304 request.SetHeader(
"x-ms-lease-action",
"release");
5305 request.SetHeader(
"x-ms-lease-id", options.LeaseId);
5306 if (options.IfModifiedSince.HasValue())
5309 "If-Modified-Since",
5310 options.IfModifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
5312 if (options.IfUnmodifiedSince.HasValue())
5315 "If-Unmodified-Since",
5316 options.IfUnmodifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
5318 auto pHttpResponse = pipeline.Send(request, context);
5319 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
5320 Models::_detail::ReleaseBlobContainerLeaseResult response;
5321 auto http_status_code
5322 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
5323 httpResponse.GetStatusCode());
5324 if (!(http_status_code == 200))
5326 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
5328 response.ETag = Azure::ETag(httpResponse.GetHeaders().at(
"etag"));
5329 response.LastModified = Azure::DateTime::Parse(
5330 httpResponse.GetHeaders().at(
"last-modified"), Azure::DateTime::DateFormat::Rfc1123);
5331 return Azure::Response<Models::_detail::ReleaseBlobContainerLeaseResult>(
5332 std::move(response), std::move(pHttpResponse));
5335 struct BreakBlobContainerLeaseOptions final
5337 Azure::Nullable<int32_t> Timeout;
5338 Azure::Nullable<std::chrono::seconds> BreakPeriod;
5339 Azure::Nullable<Azure::DateTime> IfModifiedSince;
5340 Azure::Nullable<Azure::DateTime> IfUnmodifiedSince;
5343 static Azure::Response<Models::_detail::BreakBlobContainerLeaseResult> BreakLease(
5344 Azure::Core::Http::_internal::HttpPipeline& pipeline,
5345 const Azure::Core::Url& url,
5346 const BreakBlobContainerLeaseOptions& options,
5347 const Azure::Core::Context& context)
5350 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
5351 request.SetHeader(
"Content-Length",
"0");
5352 request.SetHeader(
"x-ms-version",
"2020-02-10");
5353 if (options.Timeout.HasValue())
5355 request.GetUrl().AppendQueryParameter(
5356 "timeout", std::to_string(options.Timeout.Value()));
5358 request.GetUrl().AppendQueryParameter(
"restype",
"container");
5359 request.GetUrl().AppendQueryParameter(
"comp",
"lease");
5360 request.SetHeader(
"x-ms-lease-action",
"break");
5361 if (options.BreakPeriod.HasValue())
5364 "x-ms-lease-break-period", std::to_string(options.BreakPeriod.Value().count()));
5366 if (options.IfModifiedSince.HasValue())
5369 "If-Modified-Since",
5370 options.IfModifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
5372 if (options.IfUnmodifiedSince.HasValue())
5375 "If-Unmodified-Since",
5376 options.IfUnmodifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
5378 auto pHttpResponse = pipeline.Send(request, context);
5379 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
5380 Models::_detail::BreakBlobContainerLeaseResult response;
5381 auto http_status_code
5382 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
5383 httpResponse.GetStatusCode());
5384 if (!(http_status_code == 202))
5386 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
5388 response.ETag = Azure::ETag(httpResponse.GetHeaders().at(
"etag"));
5389 response.LastModified = Azure::DateTime::Parse(
5390 httpResponse.GetHeaders().at(
"last-modified"), Azure::DateTime::DateFormat::Rfc1123);
5391 response.LeaseTime = std::stoi(httpResponse.GetHeaders().at(
"x-ms-lease-time"));
5392 return Azure::Response<Models::_detail::BreakBlobContainerLeaseResult>(
5393 std::move(response), std::move(pHttpResponse));
5397 static BlobContainerAccessPolicy BlobContainerAccessPolicyFromXml(
5398 _internal::XmlReader& reader)
5400 BlobContainerAccessPolicy ret;
5401 enum class XmlTagName
5403 k_SignedIdentifiers,
5407 std::vector<XmlTagName> path;
5410 auto node = reader.Read();
5411 if (node.Type == _internal::XmlNodeType::End)
5415 else if (node.Type == _internal::XmlNodeType::EndTag)
5417 if (path.size() > 0)
5426 else if (node.Type == _internal::XmlNodeType::StartTag)
5428 if (std::strcmp(node.Name,
"SignedIdentifiers") == 0)
5430 path.emplace_back(XmlTagName::k_SignedIdentifiers);
5432 else if (std::strcmp(node.Name,
"SignedIdentifier") == 0)
5434 path.emplace_back(XmlTagName::k_SignedIdentifier);
5438 path.emplace_back(XmlTagName::k_Unknown);
5440 if (path.size() == 2 && path[0] == XmlTagName::k_SignedIdentifiers
5441 && path[1] == XmlTagName::k_SignedIdentifier)
5443 ret.SignedIdentifiers.emplace_back(SignedIdentifierFromXml(reader));
5447 else if (node.Type == _internal::XmlNodeType::Text)
5454 static Models::_detail::ListBlobsByHierarchyResult
5455 ListBlobsByHierarchyResultInternalFromXml(_internal::XmlReader& reader)
5457 Models::_detail::ListBlobsByHierarchyResult ret;
5458 enum class XmlTagName
5460 k_EnumerationResults,
5470 std::vector<XmlTagName> path;
5473 auto node = reader.Read();
5474 if (node.Type == _internal::XmlNodeType::End)
5478 else if (node.Type == _internal::XmlNodeType::EndTag)
5480 if (path.size() > 0)
5489 else if (node.Type == _internal::XmlNodeType::StartTag)
5491 if (std::strcmp(node.Name,
"EnumerationResults") == 0)
5493 path.emplace_back(XmlTagName::k_EnumerationResults);
5495 else if (std::strcmp(node.Name,
"Prefix") == 0)
5497 path.emplace_back(XmlTagName::k_Prefix);
5499 else if (std::strcmp(node.Name,
"Delimiter") == 0)
5501 path.emplace_back(XmlTagName::k_Delimiter);
5503 else if (std::strcmp(node.Name,
"NextMarker") == 0)
5505 path.emplace_back(XmlTagName::k_NextMarker);
5507 else if (std::strcmp(node.Name,
"Blobs") == 0)
5509 path.emplace_back(XmlTagName::k_Blobs);
5511 else if (std::strcmp(node.Name,
"Blob") == 0)
5513 path.emplace_back(XmlTagName::k_Blob);
5515 else if (std::strcmp(node.Name,
"BlobPrefix") == 0)
5517 path.emplace_back(XmlTagName::k_BlobPrefix);
5519 else if (std::strcmp(node.Name,
"Name") == 0)
5521 path.emplace_back(XmlTagName::k_Name);
5525 path.emplace_back(XmlTagName::k_Unknown);
5527 if (path.size() == 3 && path[0] == XmlTagName::k_EnumerationResults
5528 && path[1] == XmlTagName::k_Blobs && path[2] == XmlTagName::k_Blob)
5530 ret.Items.emplace_back(BlobItemFromXml(reader));
5534 else if (node.Type == _internal::XmlNodeType::Text)
5536 if (path.size() == 2 && path[0] == XmlTagName::k_EnumerationResults
5537 && path[1] == XmlTagName::k_Prefix)
5539 ret.Prefix = node.Value;
5542 path.size() == 2 && path[0] == XmlTagName::k_EnumerationResults
5543 && path[1] == XmlTagName::k_Delimiter)
5545 ret.Delimiter = node.Value;
5548 path.size() == 2 && path[0] == XmlTagName::k_EnumerationResults
5549 && path[1] == XmlTagName::k_NextMarker)
5551 ret.ContinuationToken = node.Value;
5554 path.size() == 4 && path[0] == XmlTagName::k_EnumerationResults
5555 && path[1] == XmlTagName::k_Blobs && path[2] == XmlTagName::k_BlobPrefix
5556 && path[3] == XmlTagName::k_Name)
5558 ret.BlobPrefixes.emplace_back(node.Value);
5561 else if (node.Type == _internal::XmlNodeType::Attribute)
5563 if (path.size() == 1 && path[0] == XmlTagName::k_EnumerationResults
5564 && std::strcmp(node.Name,
"ServiceEndpoint") == 0)
5566 ret.ServiceEndpoint = node.Value;
5569 path.size() == 1 && path[0] == XmlTagName::k_EnumerationResults
5570 && std::strcmp(node.Name,
"ContainerName") == 0)
5572 ret.BlobContainerName = node.Value;
5579 static Models::_detail::ListBlobsResult ListBlobsResultInternalFromXml(
5580 _internal::XmlReader& reader)
5582 Models::_detail::ListBlobsResult ret;
5583 enum class XmlTagName
5585 k_EnumerationResults,
5592 std::vector<XmlTagName> path;
5595 auto node = reader.Read();
5596 if (node.Type == _internal::XmlNodeType::End)
5600 else if (node.Type == _internal::XmlNodeType::EndTag)
5602 if (path.size() > 0)
5611 else if (node.Type == _internal::XmlNodeType::StartTag)
5613 if (std::strcmp(node.Name,
"EnumerationResults") == 0)
5615 path.emplace_back(XmlTagName::k_EnumerationResults);
5617 else if (std::strcmp(node.Name,
"Prefix") == 0)
5619 path.emplace_back(XmlTagName::k_Prefix);
5621 else if (std::strcmp(node.Name,
"NextMarker") == 0)
5623 path.emplace_back(XmlTagName::k_NextMarker);
5625 else if (std::strcmp(node.Name,
"Blobs") == 0)
5627 path.emplace_back(XmlTagName::k_Blobs);
5629 else if (std::strcmp(node.Name,
"Blob") == 0)
5631 path.emplace_back(XmlTagName::k_Blob);
5635 path.emplace_back(XmlTagName::k_Unknown);
5637 if (path.size() == 3 && path[0] == XmlTagName::k_EnumerationResults
5638 && path[1] == XmlTagName::k_Blobs && path[2] == XmlTagName::k_Blob)
5640 ret.Items.emplace_back(BlobItemFromXml(reader));
5644 else if (node.Type == _internal::XmlNodeType::Text)
5646 if (path.size() == 2 && path[0] == XmlTagName::k_EnumerationResults
5647 && path[1] == XmlTagName::k_Prefix)
5649 ret.Prefix = node.Value;
5652 path.size() == 2 && path[0] == XmlTagName::k_EnumerationResults
5653 && path[1] == XmlTagName::k_NextMarker)
5655 ret.ContinuationToken = node.Value;
5658 else if (node.Type == _internal::XmlNodeType::Attribute)
5660 if (path.size() == 1 && path[0] == XmlTagName::k_EnumerationResults
5661 && std::strcmp(node.Name,
"ServiceEndpoint") == 0)
5663 ret.ServiceEndpoint = node.Value;
5666 path.size() == 1 && path[0] == XmlTagName::k_EnumerationResults
5667 && std::strcmp(node.Name,
"ContainerName") == 0)
5669 ret.BlobContainerName = node.Value;
5676 static BlobItem BlobItemFromXml(_internal::XmlReader& reader)
5679 enum class XmlTagName
5692 k_ContentDisposition,
5701 k_AccessTierInferred,
5706 k_EncryptionKeySHA256,
5708 k_xmsblobsequencenumber,
5713 std::vector<XmlTagName> path;
5716 auto node = reader.Read();
5717 if (node.Type == _internal::XmlNodeType::End)
5721 else if (node.Type == _internal::XmlNodeType::EndTag)
5723 if (path.size() > 0)
5732 else if (node.Type == _internal::XmlNodeType::StartTag)
5734 if (std::strcmp(node.Name,
"Name") == 0)
5736 path.emplace_back(XmlTagName::k_Name);
5738 else if (std::strcmp(node.Name,
"Deleted") == 0)
5740 path.emplace_back(XmlTagName::k_Deleted);
5742 else if (std::strcmp(node.Name,
"Snapshot") == 0)
5744 path.emplace_back(XmlTagName::k_Snapshot);
5746 else if (std::strcmp(node.Name,
"VersionId") == 0)
5748 path.emplace_back(XmlTagName::k_VersionId);
5750 else if (std::strcmp(node.Name,
"IsCurrentVersion") == 0)
5752 path.emplace_back(XmlTagName::k_IsCurrentVersion);
5754 else if (std::strcmp(node.Name,
"Properties") == 0)
5756 path.emplace_back(XmlTagName::k_Properties);
5758 else if (std::strcmp(node.Name,
"Content-Type") == 0)
5760 path.emplace_back(XmlTagName::k_ContentType);
5762 else if (std::strcmp(node.Name,
"Content-Encoding") == 0)
5764 path.emplace_back(XmlTagName::k_ContentEncoding);
5766 else if (std::strcmp(node.Name,
"Content-Language") == 0)
5768 path.emplace_back(XmlTagName::k_ContentLanguage);
5770 else if (std::strcmp(node.Name,
"Content-MD5") == 0)
5772 path.emplace_back(XmlTagName::k_ContentMD5);
5774 else if (std::strcmp(node.Name,
"Cache-Control") == 0)
5776 path.emplace_back(XmlTagName::k_CacheControl);
5778 else if (std::strcmp(node.Name,
"Content-Disposition") == 0)
5780 path.emplace_back(XmlTagName::k_ContentDisposition);
5782 else if (std::strcmp(node.Name,
"Creation-Time") == 0)
5784 path.emplace_back(XmlTagName::k_CreationTime);
5786 else if (std::strcmp(node.Name,
"Expiry-Time") == 0)
5788 path.emplace_back(XmlTagName::k_ExpiryTime);
5790 else if (std::strcmp(node.Name,
"LastAccessTime") == 0)
5792 path.emplace_back(XmlTagName::k_LastAccessTime);
5794 else if (std::strcmp(node.Name,
"Last-Modified") == 0)
5796 path.emplace_back(XmlTagName::k_LastModified);
5798 else if (std::strcmp(node.Name,
"Etag") == 0)
5800 path.emplace_back(XmlTagName::k_Etag);
5802 else if (std::strcmp(node.Name,
"Content-Length") == 0)
5804 path.emplace_back(XmlTagName::k_ContentLength);
5806 else if (std::strcmp(node.Name,
"BlobType") == 0)
5808 path.emplace_back(XmlTagName::k_BlobType);
5810 else if (std::strcmp(node.Name,
"AccessTier") == 0)
5812 path.emplace_back(XmlTagName::k_AccessTier);
5814 else if (std::strcmp(node.Name,
"AccessTierInferred") == 0)
5816 path.emplace_back(XmlTagName::k_AccessTierInferred);
5818 else if (std::strcmp(node.Name,
"LeaseStatus") == 0)
5820 path.emplace_back(XmlTagName::k_LeaseStatus);
5822 else if (std::strcmp(node.Name,
"LeaseState") == 0)
5824 path.emplace_back(XmlTagName::k_LeaseState);
5826 else if (std::strcmp(node.Name,
"LeaseDuration") == 0)
5828 path.emplace_back(XmlTagName::k_LeaseDuration);
5830 else if (std::strcmp(node.Name,
"ServerEncrypted") == 0)
5832 path.emplace_back(XmlTagName::k_ServerEncrypted);
5834 else if (std::strcmp(node.Name,
"EncryptionKeySHA256") == 0)
5836 path.emplace_back(XmlTagName::k_EncryptionKeySHA256);
5838 else if (std::strcmp(node.Name,
"Sealed") == 0)
5840 path.emplace_back(XmlTagName::k_Sealed);
5842 else if (std::strcmp(node.Name,
"x-ms-blob-sequence-number") == 0)
5844 path.emplace_back(XmlTagName::k_xmsblobsequencenumber);
5846 else if (std::strcmp(node.Name,
"Metadata") == 0)
5848 path.emplace_back(XmlTagName::k_Metadata);
5850 else if (std::strcmp(node.Name,
"OrMetadata") == 0)
5852 path.emplace_back(XmlTagName::k_OrMetadata);
5856 path.emplace_back(XmlTagName::k_Unknown);
5858 if (path.size() == 1 && path[0] == XmlTagName::k_Metadata)
5860 ret.Details.Metadata = MetadataFromXml(reader);
5863 else if (path.size() == 1 && path[0] == XmlTagName::k_OrMetadata)
5865 ret.Details.ObjectReplicationSourceProperties
5866 = ObjectReplicationSourcePropertiesFromXml(reader);
5870 else if (node.Type == _internal::XmlNodeType::Text)
5872 if (path.size() == 1 && path[0] == XmlTagName::k_Name)
5874 ret.Name = node.Value;
5876 else if (path.size() == 1 && path[0] == XmlTagName::k_Deleted)
5878 ret.IsDeleted = std::strcmp(node.Value,
"true") == 0;
5880 else if (path.size() == 1 && path[0] == XmlTagName::k_Snapshot)
5882 ret.Snapshot = node.Value;
5884 else if (path.size() == 1 && path[0] == XmlTagName::k_VersionId)
5886 ret.VersionId = node.Value;
5888 else if (path.size() == 1 && path[0] == XmlTagName::k_IsCurrentVersion)
5890 ret.IsCurrentVersion = std::strcmp(node.Value,
"true") == 0;
5893 path.size() == 2 && path[0] == XmlTagName::k_Properties
5894 && path[1] == XmlTagName::k_ContentType)
5896 ret.Details.HttpHeaders.ContentType = node.Value;
5899 path.size() == 2 && path[0] == XmlTagName::k_Properties
5900 && path[1] == XmlTagName::k_ContentEncoding)
5902 ret.Details.HttpHeaders.ContentEncoding = node.Value;
5905 path.size() == 2 && path[0] == XmlTagName::k_Properties
5906 && path[1] == XmlTagName::k_ContentLanguage)
5908 ret.Details.HttpHeaders.ContentLanguage = node.Value;
5911 path.size() == 2 && path[0] == XmlTagName::k_Properties
5912 && path[1] == XmlTagName::k_ContentMD5)
5914 ret.Details.HttpHeaders.ContentHash.Value
5915 = Azure::Core::Convert::Base64Decode(node.Value);
5918 path.size() == 2 && path[0] == XmlTagName::k_Properties
5919 && path[1] == XmlTagName::k_CacheControl)
5921 ret.Details.HttpHeaders.CacheControl = node.Value;
5924 path.size() == 2 && path[0] == XmlTagName::k_Properties
5925 && path[1] == XmlTagName::k_ContentDisposition)
5927 ret.Details.HttpHeaders.ContentDisposition = node.Value;
5930 path.size() == 2 && path[0] == XmlTagName::k_Properties
5931 && path[1] == XmlTagName::k_CreationTime)
5933 ret.Details.CreatedOn
5934 = Azure::DateTime::Parse(node.Value, Azure::DateTime::DateFormat::Rfc1123);
5937 path.size() == 2 && path[0] == XmlTagName::k_Properties
5938 && path[1] == XmlTagName::k_ExpiryTime)
5940 ret.Details.ExpiresOn
5941 = Azure::DateTime::Parse(node.Value, Azure::DateTime::DateFormat::Rfc1123);
5944 path.size() == 2 && path[0] == XmlTagName::k_Properties
5945 && path[1] == XmlTagName::k_LastAccessTime)
5947 ret.Details.LastAccessedOn
5948 = Azure::DateTime::Parse(node.Value, Azure::DateTime::DateFormat::Rfc1123);
5951 path.size() == 2 && path[0] == XmlTagName::k_Properties
5952 && path[1] == XmlTagName::k_LastModified)
5954 ret.Details.LastModified
5955 = Azure::DateTime::Parse(node.Value, Azure::DateTime::DateFormat::Rfc1123);
5958 path.size() == 2 && path[0] == XmlTagName::k_Properties
5959 && path[1] == XmlTagName::k_Etag)
5961 ret.Details.ETag = Azure::ETag(node.Value);
5964 path.size() == 2 && path[0] == XmlTagName::k_Properties
5965 && path[1] == XmlTagName::k_ContentLength)
5967 ret.BlobSize = std::stoll(node.Value);
5970 path.size() == 2 && path[0] == XmlTagName::k_Properties
5971 && path[1] == XmlTagName::k_BlobType)
5973 ret.BlobType = BlobType(node.Value);
5976 path.size() == 2 && path[0] == XmlTagName::k_Properties
5977 && path[1] == XmlTagName::k_AccessTier)
5979 ret.Details.AccessTier = AccessTier(node.Value);
5982 path.size() == 2 && path[0] == XmlTagName::k_Properties
5983 && path[1] == XmlTagName::k_AccessTierInferred)
5985 ret.Details.IsAccessTierInferred = std::strcmp(node.Value,
"true") == 0;
5988 path.size() == 2 && path[0] == XmlTagName::k_Properties
5989 && path[1] == XmlTagName::k_LeaseStatus)
5991 ret.Details.LeaseStatus = LeaseStatus(node.Value);
5994 path.size() == 2 && path[0] == XmlTagName::k_Properties
5995 && path[1] == XmlTagName::k_LeaseState)
5997 ret.Details.LeaseState = LeaseState(node.Value);
6000 path.size() == 2 && path[0] == XmlTagName::k_Properties
6001 && path[1] == XmlTagName::k_LeaseDuration)
6003 ret.Details.LeaseDuration = LeaseDurationType(node.Value);
6006 path.size() == 2 && path[0] == XmlTagName::k_Properties
6007 && path[1] == XmlTagName::k_ServerEncrypted)
6009 ret.Details.IsServerEncrypted = std::strcmp(node.Value,
"true") == 0;
6012 path.size() == 2 && path[0] == XmlTagName::k_Properties
6013 && path[1] == XmlTagName::k_EncryptionKeySHA256)
6015 ret.Details.EncryptionKeySha256 = Azure::Core::Convert::Base64Decode(node.Value);
6018 path.size() == 2 && path[0] == XmlTagName::k_Properties
6019 && path[1] == XmlTagName::k_Sealed)
6021 ret.Details.IsSealed = std::strcmp(node.Value,
"true") == 0;
6024 path.size() == 2 && path[0] == XmlTagName::k_Properties
6025 && path[1] == XmlTagName::k_xmsblobsequencenumber)
6027 ret.Details.SequenceNumber = std::stoll(node.Value);
6034 static SignedIdentifier SignedIdentifierFromXml(_internal::XmlReader& reader)
6036 SignedIdentifier ret;
6037 enum class XmlTagName
6046 std::vector<XmlTagName> path;
6049 auto node = reader.Read();
6050 if (node.Type == _internal::XmlNodeType::End)
6054 else if (node.Type == _internal::XmlNodeType::EndTag)
6056 if (path.size() > 0)
6065 else if (node.Type == _internal::XmlNodeType::StartTag)
6067 if (std::strcmp(node.Name,
"Id") == 0)
6069 path.emplace_back(XmlTagName::k_Id);
6071 else if (std::strcmp(node.Name,
"AccessPolicy") == 0)
6073 path.emplace_back(XmlTagName::k_AccessPolicy);
6075 else if (std::strcmp(node.Name,
"Start") == 0)
6077 path.emplace_back(XmlTagName::k_Start);
6079 else if (std::strcmp(node.Name,
"Expiry") == 0)
6081 path.emplace_back(XmlTagName::k_Expiry);
6083 else if (std::strcmp(node.Name,
"Permission") == 0)
6085 path.emplace_back(XmlTagName::k_Permission);
6089 path.emplace_back(XmlTagName::k_Unknown);
6092 else if (node.Type == _internal::XmlNodeType::Text)
6094 if (path.size() == 1 && path[0] == XmlTagName::k_Id)
6096 ret.Id = node.Value;
6099 path.size() == 2 && path[0] == XmlTagName::k_AccessPolicy
6100 && path[1] == XmlTagName::k_Start)
6103 = Azure::DateTime::Parse(node.Value, Azure::DateTime::DateFormat::Rfc3339);
6106 path.size() == 2 && path[0] == XmlTagName::k_AccessPolicy
6107 && path[1] == XmlTagName::k_Expiry)
6110 = Azure::DateTime::Parse(node.Value, Azure::DateTime::DateFormat::Rfc3339);
6113 path.size() == 2 && path[0] == XmlTagName::k_AccessPolicy
6114 && path[1] == XmlTagName::k_Permission)
6116 ret.Permissions = node.Value;
6123 static std::vector<ObjectReplicationPolicy> ObjectReplicationSourcePropertiesFromXml(
6124 _internal::XmlReader& reader)
6127 std::map<std::string, std::vector<ObjectReplicationRule>> orPropertiesMap;
6128 std::string policyId;
6132 auto node = reader.Read();
6133 if (node.Type == _internal::XmlNodeType::End)
6137 else if (node.Type == _internal::XmlNodeType::StartTag)
6140 std::string startTagName = node.Name;
6141 if (startTagName.substr(0, 3) ==
"or-")
6143 auto underscorePos = startTagName.find(
'_', 3);
6145 = std::string(startTagName.begin() + 3, startTagName.begin() + underscorePos);
6146 ruleId = startTagName.substr(underscorePos + 1);
6149 else if (node.Type == _internal::XmlNodeType::EndTag)
6156 if (depth == 1 && node.Type == _internal::XmlNodeType::Text)
6158 ObjectReplicationRule rule;
6159 rule.RuleId = std::move(ruleId);
6160 rule.ReplicationStatus = ObjectReplicationStatus(node.Value);
6161 orPropertiesMap[policyId].emplace_back(std::move(rule));
6164 std::vector<ObjectReplicationPolicy> ret;
6165 for (
auto& property : orPropertiesMap)
6167 ObjectReplicationPolicy policy;
6168 policy.PolicyId =
property.first;
6169 policy.Rules = std::move(property.second);
6170 ret.emplace_back(std::move(policy));
6175 static Metadata MetadataFromXml(_internal::XmlReader& reader)
6182 auto node = reader.Read();
6183 if (node.Type == _internal::XmlNodeType::End)
6187 else if (node.Type == _internal::XmlNodeType::StartTag)
6194 else if (node.Type == _internal::XmlNodeType::EndTag)
6201 else if (depth == 1 && node.Type == _internal::XmlNodeType::Text)
6203 ret.emplace(std::move(key), std::string(node.Value));
6209 static void SetBlobContainerAccessPolicyOptionsToXml(
6210 _internal::XmlWriter& writer,
6211 const SetBlobContainerAccessPolicyOptions& options)
6213 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"SignedIdentifiers"});
6214 for (
const auto& i : options.SignedIdentifiers)
6216 SignedIdentifierToXml(writer, i);
6218 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
6221 static void SignedIdentifierToXml(
6222 _internal::XmlWriter& writer,
6223 const SignedIdentifier& options)
6225 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"SignedIdentifier"});
6226 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"Id"});
6228 _internal::XmlNode{_internal::XmlNodeType::Text,
nullptr, options.Id.data()});
6229 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
6230 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"AccessPolicy"});
6231 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"Start"});
6232 writer.Write(_internal::XmlNode{
6233 _internal::XmlNodeType::Text,
6237 Azure::DateTime::DateFormat::Rfc3339,
6238 Azure::DateTime::TimeFractionFormat::AllDigits)
6240 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
6241 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"Expiry"});
6242 writer.Write(_internal::XmlNode{
6243 _internal::XmlNodeType::Text,
6247 Azure::DateTime::DateFormat::Rfc3339,
6248 Azure::DateTime::TimeFractionFormat::AllDigits)
6250 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
6251 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"Permission"});
6252 writer.Write(_internal::XmlNode{
6253 _internal::XmlNodeType::Text,
nullptr, options.Permissions.data()});
6254 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
6255 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
6256 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
6263 struct DownloadBlobOptions final
6265 Azure::Nullable<int32_t> Timeout;
6266 Azure::Nullable<Azure::Core::Http::HttpRange> Range;
6267 Azure::Nullable<HashAlgorithm> RangeHashAlgorithm;
6268 Azure::Nullable<std::string> EncryptionKey;
6269 Azure::Nullable<std::vector<uint8_t>> EncryptionKeySha256;
6270 Azure::Nullable<EncryptionAlgorithmType> EncryptionAlgorithm;
6271 Azure::Nullable<std::string> LeaseId;
6272 Azure::Nullable<Azure::DateTime> IfModifiedSince;
6273 Azure::Nullable<Azure::DateTime> IfUnmodifiedSince;
6274 Azure::ETag IfMatch;
6275 Azure::ETag IfNoneMatch;
6276 Azure::Nullable<std::string> IfTags;
6279 static Azure::Response<DownloadBlobResult> Download(
6280 Azure::Core::Http::_internal::HttpPipeline& pipeline,
6281 const Azure::Core::Url& url,
6282 const DownloadBlobOptions& options,
6283 const Azure::Core::Context& context)
6286 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url,
false);
6287 request.SetHeader(
"x-ms-version",
"2020-02-10");
6288 if (options.Timeout.HasValue())
6290 request.GetUrl().AppendQueryParameter(
6291 "timeout", std::to_string(options.Timeout.Value()));
6293 if (options.Range.HasValue())
6295 std::string headerValue =
"bytes=" + std::to_string(options.Range.Value().Offset) +
"-";
6296 if (options.Range.Value().Length.HasValue())
6298 headerValue += std::to_string(
6299 options.Range.Value().Offset + options.Range.Value().Length.Value() - 1);
6301 request.SetHeader(
"x-ms-range", std::move(headerValue));
6303 if (options.EncryptionKey.HasValue())
6305 request.SetHeader(
"x-ms-encryption-key", options.EncryptionKey.Value());
6307 if (options.EncryptionKeySha256.HasValue())
6310 "x-ms-encryption-key-sha256",
6311 Azure::Core::Convert::Base64Encode(options.EncryptionKeySha256.Value()));
6313 if (options.EncryptionAlgorithm.HasValue())
6316 "x-ms-encryption-algorithm", options.EncryptionAlgorithm.Value().ToString());
6318 if (options.IfModifiedSince.HasValue())
6321 "If-Modified-Since",
6322 options.IfModifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
6324 if (options.IfUnmodifiedSince.HasValue())
6327 "If-Unmodified-Since",
6328 options.IfUnmodifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
6330 if (options.IfMatch.HasValue() && !options.IfMatch.ToString().empty())
6332 request.SetHeader(
"If-Match", options.IfMatch.ToString());
6334 if (options.IfNoneMatch.HasValue() && !options.IfNoneMatch.ToString().empty())
6336 request.SetHeader(
"If-None-Match", options.IfNoneMatch.ToString());
6338 if (options.IfTags.HasValue())
6340 request.SetHeader(
"x-ms-if-tags", options.IfTags.Value());
6342 if (options.LeaseId.HasValue())
6344 request.SetHeader(
"x-ms-lease-id", options.LeaseId.Value());
6346 if (options.RangeHashAlgorithm.HasValue())
6348 if (options.RangeHashAlgorithm.Value() == HashAlgorithm::Md5)
6350 request.SetHeader(
"x-ms-range-get-content-md5",
"true");
6352 else if (options.RangeHashAlgorithm.Value() == HashAlgorithm::Crc64)
6354 request.SetHeader(
"x-ms-range-get-content-crc64",
"true");
6357 auto pHttpResponse = pipeline.Send(request, context);
6358 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
6359 DownloadBlobResult response;
6360 auto http_status_code
6361 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
6362 httpResponse.GetStatusCode());
6363 if (!(http_status_code == 200 || http_status_code == 206))
6365 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
6367 response.BodyStream = httpResponse.ExtractBodyStream();
6369 const auto& headers = httpResponse.GetHeaders();
6370 auto content_md5_iterator = headers.find(
"content-md5");
6371 if (content_md5_iterator != headers.end())
6374 hash.Algorithm = HashAlgorithm::Md5;
6375 hash.Value = Azure::Core::Convert::Base64Decode(content_md5_iterator->second);
6376 response.TransactionalContentHash = std::move(hash);
6378 auto x_ms_content_crc64_iterator = headers.find(
"x-ms-content-crc64");
6379 if (x_ms_content_crc64_iterator != headers.end())
6382 hash.Algorithm = HashAlgorithm::Crc64;
6383 hash.Value = Azure::Core::Convert::Base64Decode(x_ms_content_crc64_iterator->second);
6384 response.TransactionalContentHash = std::move(hash);
6387 response.BlobType = BlobType(httpResponse.GetHeaders().at(
"x-ms-blob-type"));
6388 auto content_range_iterator = httpResponse.GetHeaders().find(
"content-range");
6389 if (content_range_iterator != httpResponse.GetHeaders().end())
6391 const std::string& content_range = content_range_iterator->second;
6392 auto bytes_pos = content_range.find(
"bytes ");
6393 auto dash_pos = content_range.find(
"-", bytes_pos + 6);
6394 auto slash_pos = content_range.find(
"/", dash_pos + 1);
6395 int64_t range_start_offset = std::stoll(std::string(
6396 content_range.begin() + bytes_pos + 6, content_range.begin() + dash_pos));
6397 int64_t range_end_offset = std::stoll(std::string(
6398 content_range.begin() + dash_pos + 1, content_range.begin() + slash_pos));
6399 response.ContentRange = Azure::Core::Http::HttpRange{
6400 range_start_offset, range_end_offset - range_start_offset + 1};
6404 response.ContentRange = Azure::Core::Http::HttpRange{
6405 0, std::stoll(httpResponse.GetHeaders().at(
"content-length"))};
6407 if (content_range_iterator != httpResponse.GetHeaders().end())
6409 const std::string& content_range = content_range_iterator->second;
6410 auto slash_pos = content_range.find(
"/");
6411 response.BlobSize = std::stoll(content_range.substr(slash_pos + 1));
6415 response.BlobSize = std::stoll(httpResponse.GetHeaders().at(
"content-length"));
6417 response.Details.ETag = Azure::ETag(httpResponse.GetHeaders().at(
"etag"));
6418 response.Details.LastModified = Azure::DateTime::Parse(
6419 httpResponse.GetHeaders().at(
"last-modified"), Azure::DateTime::DateFormat::Rfc1123);
6420 auto content_type__iterator = httpResponse.GetHeaders().find(
"content-type");
6421 if (content_type__iterator != httpResponse.GetHeaders().end())
6423 response.Details.HttpHeaders.ContentType = content_type__iterator->second;
6425 auto content_encoding__iterator = httpResponse.GetHeaders().find(
"content-encoding");
6426 if (content_encoding__iterator != httpResponse.GetHeaders().end())
6428 response.Details.HttpHeaders.ContentEncoding = content_encoding__iterator->second;
6430 auto content_language__iterator = httpResponse.GetHeaders().find(
"content-language");
6431 if (content_language__iterator != httpResponse.GetHeaders().end())
6433 response.Details.HttpHeaders.ContentLanguage = content_language__iterator->second;
6435 auto cache_control__iterator = httpResponse.GetHeaders().find(
"cache-control");
6436 if (cache_control__iterator != httpResponse.GetHeaders().end())
6438 response.Details.HttpHeaders.CacheControl = cache_control__iterator->second;
6440 auto content_md5__iterator = httpResponse.GetHeaders().find(
"content-md5");
6441 if (content_md5__iterator != httpResponse.GetHeaders().end())
6443 response.Details.HttpHeaders.ContentHash.Value
6444 = Azure::Core::Convert::Base64Decode(content_md5__iterator->second);
6446 auto x_ms_blob_content_md5__iterator
6447 = httpResponse.GetHeaders().find(
"x-ms-blob-content-md5");
6448 if (x_ms_blob_content_md5__iterator != httpResponse.GetHeaders().end())
6450 response.Details.HttpHeaders.ContentHash.Value
6451 = Azure::Core::Convert::Base64Decode(x_ms_blob_content_md5__iterator->second);
6453 auto content_disposition__iterator
6454 = httpResponse.GetHeaders().find(
"content-disposition");
6455 if (content_disposition__iterator != httpResponse.GetHeaders().end())
6457 response.Details.HttpHeaders.ContentDisposition = content_disposition__iterator->second;
6459 for (
auto i = httpResponse.GetHeaders().lower_bound(
"x-ms-meta-");
6460 i != httpResponse.GetHeaders().end() && i->first.substr(0, 10) ==
"x-ms-meta-";
6463 response.Details.Metadata.emplace(i->first.substr(10), i->second);
6465 response.Details.IsServerEncrypted
6466 = httpResponse.GetHeaders().at(
"x-ms-server-encrypted") ==
"true";
6467 auto x_ms_encryption_key_sha256__iterator
6468 = httpResponse.GetHeaders().find(
"x-ms-encryption-key-sha256");
6469 if (x_ms_encryption_key_sha256__iterator != httpResponse.GetHeaders().end())
6471 response.Details.EncryptionKeySha256
6472 = Azure::Core::Convert::Base64Decode(x_ms_encryption_key_sha256__iterator->second);
6474 auto x_ms_encryption_scope__iterator
6475 = httpResponse.GetHeaders().find(
"x-ms-encryption-scope");
6476 if (x_ms_encryption_scope__iterator != httpResponse.GetHeaders().end())
6478 response.Details.EncryptionScope = x_ms_encryption_scope__iterator->second;
6480 auto x_ms_lease_status__iterator = httpResponse.GetHeaders().find(
"x-ms-lease-status");
6481 if (x_ms_lease_status__iterator != httpResponse.GetHeaders().end())
6483 response.Details.LeaseStatus = LeaseStatus(x_ms_lease_status__iterator->second);
6485 auto x_ms_lease_state__iterator = httpResponse.GetHeaders().find(
"x-ms-lease-state");
6486 if (x_ms_lease_state__iterator != httpResponse.GetHeaders().end())
6488 response.Details.LeaseState = LeaseState(x_ms_lease_state__iterator->second);
6490 auto x_ms_lease_duration__iterator
6491 = httpResponse.GetHeaders().find(
"x-ms-lease-duration");
6492 if (x_ms_lease_duration__iterator != httpResponse.GetHeaders().end())
6494 response.Details.LeaseDuration
6495 = LeaseDurationType(x_ms_lease_duration__iterator->second);
6497 response.Details.CreatedOn = Azure::DateTime::Parse(
6498 httpResponse.GetHeaders().at(
"x-ms-creation-time"),
6499 Azure::DateTime::DateFormat::Rfc1123);
6500 auto x_ms_expiry_time__iterator = httpResponse.GetHeaders().find(
"x-ms-expiry-time");
6501 if (x_ms_expiry_time__iterator != httpResponse.GetHeaders().end())
6503 response.Details.ExpiresOn = Azure::DateTime::Parse(
6504 x_ms_expiry_time__iterator->second, Azure::DateTime::DateFormat::Rfc1123);
6506 auto x_ms_last_access_time__iterator
6507 = httpResponse.GetHeaders().find(
"x-ms-last-access-time");
6508 if (x_ms_last_access_time__iterator != httpResponse.GetHeaders().end())
6510 response.Details.LastAccessedOn = Azure::DateTime::Parse(
6511 x_ms_last_access_time__iterator->second, Azure::DateTime::DateFormat::Rfc1123);
6513 auto x_ms_blob_sequence_number__iterator
6514 = httpResponse.GetHeaders().find(
"x-ms-blob-sequence-number");
6515 if (x_ms_blob_sequence_number__iterator != httpResponse.GetHeaders().end())
6517 response.Details.SequenceNumber
6518 = std::stoll(x_ms_blob_sequence_number__iterator->second);
6520 auto x_ms_blob_committed_block_count__iterator
6521 = httpResponse.GetHeaders().find(
"x-ms-blob-committed-block-count");
6522 if (x_ms_blob_committed_block_count__iterator != httpResponse.GetHeaders().end())
6524 response.Details.CommittedBlockCount
6525 = std::stoi(x_ms_blob_committed_block_count__iterator->second);
6527 auto x_ms_blob_sealed__iterator = httpResponse.GetHeaders().find(
"x-ms-blob-sealed");
6528 if (x_ms_blob_sealed__iterator != httpResponse.GetHeaders().end())
6530 response.Details.IsSealed = x_ms_blob_sealed__iterator->second ==
"true";
6532 auto x_ms_or_policy_id__iterator = httpResponse.GetHeaders().find(
"x-ms-or-policy-id");
6533 if (x_ms_or_policy_id__iterator != httpResponse.GetHeaders().end())
6535 response.Details.ObjectReplicationDestinationPolicyId
6536 = x_ms_or_policy_id__iterator->second;
6539 std::map<std::string, std::vector<ObjectReplicationRule>> orPropertiesMap;
6540 for (
auto i = httpResponse.GetHeaders().lower_bound(
"x-ms-or-");
6541 i != httpResponse.GetHeaders().end() && i->first.substr(0, 8) ==
"x-ms-or-";
6544 const std::string& header = i->first;
6545 auto underscorePos = header.find(
'_', 8);
6546 if (underscorePos == std::string::npos)
6550 std::string policyId
6551 = std::string(header.begin() + 8, header.begin() + underscorePos);
6552 std::string ruleId = header.substr(underscorePos + 1);
6554 ObjectReplicationRule rule;
6555 rule.RuleId = std::move(ruleId);
6556 rule.ReplicationStatus = ObjectReplicationStatus(i->second);
6557 orPropertiesMap[policyId].emplace_back(std::move(rule));
6559 for (
auto& property : orPropertiesMap)
6561 ObjectReplicationPolicy policy;
6562 policy.PolicyId =
property.first;
6563 policy.Rules = std::move(property.second);
6564 response.Details.ObjectReplicationSourceProperties.emplace_back(std::move(policy));
6567 auto x_ms_tag_count__iterator = httpResponse.GetHeaders().find(
"x-ms-tag-count");
6568 if (x_ms_tag_count__iterator != httpResponse.GetHeaders().end())
6570 response.Details.TagCount = std::stoi(x_ms_tag_count__iterator->second);
6572 auto x_ms_copy_id__iterator = httpResponse.GetHeaders().find(
"x-ms-copy-id");
6573 if (x_ms_copy_id__iterator != httpResponse.GetHeaders().end())
6575 response.Details.CopyId = x_ms_copy_id__iterator->second;
6577 auto x_ms_copy_source__iterator = httpResponse.GetHeaders().find(
"x-ms-copy-source");
6578 if (x_ms_copy_source__iterator != httpResponse.GetHeaders().end())
6580 response.Details.CopySource = x_ms_copy_source__iterator->second;
6582 auto x_ms_copy_status__iterator = httpResponse.GetHeaders().find(
"x-ms-copy-status");
6583 if (x_ms_copy_status__iterator != httpResponse.GetHeaders().end())
6585 response.Details.CopyStatus = CopyStatus(x_ms_copy_status__iterator->second);
6587 auto x_ms_copy_status_description__iterator
6588 = httpResponse.GetHeaders().find(
"x-ms-copy-status-description");
6589 if (x_ms_copy_status_description__iterator != httpResponse.GetHeaders().end())
6591 response.Details.CopyStatusDescription = x_ms_copy_status_description__iterator->second;
6593 auto x_ms_copy_progress__iterator = httpResponse.GetHeaders().find(
"x-ms-copy-progress");
6594 if (x_ms_copy_progress__iterator != httpResponse.GetHeaders().end())
6596 response.Details.CopyProgress = x_ms_copy_progress__iterator->second;
6598 auto x_ms_copy_completion_time__iterator
6599 = httpResponse.GetHeaders().find(
"x-ms-copy-completion-time");
6600 if (x_ms_copy_completion_time__iterator != httpResponse.GetHeaders().end())
6602 response.Details.CopyCompletedOn = Azure::DateTime::Parse(
6603 x_ms_copy_completion_time__iterator->second, Azure::DateTime::DateFormat::Rfc1123);
6605 auto x_ms_version_id__iterator = httpResponse.GetHeaders().find(
"x-ms-version-id");
6606 if (x_ms_version_id__iterator != httpResponse.GetHeaders().end())
6608 response.Details.VersionId = x_ms_version_id__iterator->second;
6610 auto x_ms_is_current_version__iterator
6611 = httpResponse.GetHeaders().find(
"x-ms-is-current-version");
6612 if (x_ms_is_current_version__iterator != httpResponse.GetHeaders().end())
6614 response.Details.IsCurrentVersion = x_ms_is_current_version__iterator->second ==
"true";
6616 return Azure::Response<DownloadBlobResult>(std::move(response), std::move(pHttpResponse));
6619 struct DeleteBlobOptions final
6621 Azure::Nullable<int32_t> Timeout;
6622 Azure::Nullable<DeleteSnapshotsOption> DeleteSnapshots;
6623 Azure::Nullable<std::string> LeaseId;
6624 Azure::Nullable<Azure::DateTime> IfModifiedSince;
6625 Azure::Nullable<Azure::DateTime> IfUnmodifiedSince;
6626 Azure::ETag IfMatch;
6627 Azure::ETag IfNoneMatch;
6628 Azure::Nullable<std::string> IfTags;
6631 static Azure::Core::Http::Request DeleteCreateMessage(
6632 const Azure::Core::Url& url,
6633 const DeleteBlobOptions& options)
6636 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Delete, url);
6637 request.SetHeader(
"x-ms-version",
"2020-02-10");
6638 if (options.Timeout.HasValue())
6640 request.GetUrl().AppendQueryParameter(
6641 "timeout", std::to_string(options.Timeout.Value()));
6643 if (options.DeleteSnapshots.HasValue())
6645 request.SetHeader(
"x-ms-delete-snapshots", options.DeleteSnapshots.Value().ToString());
6647 if (options.LeaseId.HasValue())
6649 request.SetHeader(
"x-ms-lease-id", options.LeaseId.Value());
6651 if (options.IfModifiedSince.HasValue())
6654 "If-Modified-Since",
6655 options.IfModifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
6657 if (options.IfUnmodifiedSince.HasValue())
6660 "If-Unmodified-Since",
6661 options.IfUnmodifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
6663 if (options.IfMatch.HasValue() && !options.IfMatch.ToString().empty())
6665 request.SetHeader(
"If-Match", options.IfMatch.ToString());
6667 if (options.IfNoneMatch.HasValue() && !options.IfNoneMatch.ToString().empty())
6669 request.SetHeader(
"If-None-Match", options.IfNoneMatch.ToString());
6671 if (options.IfTags.HasValue())
6673 request.SetHeader(
"x-ms-if-tags", options.IfTags.Value());
6678 static Azure::Response<DeleteBlobResult> DeleteCreateResponse(
6679 std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse,
6680 const Azure::Core::Context& context)
6683 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
6684 DeleteBlobResult response;
6685 auto http_status_code
6686 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
6687 httpResponse.GetStatusCode());
6688 if (!(http_status_code == 202))
6690 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
6692 return Azure::Response<DeleteBlobResult>(std::move(response), std::move(pHttpResponse));
6695 static Azure::Response<DeleteBlobResult> Delete(
6696 Azure::Core::Http::_internal::HttpPipeline& pipeline,
6697 const Azure::Core::Url& url,
6698 const DeleteBlobOptions& options,
6699 const Azure::Core::Context& context)
6701 auto request = DeleteCreateMessage(url, options);
6702 auto pHttpResponse = pipeline.Send(request, context);
6703 return DeleteCreateResponse(std::move(pHttpResponse), context);
6706 struct SetBlobExpiryOptions final
6708 Azure::Nullable<int32_t> Timeout;
6709 ScheduleBlobExpiryOriginType ExpiryOrigin;
6710 Azure::Nullable<std::string> ExpiryTime;
6713 static Azure::Response<SetBlobExpiryResult> ScheduleDeletion(
6714 Azure::Core::Http::_internal::HttpPipeline& pipeline,
6715 const Azure::Core::Url& url,
6716 const SetBlobExpiryOptions& options,
6717 const Azure::Core::Context& context)
6720 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
6721 request.SetHeader(
"Content-Length",
"0");
6722 request.SetHeader(
"x-ms-version",
"2020-02-10");
6723 if (options.Timeout.HasValue())
6725 request.GetUrl().AppendQueryParameter(
6726 "timeout", std::to_string(options.Timeout.Value()));
6728 request.GetUrl().AppendQueryParameter(
"comp",
"expiry");
6729 request.SetHeader(
"x-ms-expiry-option", options.ExpiryOrigin.ToString());
6730 if (options.ExpiryTime.HasValue())
6732 request.SetHeader(
"x-ms-expiry-time", options.ExpiryTime.Value());
6734 auto pHttpResponse = pipeline.Send(request, context);
6735 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
6736 SetBlobExpiryResult response;
6737 auto http_status_code
6738 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
6739 httpResponse.GetStatusCode());
6740 if (!(http_status_code == 200))
6742 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
6744 return Azure::Response<SetBlobExpiryResult>(
6745 std::move(response), std::move(pHttpResponse));
6748 struct UndeleteBlobOptions final
6750 Azure::Nullable<int32_t> Timeout;
6753 static Azure::Response<UndeleteBlobResult> Undelete(
6754 Azure::Core::Http::_internal::HttpPipeline& pipeline,
6755 const Azure::Core::Url& url,
6756 const UndeleteBlobOptions& options,
6757 const Azure::Core::Context& context)
6760 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
6761 request.SetHeader(
"Content-Length",
"0");
6762 request.SetHeader(
"x-ms-version",
"2020-02-10");
6763 if (options.Timeout.HasValue())
6765 request.GetUrl().AppendQueryParameter(
6766 "timeout", std::to_string(options.Timeout.Value()));
6768 request.GetUrl().AppendQueryParameter(
"comp",
"undelete");
6769 auto pHttpResponse = pipeline.Send(request, context);
6770 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
6771 UndeleteBlobResult response;
6772 auto http_status_code
6773 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
6774 httpResponse.GetStatusCode());
6775 if (!(http_status_code == 200))
6777 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
6779 return Azure::Response<UndeleteBlobResult>(std::move(response), std::move(pHttpResponse));
6782 struct GetBlobPropertiesOptions final
6784 Azure::Nullable<int32_t> Timeout;
6785 Azure::Nullable<std::string> EncryptionKey;
6786 Azure::Nullable<std::vector<uint8_t>> EncryptionKeySha256;
6787 Azure::Nullable<EncryptionAlgorithmType> EncryptionAlgorithm;
6788 Azure::Nullable<std::string> LeaseId;
6789 Azure::Nullable<Azure::DateTime> IfModifiedSince;
6790 Azure::Nullable<Azure::DateTime> IfUnmodifiedSince;
6791 Azure::ETag IfMatch;
6792 Azure::ETag IfNoneMatch;
6793 Azure::Nullable<std::string> IfTags;
6796 static Azure::Response<BlobProperties> GetProperties(
6797 Azure::Core::Http::_internal::HttpPipeline& pipeline,
6798 const Azure::Core::Url& url,
6799 const GetBlobPropertiesOptions& options,
6800 const Azure::Core::Context& context)
6803 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Head, url);
6804 request.SetHeader(
"x-ms-version",
"2020-02-10");
6805 if (options.Timeout.HasValue())
6807 request.GetUrl().AppendQueryParameter(
6808 "timeout", std::to_string(options.Timeout.Value()));
6810 if (options.EncryptionKey.HasValue())
6812 request.SetHeader(
"x-ms-encryption-key", options.EncryptionKey.Value());
6814 if (options.EncryptionKeySha256.HasValue())
6817 "x-ms-encryption-key-sha256",
6818 Azure::Core::Convert::Base64Encode(options.EncryptionKeySha256.Value()));
6820 if (options.EncryptionAlgorithm.HasValue())
6823 "x-ms-encryption-algorithm", options.EncryptionAlgorithm.Value().ToString());
6825 if (options.LeaseId.HasValue())
6827 request.SetHeader(
"x-ms-lease-id", options.LeaseId.Value());
6829 if (options.IfModifiedSince.HasValue())
6832 "If-Modified-Since",
6833 options.IfModifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
6835 if (options.IfUnmodifiedSince.HasValue())
6838 "If-Unmodified-Since",
6839 options.IfUnmodifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
6841 if (options.IfMatch.HasValue() && !options.IfMatch.ToString().empty())
6843 request.SetHeader(
"If-Match", options.IfMatch.ToString());
6845 if (options.IfNoneMatch.HasValue() && !options.IfNoneMatch.ToString().empty())
6847 request.SetHeader(
"If-None-Match", options.IfNoneMatch.ToString());
6849 if (options.IfTags.HasValue())
6851 request.SetHeader(
"x-ms-if-tags", options.IfTags.Value());
6853 auto pHttpResponse = pipeline.Send(request, context);
6854 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
6855 BlobProperties response;
6856 auto http_status_code
6857 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
6858 httpResponse.GetStatusCode());
6859 if (!(http_status_code == 200))
6861 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
6863 response.ETag = Azure::ETag(httpResponse.GetHeaders().at(
"etag"));
6864 response.LastModified = Azure::DateTime::Parse(
6865 httpResponse.GetHeaders().at(
"last-modified"), Azure::DateTime::DateFormat::Rfc1123);
6866 response.CreatedOn = Azure::DateTime::Parse(
6867 httpResponse.GetHeaders().at(
"x-ms-creation-time"),
6868 Azure::DateTime::DateFormat::Rfc1123);
6869 auto x_ms_expiry_time__iterator = httpResponse.GetHeaders().find(
"x-ms-expiry-time");
6870 if (x_ms_expiry_time__iterator != httpResponse.GetHeaders().end())
6872 response.ExpiresOn = Azure::DateTime::Parse(
6873 x_ms_expiry_time__iterator->second, Azure::DateTime::DateFormat::Rfc1123);
6875 auto x_ms_last_access_time__iterator
6876 = httpResponse.GetHeaders().find(
"x-ms-last-access-time");
6877 if (x_ms_last_access_time__iterator != httpResponse.GetHeaders().end())
6879 response.LastAccessedOn = Azure::DateTime::Parse(
6880 x_ms_last_access_time__iterator->second, Azure::DateTime::DateFormat::Rfc1123);
6882 for (
auto i = httpResponse.GetHeaders().lower_bound(
"x-ms-meta-");
6883 i != httpResponse.GetHeaders().end() && i->first.substr(0, 10) ==
"x-ms-meta-";
6886 response.Metadata.emplace(i->first.substr(10), i->second);
6888 response.BlobType = BlobType(httpResponse.GetHeaders().at(
"x-ms-blob-type"));
6889 auto x_ms_lease_status__iterator = httpResponse.GetHeaders().find(
"x-ms-lease-status");
6890 if (x_ms_lease_status__iterator != httpResponse.GetHeaders().end())
6892 response.LeaseStatus = LeaseStatus(x_ms_lease_status__iterator->second);
6894 auto x_ms_lease_state__iterator = httpResponse.GetHeaders().find(
"x-ms-lease-state");
6895 if (x_ms_lease_state__iterator != httpResponse.GetHeaders().end())
6897 response.LeaseState = LeaseState(x_ms_lease_state__iterator->second);
6899 auto x_ms_lease_duration__iterator
6900 = httpResponse.GetHeaders().find(
"x-ms-lease-duration");
6901 if (x_ms_lease_duration__iterator != httpResponse.GetHeaders().end())
6903 response.LeaseDuration = LeaseDurationType(x_ms_lease_duration__iterator->second);
6905 response.BlobSize = std::stoll(httpResponse.GetHeaders().at(
"content-length"));
6906 auto content_type__iterator = httpResponse.GetHeaders().find(
"content-type");
6907 if (content_type__iterator != httpResponse.GetHeaders().end())
6909 response.HttpHeaders.ContentType = content_type__iterator->second;
6911 auto content_encoding__iterator = httpResponse.GetHeaders().find(
"content-encoding");
6912 if (content_encoding__iterator != httpResponse.GetHeaders().end())
6914 response.HttpHeaders.ContentEncoding = content_encoding__iterator->second;
6916 auto content_language__iterator = httpResponse.GetHeaders().find(
"content-language");
6917 if (content_language__iterator != httpResponse.GetHeaders().end())
6919 response.HttpHeaders.ContentLanguage = content_language__iterator->second;
6921 auto cache_control__iterator = httpResponse.GetHeaders().find(
"cache-control");
6922 if (cache_control__iterator != httpResponse.GetHeaders().end())
6924 response.HttpHeaders.CacheControl = cache_control__iterator->second;
6926 auto content_md5__iterator = httpResponse.GetHeaders().find(
"content-md5");
6927 if (content_md5__iterator != httpResponse.GetHeaders().end())
6929 response.HttpHeaders.ContentHash.Value
6930 = Azure::Core::Convert::Base64Decode(content_md5__iterator->second);
6932 auto x_ms_blob_content_md5__iterator
6933 = httpResponse.GetHeaders().find(
"x-ms-blob-content-md5");
6934 if (x_ms_blob_content_md5__iterator != httpResponse.GetHeaders().end())
6936 response.HttpHeaders.ContentHash.Value
6937 = Azure::Core::Convert::Base64Decode(x_ms_blob_content_md5__iterator->second);
6939 auto content_disposition__iterator
6940 = httpResponse.GetHeaders().find(
"content-disposition");
6941 if (content_disposition__iterator != httpResponse.GetHeaders().end())
6943 response.HttpHeaders.ContentDisposition = content_disposition__iterator->second;
6945 auto x_ms_blob_sequence_number__iterator
6946 = httpResponse.GetHeaders().find(
"x-ms-blob-sequence-number");
6947 if (x_ms_blob_sequence_number__iterator != httpResponse.GetHeaders().end())
6949 response.SequenceNumber = std::stoll(x_ms_blob_sequence_number__iterator->second);
6951 auto x_ms_blob_committed_block_count__iterator
6952 = httpResponse.GetHeaders().find(
"x-ms-blob-committed-block-count");
6953 if (x_ms_blob_committed_block_count__iterator != httpResponse.GetHeaders().end())
6955 response.CommittedBlockCount
6956 = std::stoi(x_ms_blob_committed_block_count__iterator->second);
6958 auto x_ms_blob_sealed__iterator = httpResponse.GetHeaders().find(
"x-ms-blob-sealed");
6959 if (x_ms_blob_sealed__iterator != httpResponse.GetHeaders().end())
6961 response.IsSealed = x_ms_blob_sealed__iterator->second ==
"true";
6963 response.IsServerEncrypted
6964 = httpResponse.GetHeaders().at(
"x-ms-server-encrypted") ==
"true";
6965 auto x_ms_encryption_key_sha256__iterator
6966 = httpResponse.GetHeaders().find(
"x-ms-encryption-key-sha256");
6967 if (x_ms_encryption_key_sha256__iterator != httpResponse.GetHeaders().end())
6969 response.EncryptionKeySha256
6970 = Azure::Core::Convert::Base64Decode(x_ms_encryption_key_sha256__iterator->second);
6972 auto x_ms_encryption_scope__iterator
6973 = httpResponse.GetHeaders().find(
"x-ms-encryption-scope");
6974 if (x_ms_encryption_scope__iterator != httpResponse.GetHeaders().end())
6976 response.EncryptionScope = x_ms_encryption_scope__iterator->second;
6978 auto x_ms_access_tier__iterator = httpResponse.GetHeaders().find(
"x-ms-access-tier");
6979 if (x_ms_access_tier__iterator != httpResponse.GetHeaders().end())
6981 response.AccessTier = AccessTier(x_ms_access_tier__iterator->second);
6983 auto x_ms_access_tier_inferred__iterator
6984 = httpResponse.GetHeaders().find(
"x-ms-access-tier-inferred");
6985 if (x_ms_access_tier_inferred__iterator != httpResponse.GetHeaders().end())
6987 response.IsAccessTierInferred = x_ms_access_tier_inferred__iterator->second ==
"true";
6989 auto x_ms_archive_status__iterator
6990 = httpResponse.GetHeaders().find(
"x-ms-archive-status");
6991 if (x_ms_archive_status__iterator != httpResponse.GetHeaders().end())
6993 response.ArchiveStatus = ArchiveStatus(x_ms_archive_status__iterator->second);
6995 auto x_ms_rehydrate_priority__iterator
6996 = httpResponse.GetHeaders().find(
"x-ms-rehydrate-priority");
6997 if (x_ms_rehydrate_priority__iterator != httpResponse.GetHeaders().end())
6999 response.RehydratePriority
7000 = RehydratePriority(x_ms_rehydrate_priority__iterator->second);
7002 auto x_ms_access_tier_change_time__iterator
7003 = httpResponse.GetHeaders().find(
"x-ms-access-tier-change-time");
7004 if (x_ms_access_tier_change_time__iterator != httpResponse.GetHeaders().end())
7006 response.AccessTierChangedOn = Azure::DateTime::Parse(
7007 x_ms_access_tier_change_time__iterator->second,
7008 Azure::DateTime::DateFormat::Rfc1123);
7010 auto x_ms_copy_id__iterator = httpResponse.GetHeaders().find(
"x-ms-copy-id");
7011 if (x_ms_copy_id__iterator != httpResponse.GetHeaders().end())
7013 response.CopyId = x_ms_copy_id__iterator->second;
7015 auto x_ms_copy_source__iterator = httpResponse.GetHeaders().find(
"x-ms-copy-source");
7016 if (x_ms_copy_source__iterator != httpResponse.GetHeaders().end())
7018 response.CopySource = x_ms_copy_source__iterator->second;
7020 auto x_ms_copy_status__iterator = httpResponse.GetHeaders().find(
"x-ms-copy-status");
7021 if (x_ms_copy_status__iterator != httpResponse.GetHeaders().end())
7023 response.CopyStatus = CopyStatus(x_ms_copy_status__iterator->second);
7025 auto x_ms_copy_status_description__iterator
7026 = httpResponse.GetHeaders().find(
"x-ms-copy-status-description");
7027 if (x_ms_copy_status_description__iterator != httpResponse.GetHeaders().end())
7029 response.CopyStatusDescription = x_ms_copy_status_description__iterator->second;
7031 auto x_ms_incremental_copy__iterator
7032 = httpResponse.GetHeaders().find(
"x-ms-incremental-copy");
7033 if (x_ms_incremental_copy__iterator != httpResponse.GetHeaders().end())
7035 response.IsIncrementalCopy = x_ms_incremental_copy__iterator->second ==
"true";
7037 auto x_ms_copy_destination_snapshot__iterator
7038 = httpResponse.GetHeaders().find(
"x-ms-copy-destination-snapshot");
7039 if (x_ms_copy_destination_snapshot__iterator != httpResponse.GetHeaders().end())
7041 response.IncrementalCopyDestinationSnapshot
7042 = x_ms_copy_destination_snapshot__iterator->second;
7044 auto x_ms_copy_progress__iterator = httpResponse.GetHeaders().find(
"x-ms-copy-progress");
7045 if (x_ms_copy_progress__iterator != httpResponse.GetHeaders().end())
7047 response.CopyProgress = x_ms_copy_progress__iterator->second;
7049 auto x_ms_copy_completion_time__iterator
7050 = httpResponse.GetHeaders().find(
"x-ms-copy-completion-time");
7051 if (x_ms_copy_completion_time__iterator != httpResponse.GetHeaders().end())
7053 response.CopyCompletedOn = Azure::DateTime::Parse(
7054 x_ms_copy_completion_time__iterator->second, Azure::DateTime::DateFormat::Rfc1123);
7056 auto x_ms_or_policy_id__iterator = httpResponse.GetHeaders().find(
"x-ms-or-policy-id");
7057 if (x_ms_or_policy_id__iterator != httpResponse.GetHeaders().end())
7059 response.ObjectReplicationDestinationPolicyId = x_ms_or_policy_id__iterator->second;
7062 std::map<std::string, std::vector<ObjectReplicationRule>> orPropertiesMap;
7063 for (
auto i = httpResponse.GetHeaders().lower_bound(
"x-ms-or-");
7064 i != httpResponse.GetHeaders().end() && i->first.substr(0, 8) ==
"x-ms-or-";
7067 const std::string& header = i->first;
7068 auto underscorePos = header.find(
'_', 8);
7069 if (underscorePos == std::string::npos)
7073 std::string policyId
7074 = std::string(header.begin() + 8, header.begin() + underscorePos);
7075 std::string ruleId = header.substr(underscorePos + 1);
7077 ObjectReplicationRule rule;
7078 rule.RuleId = std::move(ruleId);
7079 rule.ReplicationStatus = ObjectReplicationStatus(i->second);
7080 orPropertiesMap[policyId].emplace_back(std::move(rule));
7082 for (
auto& property : orPropertiesMap)
7084 ObjectReplicationPolicy policy;
7085 policy.PolicyId =
property.first;
7086 policy.Rules = std::move(property.second);
7087 response.ObjectReplicationSourceProperties.emplace_back(std::move(policy));
7090 auto x_ms_tag_count__iterator = httpResponse.GetHeaders().find(
"x-ms-tag-count");
7091 if (x_ms_tag_count__iterator != httpResponse.GetHeaders().end())
7093 response.TagCount = std::stoi(x_ms_tag_count__iterator->second);
7095 auto x_ms_version_id__iterator = httpResponse.GetHeaders().find(
"x-ms-version-id");
7096 if (x_ms_version_id__iterator != httpResponse.GetHeaders().end())
7098 response.VersionId = x_ms_version_id__iterator->second;
7100 auto x_ms_is_current_version__iterator
7101 = httpResponse.GetHeaders().find(
"x-ms-is-current-version");
7102 if (x_ms_is_current_version__iterator != httpResponse.GetHeaders().end())
7104 response.IsCurrentVersion = x_ms_is_current_version__iterator->second ==
"true";
7106 return Azure::Response<BlobProperties>(std::move(response), std::move(pHttpResponse));
7109 struct SetBlobHttpHeadersOptions final
7111 Azure::Nullable<int32_t> Timeout;
7112 BlobHttpHeaders HttpHeaders;
7113 Azure::Nullable<std::string> LeaseId;
7114 Azure::Nullable<Azure::DateTime> IfModifiedSince;
7115 Azure::Nullable<Azure::DateTime> IfUnmodifiedSince;
7116 Azure::ETag IfMatch;
7117 Azure::ETag IfNoneMatch;
7118 Azure::Nullable<std::string> IfTags;
7121 static Azure::Response<SetBlobHttpHeadersResult> SetHttpHeaders(
7122 Azure::Core::Http::_internal::HttpPipeline& pipeline,
7123 const Azure::Core::Url& url,
7124 const SetBlobHttpHeadersOptions& options,
7125 const Azure::Core::Context& context)
7128 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
7129 request.SetHeader(
"Content-Length",
"0");
7130 request.GetUrl().AppendQueryParameter(
"comp",
"properties");
7131 request.SetHeader(
"x-ms-version",
"2020-02-10");
7132 if (options.Timeout.HasValue())
7134 request.GetUrl().AppendQueryParameter(
7135 "timeout", std::to_string(options.Timeout.Value()));
7137 if (!options.HttpHeaders.ContentType.empty())
7139 request.SetHeader(
"x-ms-blob-content-type", options.HttpHeaders.ContentType);
7141 if (!options.HttpHeaders.ContentEncoding.empty())
7143 request.SetHeader(
"x-ms-blob-content-encoding", options.HttpHeaders.ContentEncoding);
7145 if (!options.HttpHeaders.ContentLanguage.empty())
7147 request.SetHeader(
"x-ms-blob-content-language", options.HttpHeaders.ContentLanguage);
7149 if (!options.HttpHeaders.CacheControl.empty())
7151 request.SetHeader(
"x-ms-blob-cache-control", options.HttpHeaders.CacheControl);
7153 if (!Azure::Core::Convert::Base64Encode(options.HttpHeaders.ContentHash.Value).empty())
7156 "x-ms-blob-content-md5",
7157 Azure::Core::Convert::Base64Encode(options.HttpHeaders.ContentHash.Value));
7159 if (!options.HttpHeaders.ContentDisposition.empty())
7162 "x-ms-blob-content-disposition", options.HttpHeaders.ContentDisposition);
7164 if (options.LeaseId.HasValue())
7166 request.SetHeader(
"x-ms-lease-id", options.LeaseId.Value());
7168 if (options.IfModifiedSince.HasValue())
7171 "If-Modified-Since",
7172 options.IfModifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
7174 if (options.IfUnmodifiedSince.HasValue())
7177 "If-Unmodified-Since",
7178 options.IfUnmodifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
7180 if (options.IfMatch.HasValue() && !options.IfMatch.ToString().empty())
7182 request.SetHeader(
"If-Match", options.IfMatch.ToString());
7184 if (options.IfNoneMatch.HasValue() && !options.IfNoneMatch.ToString().empty())
7186 request.SetHeader(
"If-None-Match", options.IfNoneMatch.ToString());
7188 if (options.IfTags.HasValue())
7190 request.SetHeader(
"x-ms-if-tags", options.IfTags.Value());
7192 auto pHttpResponse = pipeline.Send(request, context);
7193 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
7194 SetBlobHttpHeadersResult response;
7195 auto http_status_code
7196 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
7197 httpResponse.GetStatusCode());
7198 if (!(http_status_code == 200))
7200 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
7202 response.ETag = Azure::ETag(httpResponse.GetHeaders().at(
"etag"));
7203 response.LastModified = Azure::DateTime::Parse(
7204 httpResponse.GetHeaders().at(
"last-modified"), Azure::DateTime::DateFormat::Rfc1123);
7205 auto x_ms_blob_sequence_number__iterator
7206 = httpResponse.GetHeaders().find(
"x-ms-blob-sequence-number");
7207 if (x_ms_blob_sequence_number__iterator != httpResponse.GetHeaders().end())
7209 response.SequenceNumber = std::stoll(x_ms_blob_sequence_number__iterator->second);
7211 return Azure::Response<SetBlobHttpHeadersResult>(
7212 std::move(response), std::move(pHttpResponse));
7215 struct SetBlobMetadataOptions final
7217 Azure::Nullable<int32_t> Timeout;
7218 Storage::Metadata Metadata;
7219 Azure::Nullable<std::string> EncryptionKey;
7220 Azure::Nullable<std::vector<uint8_t>> EncryptionKeySha256;
7221 Azure::Nullable<EncryptionAlgorithmType> EncryptionAlgorithm;
7222 Azure::Nullable<std::string> EncryptionScope;
7223 Azure::Nullable<std::string> LeaseId;
7224 Azure::Nullable<Azure::DateTime> IfModifiedSince;
7225 Azure::Nullable<Azure::DateTime> IfUnmodifiedSince;
7226 Azure::ETag IfMatch;
7227 Azure::ETag IfNoneMatch;
7228 Azure::Nullable<std::string> IfTags;
7231 static Azure::Response<SetBlobMetadataResult> SetMetadata(
7232 Azure::Core::Http::_internal::HttpPipeline& pipeline,
7233 const Azure::Core::Url& url,
7234 const SetBlobMetadataOptions& options,
7235 const Azure::Core::Context& context)
7238 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
7239 request.SetHeader(
"Content-Length",
"0");
7240 request.GetUrl().AppendQueryParameter(
"comp",
"metadata");
7241 request.SetHeader(
"x-ms-version",
"2020-02-10");
7242 if (options.Timeout.HasValue())
7244 request.GetUrl().AppendQueryParameter(
7245 "timeout", std::to_string(options.Timeout.Value()));
7247 for (
const auto& pair : options.Metadata)
7249 request.SetHeader(
"x-ms-meta-" + pair.first, pair.second);
7251 if (options.EncryptionKey.HasValue())
7253 request.SetHeader(
"x-ms-encryption-key", options.EncryptionKey.Value());
7255 if (options.EncryptionKeySha256.HasValue())
7258 "x-ms-encryption-key-sha256",
7259 Azure::Core::Convert::Base64Encode(options.EncryptionKeySha256.Value()));
7261 if (options.EncryptionAlgorithm.HasValue())
7264 "x-ms-encryption-algorithm", options.EncryptionAlgorithm.Value().ToString());
7266 if (options.EncryptionScope.HasValue())
7268 request.SetHeader(
"x-ms-encryption-scope", options.EncryptionScope.Value());
7270 if (options.LeaseId.HasValue())
7272 request.SetHeader(
"x-ms-lease-id", options.LeaseId.Value());
7274 if (options.IfModifiedSince.HasValue())
7277 "If-Modified-Since",
7278 options.IfModifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
7280 if (options.IfUnmodifiedSince.HasValue())
7283 "If-Unmodified-Since",
7284 options.IfUnmodifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
7286 if (options.IfMatch.HasValue() && !options.IfMatch.ToString().empty())
7288 request.SetHeader(
"If-Match", options.IfMatch.ToString());
7290 if (options.IfNoneMatch.HasValue() && !options.IfNoneMatch.ToString().empty())
7292 request.SetHeader(
"If-None-Match", options.IfNoneMatch.ToString());
7294 if (options.IfTags.HasValue())
7296 request.SetHeader(
"x-ms-if-tags", options.IfTags.Value());
7298 auto pHttpResponse = pipeline.Send(request, context);
7299 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
7300 SetBlobMetadataResult response;
7301 auto http_status_code
7302 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
7303 httpResponse.GetStatusCode());
7304 if (!(http_status_code == 200))
7306 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
7308 response.ETag = Azure::ETag(httpResponse.GetHeaders().at(
"etag"));
7309 response.LastModified = Azure::DateTime::Parse(
7310 httpResponse.GetHeaders().at(
"last-modified"), Azure::DateTime::DateFormat::Rfc1123);
7311 return Azure::Response<SetBlobMetadataResult>(
7312 std::move(response), std::move(pHttpResponse));
7315 struct SetBlobAccessTierOptions final
7317 Azure::Nullable<int32_t> Timeout;
7318 Models::AccessTier AccessTier;
7319 Azure::Nullable<Models::RehydratePriority> RehydratePriority;
7320 Azure::Nullable<std::string> IfTags;
7323 static Azure::Core::Http::Request SetAccessTierCreateMessage(
7324 const Azure::Core::Url& url,
7325 const SetBlobAccessTierOptions& options)
7328 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
7329 request.SetHeader(
"Content-Length",
"0");
7330 request.GetUrl().AppendQueryParameter(
"comp",
"tier");
7331 request.SetHeader(
"x-ms-version",
"2020-02-10");
7332 if (options.Timeout.HasValue())
7334 request.GetUrl().AppendQueryParameter(
7335 "timeout", std::to_string(options.Timeout.Value()));
7337 request.SetHeader(
"x-ms-access-tier", options.AccessTier.ToString());
7338 if (options.RehydratePriority.HasValue())
7341 "x-ms-rehydrate-priority", options.RehydratePriority.Value().ToString());
7343 if (options.IfTags.HasValue())
7345 request.SetHeader(
"x-ms-if-tags", options.IfTags.Value());
7350 static Azure::Response<SetBlobAccessTierResult> SetAccessTierCreateResponse(
7351 std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse,
7352 const Azure::Core::Context& context)
7355 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
7356 SetBlobAccessTierResult response;
7357 auto http_status_code
7358 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
7359 httpResponse.GetStatusCode());
7360 if (!(http_status_code == 200 || http_status_code == 202))
7362 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
7364 return Azure::Response<SetBlobAccessTierResult>(
7365 std::move(response), std::move(pHttpResponse));
7368 static Azure::Response<SetBlobAccessTierResult> SetAccessTier(
7369 Azure::Core::Http::_internal::HttpPipeline& pipeline,
7370 const Azure::Core::Url& url,
7371 const SetBlobAccessTierOptions& options,
7372 const Azure::Core::Context& context)
7374 auto request = SetAccessTierCreateMessage(url, options);
7375 auto pHttpResponse = pipeline.Send(request, context);
7376 return SetAccessTierCreateResponse(std::move(pHttpResponse), context);
7379 struct StartBlobCopyFromUriOptions final
7381 Azure::Nullable<int32_t> Timeout;
7382 Storage::Metadata Metadata;
7383 std::string SourceUri;
7384 Azure::Nullable<std::string> LeaseId;
7385 Azure::Nullable<std::string> SourceLeaseId;
7386 Azure::Nullable<Models::AccessTier> AccessTier;
7387 Azure::Nullable<Models::RehydratePriority> RehydratePriority;
7388 Azure::Nullable<Azure::DateTime> IfModifiedSince;
7389 Azure::Nullable<Azure::DateTime> IfUnmodifiedSince;
7390 Azure::ETag IfMatch;
7391 Azure::ETag IfNoneMatch;
7392 Azure::Nullable<std::string> IfTags;
7393 Azure::Nullable<Azure::DateTime> SourceIfModifiedSince;
7394 Azure::Nullable<Azure::DateTime> SourceIfUnmodifiedSince;
7395 Azure::ETag SourceIfMatch;
7396 Azure::ETag SourceIfNoneMatch;
7397 Azure::Nullable<std::string> SourceIfTags;
7398 Azure::Nullable<bool> ShouldSealDestination;
7401 static Azure::Response<Models::_detail::StartBlobCopyFromUriResult> StartCopyFromUri(
7402 Azure::Core::Http::_internal::HttpPipeline& pipeline,
7403 const Azure::Core::Url& url,
7404 const StartBlobCopyFromUriOptions& options,
7405 const Azure::Core::Context& context)
7408 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
7409 request.SetHeader(
"Content-Length",
"0");
7410 request.SetHeader(
"x-ms-version",
"2020-02-10");
7411 if (options.Timeout.HasValue())
7413 request.GetUrl().AppendQueryParameter(
7414 "timeout", std::to_string(options.Timeout.Value()));
7416 for (
const auto& pair : options.Metadata)
7418 request.SetHeader(
"x-ms-meta-" + pair.first, pair.second);
7420 request.SetHeader(
"x-ms-copy-source", options.SourceUri);
7421 if (options.LeaseId.HasValue())
7423 request.SetHeader(
"x-ms-lease-id", options.LeaseId.Value());
7425 if (options.SourceLeaseId.HasValue())
7427 request.SetHeader(
"x-ms-source-lease-id", options.SourceLeaseId.Value());
7429 if (options.AccessTier.HasValue())
7431 request.SetHeader(
"x-ms-access-tier", options.AccessTier.Value().ToString());
7433 if (options.RehydratePriority.HasValue())
7436 "x-ms-rehydrate-priority", options.RehydratePriority.Value().ToString());
7438 if (options.ShouldSealDestination.HasValue())
7441 "x-ms-seal-blob", options.ShouldSealDestination.Value() ?
"true" :
"false");
7443 if (options.IfModifiedSince.HasValue())
7446 "If-Modified-Since",
7447 options.IfModifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
7449 if (options.IfUnmodifiedSince.HasValue())
7452 "If-Unmodified-Since",
7453 options.IfUnmodifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
7455 if (options.IfMatch.HasValue() && !options.IfMatch.ToString().empty())
7457 request.SetHeader(
"If-Match", options.IfMatch.ToString());
7459 if (options.IfNoneMatch.HasValue() && !options.IfNoneMatch.ToString().empty())
7461 request.SetHeader(
"If-None-Match", options.IfNoneMatch.ToString());
7463 if (options.IfTags.HasValue())
7465 request.SetHeader(
"x-ms-if-tags", options.IfTags.Value());
7467 if (options.SourceIfModifiedSince.HasValue())
7470 "x-ms-source-if-modified-since",
7471 options.SourceIfModifiedSince.Value().ToString(
7472 Azure::DateTime::DateFormat::Rfc1123));
7474 if (options.SourceIfUnmodifiedSince.HasValue())
7477 "x-ms-source-if-unmodified-since",
7478 options.SourceIfUnmodifiedSince.Value().ToString(
7479 Azure::DateTime::DateFormat::Rfc1123));
7481 if (options.SourceIfMatch.HasValue() && !options.SourceIfMatch.ToString().empty())
7483 request.SetHeader(
"x-ms-source-if-match", options.SourceIfMatch.ToString());
7485 if (options.SourceIfNoneMatch.HasValue() && !options.SourceIfNoneMatch.ToString().empty())
7487 request.SetHeader(
"x-ms-source-if-none-match", options.SourceIfNoneMatch.ToString());
7489 if (options.SourceIfTags.HasValue())
7491 request.SetHeader(
"x-ms-source-if-tags", options.SourceIfTags.Value());
7493 auto pHttpResponse = pipeline.Send(request, context);
7494 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
7495 Models::_detail::StartBlobCopyFromUriResult response;
7496 auto http_status_code
7497 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
7498 httpResponse.GetStatusCode());
7499 if (!(http_status_code == 202))
7501 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
7503 response.ETag = Azure::ETag(httpResponse.GetHeaders().at(
"etag"));
7504 response.LastModified = Azure::DateTime::Parse(
7505 httpResponse.GetHeaders().at(
"last-modified"), Azure::DateTime::DateFormat::Rfc1123);
7506 response.CopyId = httpResponse.GetHeaders().at(
"x-ms-copy-id");
7507 response.CopyStatus = CopyStatus(httpResponse.GetHeaders().at(
"x-ms-copy-status"));
7508 auto x_ms_version_id__iterator = httpResponse.GetHeaders().find(
"x-ms-version-id");
7509 if (x_ms_version_id__iterator != httpResponse.GetHeaders().end())
7511 response.VersionId = x_ms_version_id__iterator->second;
7513 return Azure::Response<Models::_detail::StartBlobCopyFromUriResult>(
7514 std::move(response), std::move(pHttpResponse));
7517 struct AbortBlobCopyFromUriOptions final
7519 Azure::Nullable<int32_t> Timeout;
7521 Azure::Nullable<std::string> LeaseId;
7524 static Azure::Response<AbortBlobCopyFromUriResult> AbortCopyFromUri(
7525 Azure::Core::Http::_internal::HttpPipeline& pipeline,
7526 const Azure::Core::Url& url,
7527 const AbortBlobCopyFromUriOptions& options,
7528 const Azure::Core::Context& context)
7531 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
7532 request.SetHeader(
"Content-Length",
"0");
7533 request.SetHeader(
"x-ms-version",
"2020-02-10");
7534 if (options.Timeout.HasValue())
7536 request.GetUrl().AppendQueryParameter(
7537 "timeout", std::to_string(options.Timeout.Value()));
7539 request.GetUrl().AppendQueryParameter(
"comp",
"copy");
7540 request.GetUrl().AppendQueryParameter(
7541 "copyid", _internal::UrlEncodeQueryParameter(options.CopyId));
7542 request.SetHeader(
"x-ms-copy-action",
"abort");
7543 if (options.LeaseId.HasValue())
7545 request.SetHeader(
"x-ms-lease-id", options.LeaseId.Value());
7547 auto pHttpResponse = pipeline.Send(request, context);
7548 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
7549 AbortBlobCopyFromUriResult response;
7550 auto http_status_code
7551 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
7552 httpResponse.GetStatusCode());
7553 if (!(http_status_code == 204))
7555 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
7557 return Azure::Response<AbortBlobCopyFromUriResult>(
7558 std::move(response), std::move(pHttpResponse));
7561 struct CreateBlobSnapshotOptions final
7563 Azure::Nullable<int32_t> Timeout;
7564 Storage::Metadata Metadata;
7565 Azure::Nullable<std::string> LeaseId;
7566 Azure::Nullable<std::string> EncryptionKey;
7567 Azure::Nullable<std::vector<uint8_t>> EncryptionKeySha256;
7568 Azure::Nullable<EncryptionAlgorithmType> EncryptionAlgorithm;
7569 Azure::Nullable<std::string> EncryptionScope;
7570 Azure::Nullable<Azure::DateTime> IfModifiedSince;
7571 Azure::Nullable<Azure::DateTime> IfUnmodifiedSince;
7572 Azure::ETag IfMatch;
7573 Azure::ETag IfNoneMatch;
7574 Azure::Nullable<std::string> IfTags;
7577 static Azure::Response<CreateBlobSnapshotResult> CreateSnapshot(
7578 Azure::Core::Http::_internal::HttpPipeline& pipeline,
7579 const Azure::Core::Url& url,
7580 const CreateBlobSnapshotOptions& options,
7581 const Azure::Core::Context& context)
7584 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
7585 request.SetHeader(
"Content-Length",
"0");
7586 request.GetUrl().AppendQueryParameter(
"comp",
"snapshot");
7587 request.SetHeader(
"x-ms-version",
"2020-02-10");
7588 if (options.Timeout.HasValue())
7590 request.GetUrl().AppendQueryParameter(
7591 "timeout", std::to_string(options.Timeout.Value()));
7593 if (options.EncryptionKey.HasValue())
7595 request.SetHeader(
"x-ms-encryption-key", options.EncryptionKey.Value());
7597 if (options.EncryptionKeySha256.HasValue())
7600 "x-ms-encryption-key-sha256",
7601 Azure::Core::Convert::Base64Encode(options.EncryptionKeySha256.Value()));
7603 if (options.EncryptionAlgorithm.HasValue())
7606 "x-ms-encryption-algorithm", options.EncryptionAlgorithm.Value().ToString());
7608 if (options.EncryptionScope.HasValue())
7610 request.SetHeader(
"x-ms-encryption-scope", options.EncryptionScope.Value());
7612 for (
const auto& pair : options.Metadata)
7614 request.SetHeader(
"x-ms-meta-" + pair.first, pair.second);
7616 if (options.LeaseId.HasValue())
7618 request.SetHeader(
"x-ms-lease-id", options.LeaseId.Value());
7620 if (options.IfModifiedSince.HasValue())
7623 "If-Modified-Since",
7624 options.IfModifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
7626 if (options.IfUnmodifiedSince.HasValue())
7629 "If-Unmodified-Since",
7630 options.IfUnmodifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
7632 if (options.IfMatch.HasValue() && !options.IfMatch.ToString().empty())
7634 request.SetHeader(
"If-Match", options.IfMatch.ToString());
7636 if (options.IfNoneMatch.HasValue() && !options.IfNoneMatch.ToString().empty())
7638 request.SetHeader(
"If-None-Match", options.IfNoneMatch.ToString());
7640 if (options.IfTags.HasValue())
7642 request.SetHeader(
"x-ms-if-tags", options.IfTags.Value());
7644 auto pHttpResponse = pipeline.Send(request, context);
7645 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
7646 CreateBlobSnapshotResult response;
7647 auto http_status_code
7648 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
7649 httpResponse.GetStatusCode());
7650 if (!(http_status_code == 201))
7652 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
7654 response.ETag = Azure::ETag(httpResponse.GetHeaders().at(
"etag"));
7655 response.LastModified = Azure::DateTime::Parse(
7656 httpResponse.GetHeaders().at(
"last-modified"), Azure::DateTime::DateFormat::Rfc1123);
7657 response.IsServerEncrypted
7658 = httpResponse.GetHeaders().at(
"x-ms-request-server-encrypted") ==
"true";
7659 auto x_ms_encryption_key_sha256__iterator
7660 = httpResponse.GetHeaders().find(
"x-ms-encryption-key-sha256");
7661 if (x_ms_encryption_key_sha256__iterator != httpResponse.GetHeaders().end())
7663 response.EncryptionKeySha256
7664 = Azure::Core::Convert::Base64Decode(x_ms_encryption_key_sha256__iterator->second);
7666 auto x_ms_encryption_scope__iterator
7667 = httpResponse.GetHeaders().find(
"x-ms-encryption-scope");
7668 if (x_ms_encryption_scope__iterator != httpResponse.GetHeaders().end())
7670 response.EncryptionScope = x_ms_encryption_scope__iterator->second;
7672 response.Snapshot = httpResponse.GetHeaders().at(
"x-ms-snapshot");
7673 auto x_ms_version_id__iterator = httpResponse.GetHeaders().find(
"x-ms-version-id");
7674 if (x_ms_version_id__iterator != httpResponse.GetHeaders().end())
7676 response.VersionId = x_ms_version_id__iterator->second;
7678 return Azure::Response<CreateBlobSnapshotResult>(
7679 std::move(response), std::move(pHttpResponse));
7682 struct GetBlobTagsOptions final
7684 Azure::Nullable<int32_t> Timeout;
7685 Azure::Nullable<std::string> IfTags;
7688 static Azure::Response<Models::_detail::GetBlobTagsResult> GetTags(
7689 Azure::Core::Http::_internal::HttpPipeline& pipeline,
7690 const Azure::Core::Url& url,
7691 const GetBlobTagsOptions& options,
7692 const Azure::Core::Context& context)
7695 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url);
7696 request.SetHeader(
"x-ms-version",
"2020-02-10");
7697 if (options.Timeout.HasValue())
7699 request.GetUrl().AppendQueryParameter(
7700 "timeout", std::to_string(options.Timeout.Value()));
7702 request.GetUrl().AppendQueryParameter(
"comp",
"tags");
7703 if (options.IfTags.HasValue())
7705 request.SetHeader(
"x-ms-if-tags", options.IfTags.Value());
7707 auto pHttpResponse = pipeline.Send(request, context);
7708 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
7709 Models::_detail::GetBlobTagsResult response;
7710 auto http_status_code
7711 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
7712 httpResponse.GetStatusCode());
7713 if (!(http_status_code == 200))
7715 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
7718 const auto& httpResponseBody = httpResponse.GetBody();
7719 _internal::XmlReader reader(
7720 reinterpret_cast<const char*
>(httpResponseBody.data()), httpResponseBody.size());
7721 response = GetBlobTagsResultInternalFromXml(reader);
7723 return Azure::Response<Models::_detail::GetBlobTagsResult>(
7724 std::move(response), std::move(pHttpResponse));
7727 struct SetBlobTagsOptions final
7729 Azure::Nullable<int32_t> Timeout;
7730 std::map<std::string, std::string> Tags;
7731 Azure::Nullable<std::string> IfTags;
7734 static Azure::Response<SetBlobTagsResult> SetTags(
7735 Azure::Core::Http::_internal::HttpPipeline& pipeline,
7736 const Azure::Core::Url& url,
7737 const SetBlobTagsOptions& options,
7738 const Azure::Core::Context& context)
7741 std::string xml_body;
7743 _internal::XmlWriter writer;
7744 SetBlobTagsOptionsToXml(writer, options);
7745 xml_body = writer.GetDocument();
7746 writer.Write(_internal::XmlNode{_internal::XmlNodeType::End});
7748 Azure::Core::IO::MemoryBodyStream xml_body_stream(
7749 reinterpret_cast<const uint8_t*
>(xml_body.data()), xml_body.length());
7750 auto request = Azure::Core::Http::Request(
7751 Azure::Core::Http::HttpMethod::Put, url, &xml_body_stream);
7752 request.SetHeader(
"Content-Length", std::to_string(xml_body_stream.Length()));
7753 request.SetHeader(
"x-ms-version",
"2020-02-10");
7754 if (options.Timeout.HasValue())
7756 request.GetUrl().AppendQueryParameter(
7757 "timeout", std::to_string(options.Timeout.Value()));
7759 request.GetUrl().AppendQueryParameter(
"comp",
"tags");
7760 request.SetHeader(
"Content-Type",
"application/xml; charset=UTF-8");
7761 if (options.IfTags.HasValue())
7763 request.SetHeader(
"x-ms-if-tags", options.IfTags.Value());
7765 auto pHttpResponse = pipeline.Send(request, context);
7766 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
7767 SetBlobTagsResult response;
7768 auto http_status_code
7769 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
7770 httpResponse.GetStatusCode());
7771 if (!(http_status_code == 204))
7773 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
7775 return Azure::Response<SetBlobTagsResult>(std::move(response), std::move(pHttpResponse));
7778 struct AcquireBlobLeaseOptions final
7780 Azure::Nullable<int32_t> Timeout;
7781 std::chrono::seconds LeaseDuration;
7782 Azure::Nullable<std::string> ProposedLeaseId;
7783 Azure::Nullable<Azure::DateTime> IfModifiedSince;
7784 Azure::Nullable<Azure::DateTime> IfUnmodifiedSince;
7785 Azure::ETag IfMatch;
7786 Azure::ETag IfNoneMatch;
7787 Azure::Nullable<std::string> IfTags;
7790 static Azure::Response<Models::_detail::AcquireBlobLeaseResult> AcquireLease(
7791 Azure::Core::Http::_internal::HttpPipeline& pipeline,
7792 const Azure::Core::Url& url,
7793 const AcquireBlobLeaseOptions& options,
7794 const Azure::Core::Context& context)
7797 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
7798 request.SetHeader(
"Content-Length",
"0");
7799 request.SetHeader(
"x-ms-version",
"2020-02-10");
7800 if (options.Timeout.HasValue())
7802 request.GetUrl().AppendQueryParameter(
7803 "timeout", std::to_string(options.Timeout.Value()));
7805 request.GetUrl().AppendQueryParameter(
"comp",
"lease");
7806 request.SetHeader(
"x-ms-lease-action",
"acquire");
7807 request.SetHeader(
"x-ms-lease-duration", std::to_string(options.LeaseDuration.count()));
7808 if (options.ProposedLeaseId.HasValue())
7810 request.SetHeader(
"x-ms-proposed-lease-id", options.ProposedLeaseId.Value());
7812 if (options.IfModifiedSince.HasValue())
7815 "If-Modified-Since",
7816 options.IfModifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
7818 if (options.IfUnmodifiedSince.HasValue())
7821 "If-Unmodified-Since",
7822 options.IfUnmodifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
7824 if (options.IfMatch.HasValue() && !options.IfMatch.ToString().empty())
7826 request.SetHeader(
"If-Match", options.IfMatch.ToString());
7828 if (options.IfNoneMatch.HasValue() && !options.IfNoneMatch.ToString().empty())
7830 request.SetHeader(
"If-None-Match", options.IfNoneMatch.ToString());
7832 if (options.IfTags.HasValue())
7834 request.SetHeader(
"x-ms-if-tags", options.IfTags.Value());
7836 auto pHttpResponse = pipeline.Send(request, context);
7837 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
7838 Models::_detail::AcquireBlobLeaseResult response;
7839 auto http_status_code
7840 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
7841 httpResponse.GetStatusCode());
7842 if (!(http_status_code == 201))
7844 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
7846 response.ETag = Azure::ETag(httpResponse.GetHeaders().at(
"etag"));
7847 response.LastModified = Azure::DateTime::Parse(
7848 httpResponse.GetHeaders().at(
"last-modified"), Azure::DateTime::DateFormat::Rfc1123);
7849 response.LeaseId = httpResponse.GetHeaders().at(
"x-ms-lease-id");
7850 return Azure::Response<Models::_detail::AcquireBlobLeaseResult>(
7851 std::move(response), std::move(pHttpResponse));
7854 struct RenewBlobLeaseOptions final
7856 Azure::Nullable<int32_t> Timeout;
7857 std::string LeaseId;
7858 Azure::Nullable<Azure::DateTime> IfModifiedSince;
7859 Azure::Nullable<Azure::DateTime> IfUnmodifiedSince;
7860 Azure::ETag IfMatch;
7861 Azure::ETag IfNoneMatch;
7862 Azure::Nullable<std::string> IfTags;
7865 static Azure::Response<Models::_detail::RenewBlobLeaseResult> RenewLease(
7866 Azure::Core::Http::_internal::HttpPipeline& pipeline,
7867 const Azure::Core::Url& url,
7868 const RenewBlobLeaseOptions& options,
7869 const Azure::Core::Context& context)
7872 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
7873 request.SetHeader(
"Content-Length",
"0");
7874 request.SetHeader(
"x-ms-version",
"2020-02-10");
7875 if (options.Timeout.HasValue())
7877 request.GetUrl().AppendQueryParameter(
7878 "timeout", std::to_string(options.Timeout.Value()));
7880 request.GetUrl().AppendQueryParameter(
"comp",
"lease");
7881 request.SetHeader(
"x-ms-lease-action",
"renew");
7882 request.SetHeader(
"x-ms-lease-id", options.LeaseId);
7883 if (options.IfModifiedSince.HasValue())
7886 "If-Modified-Since",
7887 options.IfModifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
7889 if (options.IfUnmodifiedSince.HasValue())
7892 "If-Unmodified-Since",
7893 options.IfUnmodifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
7895 if (options.IfMatch.HasValue() && !options.IfMatch.ToString().empty())
7897 request.SetHeader(
"If-Match", options.IfMatch.ToString());
7899 if (options.IfNoneMatch.HasValue() && !options.IfNoneMatch.ToString().empty())
7901 request.SetHeader(
"If-None-Match", options.IfNoneMatch.ToString());
7903 if (options.IfTags.HasValue())
7905 request.SetHeader(
"x-ms-if-tags", options.IfTags.Value());
7907 auto pHttpResponse = pipeline.Send(request, context);
7908 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
7909 Models::_detail::RenewBlobLeaseResult response;
7910 auto http_status_code
7911 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
7912 httpResponse.GetStatusCode());
7913 if (!(http_status_code == 200))
7915 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
7917 response.ETag = Azure::ETag(httpResponse.GetHeaders().at(
"etag"));
7918 response.LastModified = Azure::DateTime::Parse(
7919 httpResponse.GetHeaders().at(
"last-modified"), Azure::DateTime::DateFormat::Rfc1123);
7920 response.LeaseId = httpResponse.GetHeaders().at(
"x-ms-lease-id");
7921 return Azure::Response<Models::_detail::RenewBlobLeaseResult>(
7922 std::move(response), std::move(pHttpResponse));
7925 struct ChangeBlobLeaseOptions final
7927 Azure::Nullable<int32_t> Timeout;
7928 std::string LeaseId;
7929 std::string ProposedLeaseId;
7930 Azure::Nullable<Azure::DateTime> IfModifiedSince;
7931 Azure::Nullable<Azure::DateTime> IfUnmodifiedSince;
7932 Azure::ETag IfMatch;
7933 Azure::ETag IfNoneMatch;
7934 Azure::Nullable<std::string> IfTags;
7937 static Azure::Response<Models::_detail::ChangeBlobLeaseResult> ChangeLease(
7938 Azure::Core::Http::_internal::HttpPipeline& pipeline,
7939 const Azure::Core::Url& url,
7940 const ChangeBlobLeaseOptions& options,
7941 const Azure::Core::Context& context)
7944 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
7945 request.SetHeader(
"Content-Length",
"0");
7946 request.SetHeader(
"x-ms-version",
"2020-02-10");
7947 if (options.Timeout.HasValue())
7949 request.GetUrl().AppendQueryParameter(
7950 "timeout", std::to_string(options.Timeout.Value()));
7952 request.GetUrl().AppendQueryParameter(
"comp",
"lease");
7953 request.SetHeader(
"x-ms-lease-action",
"change");
7954 request.SetHeader(
"x-ms-lease-id", options.LeaseId);
7955 request.SetHeader(
"x-ms-proposed-lease-id", options.ProposedLeaseId);
7956 if (options.IfModifiedSince.HasValue())
7959 "If-Modified-Since",
7960 options.IfModifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
7962 if (options.IfUnmodifiedSince.HasValue())
7965 "If-Unmodified-Since",
7966 options.IfUnmodifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
7968 if (options.IfMatch.HasValue() && !options.IfMatch.ToString().empty())
7970 request.SetHeader(
"If-Match", options.IfMatch.ToString());
7972 if (options.IfNoneMatch.HasValue() && !options.IfNoneMatch.ToString().empty())
7974 request.SetHeader(
"If-None-Match", options.IfNoneMatch.ToString());
7976 if (options.IfTags.HasValue())
7978 request.SetHeader(
"x-ms-if-tags", options.IfTags.Value());
7980 auto pHttpResponse = pipeline.Send(request, context);
7981 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
7982 Models::_detail::ChangeBlobLeaseResult response;
7983 auto http_status_code
7984 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
7985 httpResponse.GetStatusCode());
7986 if (!(http_status_code == 200))
7988 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
7990 response.ETag = Azure::ETag(httpResponse.GetHeaders().at(
"etag"));
7991 response.LastModified = Azure::DateTime::Parse(
7992 httpResponse.GetHeaders().at(
"last-modified"), Azure::DateTime::DateFormat::Rfc1123);
7993 response.LeaseId = httpResponse.GetHeaders().at(
"x-ms-lease-id");
7994 return Azure::Response<Models::_detail::ChangeBlobLeaseResult>(
7995 std::move(response), std::move(pHttpResponse));
7998 struct ReleaseBlobLeaseOptions final
8000 Azure::Nullable<int32_t> Timeout;
8001 std::string LeaseId;
8002 Azure::Nullable<Azure::DateTime> IfModifiedSince;
8003 Azure::Nullable<Azure::DateTime> IfUnmodifiedSince;
8004 Azure::ETag IfMatch;
8005 Azure::ETag IfNoneMatch;
8006 Azure::Nullable<std::string> IfTags;
8009 static Azure::Response<Models::_detail::ReleaseBlobLeaseResult> ReleaseLease(
8010 Azure::Core::Http::_internal::HttpPipeline& pipeline,
8011 const Azure::Core::Url& url,
8012 const ReleaseBlobLeaseOptions& options,
8013 const Azure::Core::Context& context)
8016 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
8017 request.SetHeader(
"Content-Length",
"0");
8018 request.SetHeader(
"x-ms-version",
"2020-02-10");
8019 if (options.Timeout.HasValue())
8021 request.GetUrl().AppendQueryParameter(
8022 "timeout", std::to_string(options.Timeout.Value()));
8024 request.GetUrl().AppendQueryParameter(
"comp",
"lease");
8025 request.SetHeader(
"x-ms-lease-action",
"release");
8026 request.SetHeader(
"x-ms-lease-id", options.LeaseId);
8027 if (options.IfModifiedSince.HasValue())
8030 "If-Modified-Since",
8031 options.IfModifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
8033 if (options.IfUnmodifiedSince.HasValue())
8036 "If-Unmodified-Since",
8037 options.IfUnmodifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
8039 if (options.IfMatch.HasValue() && !options.IfMatch.ToString().empty())
8041 request.SetHeader(
"If-Match", options.IfMatch.ToString());
8043 if (options.IfNoneMatch.HasValue() && !options.IfNoneMatch.ToString().empty())
8045 request.SetHeader(
"If-None-Match", options.IfNoneMatch.ToString());
8047 if (options.IfTags.HasValue())
8049 request.SetHeader(
"x-ms-if-tags", options.IfTags.Value());
8051 auto pHttpResponse = pipeline.Send(request, context);
8052 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
8053 Models::_detail::ReleaseBlobLeaseResult response;
8054 auto http_status_code
8055 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
8056 httpResponse.GetStatusCode());
8057 if (!(http_status_code == 200))
8059 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
8061 response.ETag = Azure::ETag(httpResponse.GetHeaders().at(
"etag"));
8062 response.LastModified = Azure::DateTime::Parse(
8063 httpResponse.GetHeaders().at(
"last-modified"), Azure::DateTime::DateFormat::Rfc1123);
8064 auto x_ms_blob_sequence_number__iterator
8065 = httpResponse.GetHeaders().find(
"x-ms-blob-sequence-number");
8066 if (x_ms_blob_sequence_number__iterator != httpResponse.GetHeaders().end())
8068 response.SequenceNumber = std::stoll(x_ms_blob_sequence_number__iterator->second);
8070 return Azure::Response<Models::_detail::ReleaseBlobLeaseResult>(
8071 std::move(response), std::move(pHttpResponse));
8074 struct BreakBlobLeaseOptions final
8076 Azure::Nullable<int32_t> Timeout;
8077 Azure::Nullable<std::chrono::seconds> BreakPeriod;
8078 Azure::Nullable<Azure::DateTime> IfModifiedSince;
8079 Azure::Nullable<Azure::DateTime> IfUnmodifiedSince;
8080 Azure::ETag IfMatch;
8081 Azure::ETag IfNoneMatch;
8082 Azure::Nullable<std::string> IfTags;
8085 static Azure::Response<Models::_detail::BreakBlobLeaseResult> BreakLease(
8086 Azure::Core::Http::_internal::HttpPipeline& pipeline,
8087 const Azure::Core::Url& url,
8088 const BreakBlobLeaseOptions& options,
8089 const Azure::Core::Context& context)
8092 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
8093 request.SetHeader(
"Content-Length",
"0");
8094 request.SetHeader(
"x-ms-version",
"2020-02-10");
8095 if (options.Timeout.HasValue())
8097 request.GetUrl().AppendQueryParameter(
8098 "timeout", std::to_string(options.Timeout.Value()));
8100 request.GetUrl().AppendQueryParameter(
"comp",
"lease");
8101 request.SetHeader(
"x-ms-lease-action",
"break");
8102 if (options.BreakPeriod.HasValue())
8105 "x-ms-lease-break-period", std::to_string(options.BreakPeriod.Value().count()));
8107 if (options.IfModifiedSince.HasValue())
8110 "If-Modified-Since",
8111 options.IfModifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
8113 if (options.IfUnmodifiedSince.HasValue())
8116 "If-Unmodified-Since",
8117 options.IfUnmodifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
8119 if (options.IfMatch.HasValue() && !options.IfMatch.ToString().empty())
8121 request.SetHeader(
"If-Match", options.IfMatch.ToString());
8123 if (options.IfNoneMatch.HasValue() && !options.IfNoneMatch.ToString().empty())
8125 request.SetHeader(
"If-None-Match", options.IfNoneMatch.ToString());
8127 if (options.IfTags.HasValue())
8129 request.SetHeader(
"x-ms-if-tags", options.IfTags.Value());
8131 auto pHttpResponse = pipeline.Send(request, context);
8132 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
8133 Models::_detail::BreakBlobLeaseResult response;
8134 auto http_status_code
8135 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
8136 httpResponse.GetStatusCode());
8137 if (!(http_status_code == 202))
8139 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
8141 response.ETag = Azure::ETag(httpResponse.GetHeaders().at(
"etag"));
8142 response.LastModified = Azure::DateTime::Parse(
8143 httpResponse.GetHeaders().at(
"last-modified"), Azure::DateTime::DateFormat::Rfc1123);
8144 response.LeaseTime = std::stoi(httpResponse.GetHeaders().at(
"x-ms-lease-time"));
8145 return Azure::Response<Models::_detail::BreakBlobLeaseResult>(
8146 std::move(response), std::move(pHttpResponse));
8150 static Models::_detail::GetBlobTagsResult GetBlobTagsResultInternalFromXml(
8151 _internal::XmlReader& reader)
8153 Models::_detail::GetBlobTagsResult ret;
8154 enum class XmlTagName
8160 std::vector<XmlTagName> path;
8163 auto node = reader.Read();
8164 if (node.Type == _internal::XmlNodeType::End)
8168 else if (node.Type == _internal::XmlNodeType::EndTag)
8170 if (path.size() > 0)
8179 else if (node.Type == _internal::XmlNodeType::StartTag)
8181 if (std::strcmp(node.Name,
"Tags") == 0)
8183 path.emplace_back(XmlTagName::k_Tags);
8185 else if (std::strcmp(node.Name,
"TagSet") == 0)
8187 path.emplace_back(XmlTagName::k_TagSet);
8191 path.emplace_back(XmlTagName::k_Unknown);
8193 if (path.size() == 2 && path[0] == XmlTagName::k_Tags
8194 && path[1] == XmlTagName::k_TagSet)
8196 ret.Tags = TagsFromXml(reader);
8200 else if (node.Type == _internal::XmlNodeType::Text)
8207 static std::map<std::string, std::string> TagsFromXml(_internal::XmlReader& reader)
8209 std::map<std::string, std::string> ret;
8212 bool is_key =
false;
8213 bool is_value =
false;
8216 auto node = reader.Read();
8217 if (node.Type == _internal::XmlNodeType::End)
8221 else if (node.Type == _internal::XmlNodeType::StartTag)
8224 if (strcmp(node.Name,
"Key") == 0)
8228 else if (strcmp(node.Name,
"Value") == 0)
8233 else if (node.Type == _internal::XmlNodeType::EndTag)
8240 if (depth == 2 && node.Type == _internal::XmlNodeType::Text)
8249 ret.emplace(std::move(key), node.Value);
8257 static void SetBlobTagsOptionsToXml(
8258 _internal::XmlWriter& writer,
8259 const SetBlobTagsOptions& options)
8261 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"Tags"});
8262 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"TagSet"});
8263 for (
const auto& i : options.Tags)
8265 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"Tag"});
8266 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"Key"});
8267 writer.Write(_internal::XmlNode{_internal::XmlNodeType::Text,
nullptr, i.first.data()});
8268 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
8269 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"Value"});
8271 _internal::XmlNode{_internal::XmlNodeType::Text,
nullptr, i.second.data()});
8272 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
8273 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
8275 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
8276 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
8281 class BlockBlob final {
8283 struct UploadBlockBlobOptions final
8285 Azure::Nullable<int32_t> Timeout;
8286 Azure::Nullable<ContentHash> TransactionalContentHash;
8287 BlobHttpHeaders HttpHeaders;
8288 Storage::Metadata Metadata;
8289 Azure::Nullable<std::string> LeaseId;
8290 Azure::Nullable<Models::AccessTier> AccessTier;
8291 Azure::Nullable<std::string> EncryptionKey;
8292 Azure::Nullable<std::vector<uint8_t>> EncryptionKeySha256;
8293 Azure::Nullable<EncryptionAlgorithmType> EncryptionAlgorithm;
8294 Azure::Nullable<std::string> EncryptionScope;
8295 Azure::Nullable<Azure::DateTime> IfModifiedSince;
8296 Azure::Nullable<Azure::DateTime> IfUnmodifiedSince;
8297 Azure::ETag IfMatch;
8298 Azure::ETag IfNoneMatch;
8299 Azure::Nullable<std::string> IfTags;
8302 static Azure::Response<UploadBlockBlobResult> Upload(
8303 Azure::Core::Http::_internal::HttpPipeline& pipeline,
8304 const Azure::Core::Url& url,
8305 Azure::Core::IO::BodyStream& requestBody,
8306 const UploadBlockBlobOptions& options,
8307 const Azure::Core::Context& context)
8311 = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url, &requestBody);
8312 request.SetHeader(
"Content-Length", std::to_string(requestBody.Length()));
8313 request.SetHeader(
"x-ms-version",
"2020-02-10");
8314 if (options.Timeout.HasValue())
8316 request.GetUrl().AppendQueryParameter(
8317 "timeout", std::to_string(options.Timeout.Value()));
8319 if (options.EncryptionKey.HasValue())
8321 request.SetHeader(
"x-ms-encryption-key", options.EncryptionKey.Value());
8323 if (options.EncryptionKeySha256.HasValue())
8326 "x-ms-encryption-key-sha256",
8327 Azure::Core::Convert::Base64Encode(options.EncryptionKeySha256.Value()));
8329 if (options.EncryptionAlgorithm.HasValue())
8332 "x-ms-encryption-algorithm", options.EncryptionAlgorithm.Value().ToString());
8334 if (options.EncryptionScope.HasValue())
8336 request.SetHeader(
"x-ms-encryption-scope", options.EncryptionScope.Value());
8338 if (options.TransactionalContentHash.HasValue())
8340 if (options.TransactionalContentHash.Value().Algorithm == HashAlgorithm::Md5)
8344 Azure::Core::Convert::Base64Encode(
8345 options.TransactionalContentHash.Value().Value));
8347 else if (options.TransactionalContentHash.Value().Algorithm == HashAlgorithm::Crc64)
8350 "x-ms-content-crc64",
8351 Azure::Core::Convert::Base64Encode(
8352 options.TransactionalContentHash.Value().Value));
8355 if (!options.HttpHeaders.ContentType.empty())
8357 request.SetHeader(
"x-ms-blob-content-type", options.HttpHeaders.ContentType);
8359 if (!options.HttpHeaders.ContentEncoding.empty())
8361 request.SetHeader(
"x-ms-blob-content-encoding", options.HttpHeaders.ContentEncoding);
8363 if (!options.HttpHeaders.ContentLanguage.empty())
8365 request.SetHeader(
"x-ms-blob-content-language", options.HttpHeaders.ContentLanguage);
8367 if (!options.HttpHeaders.CacheControl.empty())
8369 request.SetHeader(
"x-ms-blob-cache-control", options.HttpHeaders.CacheControl);
8371 if (!Azure::Core::Convert::Base64Encode(options.HttpHeaders.ContentHash.Value).empty())
8374 "x-ms-blob-content-md5",
8375 Azure::Core::Convert::Base64Encode(options.HttpHeaders.ContentHash.Value));
8377 if (!options.HttpHeaders.ContentDisposition.empty())
8380 "x-ms-blob-content-disposition", options.HttpHeaders.ContentDisposition);
8382 for (
const auto& pair : options.Metadata)
8384 request.SetHeader(
"x-ms-meta-" + pair.first, pair.second);
8386 if (options.LeaseId.HasValue())
8388 request.SetHeader(
"x-ms-lease-id", options.LeaseId.Value());
8390 request.SetHeader(
"x-ms-blob-type",
"BlockBlob");
8391 if (options.AccessTier.HasValue())
8393 request.SetHeader(
"x-ms-access-tier", options.AccessTier.Value().ToString());
8395 if (options.IfModifiedSince.HasValue())
8398 "If-Modified-Since",
8399 options.IfModifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
8401 if (options.IfUnmodifiedSince.HasValue())
8404 "If-Unmodified-Since",
8405 options.IfUnmodifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
8407 if (options.IfMatch.HasValue() && !options.IfMatch.ToString().empty())
8409 request.SetHeader(
"If-Match", options.IfMatch.ToString());
8411 if (options.IfNoneMatch.HasValue() && !options.IfNoneMatch.ToString().empty())
8413 request.SetHeader(
"If-None-Match", options.IfNoneMatch.ToString());
8415 if (options.IfTags.HasValue())
8417 request.SetHeader(
"x-ms-if-tags", options.IfTags.Value());
8419 auto pHttpResponse = pipeline.Send(request, context);
8420 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
8421 UploadBlockBlobResult response;
8422 auto http_status_code
8423 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
8424 httpResponse.GetStatusCode());
8425 if (!(http_status_code == 201))
8427 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
8429 response.ETag = Azure::ETag(httpResponse.GetHeaders().at(
"etag"));
8430 response.LastModified = Azure::DateTime::Parse(
8431 httpResponse.GetHeaders().at(
"last-modified"), Azure::DateTime::DateFormat::Rfc1123);
8433 const auto& headers = httpResponse.GetHeaders();
8434 auto content_md5_iterator = headers.find(
"content-md5");
8435 if (content_md5_iterator != headers.end())
8438 hash.Algorithm = HashAlgorithm::Md5;
8439 hash.Value = Azure::Core::Convert::Base64Decode(content_md5_iterator->second);
8440 response.TransactionalContentHash = std::move(hash);
8442 auto x_ms_content_crc64_iterator = headers.find(
"x-ms-content-crc64");
8443 if (x_ms_content_crc64_iterator != headers.end())
8446 hash.Algorithm = HashAlgorithm::Crc64;
8447 hash.Value = Azure::Core::Convert::Base64Decode(x_ms_content_crc64_iterator->second);
8448 response.TransactionalContentHash = std::move(hash);
8451 auto x_ms_version_id__iterator = httpResponse.GetHeaders().find(
"x-ms-version-id");
8452 if (x_ms_version_id__iterator != httpResponse.GetHeaders().end())
8454 response.VersionId = x_ms_version_id__iterator->second;
8456 response.IsServerEncrypted
8457 = httpResponse.GetHeaders().at(
"x-ms-request-server-encrypted") ==
"true";
8458 auto x_ms_encryption_key_sha256__iterator
8459 = httpResponse.GetHeaders().find(
"x-ms-encryption-key-sha256");
8460 if (x_ms_encryption_key_sha256__iterator != httpResponse.GetHeaders().end())
8462 response.EncryptionKeySha256
8463 = Azure::Core::Convert::Base64Decode(x_ms_encryption_key_sha256__iterator->second);
8465 auto x_ms_encryption_scope__iterator
8466 = httpResponse.GetHeaders().find(
"x-ms-encryption-scope");
8467 if (x_ms_encryption_scope__iterator != httpResponse.GetHeaders().end())
8469 response.EncryptionScope = x_ms_encryption_scope__iterator->second;
8471 return Azure::Response<UploadBlockBlobResult>(
8472 std::move(response), std::move(pHttpResponse));
8475 struct StageBlockOptions final
8477 Azure::Nullable<int32_t> Timeout;
8478 std::string BlockId;
8479 Azure::Nullable<ContentHash> TransactionalContentHash;
8480 Azure::Nullable<std::string> LeaseId;
8481 Azure::Nullable<std::string> EncryptionKey;
8482 Azure::Nullable<std::vector<uint8_t>> EncryptionKeySha256;
8483 Azure::Nullable<EncryptionAlgorithmType> EncryptionAlgorithm;
8484 Azure::Nullable<std::string> EncryptionScope;
8487 static Azure::Response<StageBlockResult> StageBlock(
8488 Azure::Core::Http::_internal::HttpPipeline& pipeline,
8489 const Azure::Core::Url& url,
8490 Azure::Core::IO::BodyStream& requestBody,
8491 const StageBlockOptions& options,
8492 const Azure::Core::Context& context)
8496 = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url, &requestBody);
8497 request.SetHeader(
"Content-Length", std::to_string(requestBody.Length()));
8498 request.GetUrl().AppendQueryParameter(
"comp",
"block");
8499 request.GetUrl().AppendQueryParameter(
8500 "blockid", _internal::UrlEncodeQueryParameter(options.BlockId));
8501 request.SetHeader(
"x-ms-version",
"2020-02-10");
8502 if (options.Timeout.HasValue())
8504 request.GetUrl().AppendQueryParameter(
8505 "timeout", std::to_string(options.Timeout.Value()));
8507 if (options.TransactionalContentHash.HasValue())
8509 if (options.TransactionalContentHash.Value().Algorithm == HashAlgorithm::Md5)
8513 Azure::Core::Convert::Base64Encode(
8514 options.TransactionalContentHash.Value().Value));
8516 else if (options.TransactionalContentHash.Value().Algorithm == HashAlgorithm::Crc64)
8519 "x-ms-content-crc64",
8520 Azure::Core::Convert::Base64Encode(
8521 options.TransactionalContentHash.Value().Value));
8524 if (options.LeaseId.HasValue())
8526 request.SetHeader(
"x-ms-lease-id", options.LeaseId.Value());
8528 if (options.EncryptionKey.HasValue())
8530 request.SetHeader(
"x-ms-encryption-key", options.EncryptionKey.Value());
8532 if (options.EncryptionKeySha256.HasValue())
8535 "x-ms-encryption-key-sha256",
8536 Azure::Core::Convert::Base64Encode(options.EncryptionKeySha256.Value()));
8538 if (options.EncryptionAlgorithm.HasValue())
8541 "x-ms-encryption-algorithm", options.EncryptionAlgorithm.Value().ToString());
8543 if (options.EncryptionScope.HasValue())
8545 request.SetHeader(
"x-ms-encryption-scope", options.EncryptionScope.Value());
8547 auto pHttpResponse = pipeline.Send(request, context);
8548 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
8549 StageBlockResult response;
8550 auto http_status_code
8551 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
8552 httpResponse.GetStatusCode());
8553 if (!(http_status_code == 201))
8555 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
8558 const auto& headers = httpResponse.GetHeaders();
8559 auto content_md5_iterator = headers.find(
"content-md5");
8560 if (content_md5_iterator != headers.end())
8563 hash.Algorithm = HashAlgorithm::Md5;
8564 hash.Value = Azure::Core::Convert::Base64Decode(content_md5_iterator->second);
8565 response.TransactionalContentHash = std::move(hash);
8567 auto x_ms_content_crc64_iterator = headers.find(
"x-ms-content-crc64");
8568 if (x_ms_content_crc64_iterator != headers.end())
8571 hash.Algorithm = HashAlgorithm::Crc64;
8572 hash.Value = Azure::Core::Convert::Base64Decode(x_ms_content_crc64_iterator->second);
8573 response.TransactionalContentHash = std::move(hash);
8576 response.IsServerEncrypted
8577 = httpResponse.GetHeaders().at(
"x-ms-request-server-encrypted") ==
"true";
8578 auto x_ms_encryption_key_sha256__iterator
8579 = httpResponse.GetHeaders().find(
"x-ms-encryption-key-sha256");
8580 if (x_ms_encryption_key_sha256__iterator != httpResponse.GetHeaders().end())
8582 response.EncryptionKeySha256
8583 = Azure::Core::Convert::Base64Decode(x_ms_encryption_key_sha256__iterator->second);
8585 auto x_ms_encryption_scope__iterator
8586 = httpResponse.GetHeaders().find(
"x-ms-encryption-scope");
8587 if (x_ms_encryption_scope__iterator != httpResponse.GetHeaders().end())
8589 response.EncryptionScope = x_ms_encryption_scope__iterator->second;
8591 return Azure::Response<StageBlockResult>(std::move(response), std::move(pHttpResponse));
8594 struct StageBlockFromUriOptions final
8596 Azure::Nullable<int32_t> Timeout;
8597 std::string BlockId;
8598 std::string SourceUri;
8599 Azure::Nullable<Azure::Core::Http::HttpRange> SourceRange;
8600 Azure::Nullable<ContentHash> TransactionalContentHash;
8601 Azure::Nullable<std::string> LeaseId;
8602 Azure::Nullable<std::string> EncryptionKey;
8603 Azure::Nullable<std::vector<uint8_t>> EncryptionKeySha256;
8604 Azure::Nullable<EncryptionAlgorithmType> EncryptionAlgorithm;
8605 Azure::Nullable<std::string> EncryptionScope;
8606 Azure::Nullable<Azure::DateTime> SourceIfModifiedSince;
8607 Azure::Nullable<Azure::DateTime> SourceIfUnmodifiedSince;
8608 Azure::ETag SourceIfMatch;
8609 Azure::ETag SourceIfNoneMatch;
8612 static Azure::Response<StageBlockFromUriResult> StageBlockFromUri(
8613 Azure::Core::Http::_internal::HttpPipeline& pipeline,
8614 const Azure::Core::Url& url,
8615 const StageBlockFromUriOptions& options,
8616 const Azure::Core::Context& context)
8619 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
8620 request.SetHeader(
"Content-Length",
"0");
8621 request.GetUrl().AppendQueryParameter(
"comp",
"block");
8622 request.GetUrl().AppendQueryParameter(
8623 "blockid", _internal::UrlEncodeQueryParameter(options.BlockId));
8624 request.SetHeader(
"x-ms-version",
"2020-02-10");
8625 if (options.Timeout.HasValue())
8627 request.GetUrl().AppendQueryParameter(
8628 "timeout", std::to_string(options.Timeout.Value()));
8630 request.SetHeader(
"x-ms-copy-source", options.SourceUri);
8631 if (options.SourceRange.HasValue())
8633 std::string headerValue
8634 =
"bytes=" + std::to_string(options.SourceRange.Value().Offset) +
"-";
8635 if (options.SourceRange.Value().Length.HasValue())
8637 headerValue += std::to_string(
8638 options.SourceRange.Value().Offset + options.SourceRange.Value().Length.Value()
8641 request.SetHeader(
"x-ms-source_range", std::move(headerValue));
8643 if (options.TransactionalContentHash.HasValue())
8645 if (options.TransactionalContentHash.Value().Algorithm == HashAlgorithm::Md5)
8648 "x-ms-source-content-md5",
8649 Azure::Core::Convert::Base64Encode(
8650 options.TransactionalContentHash.Value().Value));
8652 else if (options.TransactionalContentHash.Value().Algorithm == HashAlgorithm::Crc64)
8655 "x-ms-source-content-crc64",
8656 Azure::Core::Convert::Base64Encode(
8657 options.TransactionalContentHash.Value().Value));
8660 if (options.LeaseId.HasValue())
8662 request.SetHeader(
"x-ms-lease-id", options.LeaseId.Value());
8664 if (options.EncryptionKey.HasValue())
8666 request.SetHeader(
"x-ms-encryption-key", options.EncryptionKey.Value());
8668 if (options.EncryptionKeySha256.HasValue())
8671 "x-ms-encryption-key-sha256",
8672 Azure::Core::Convert::Base64Encode(options.EncryptionKeySha256.Value()));
8674 if (options.EncryptionAlgorithm.HasValue())
8677 "x-ms-encryption-algorithm", options.EncryptionAlgorithm.Value().ToString());
8679 if (options.EncryptionScope.HasValue())
8681 request.SetHeader(
"x-ms-encryption-scope", options.EncryptionScope.Value());
8683 if (options.SourceIfModifiedSince.HasValue())
8686 "x-ms-source-if-modified-since",
8687 options.SourceIfModifiedSince.Value().ToString(
8688 Azure::DateTime::DateFormat::Rfc1123));
8690 if (options.SourceIfUnmodifiedSince.HasValue())
8693 "x-ms-source-if-unmodified-since",
8694 options.SourceIfUnmodifiedSince.Value().ToString(
8695 Azure::DateTime::DateFormat::Rfc1123));
8697 if (options.SourceIfMatch.HasValue() && !options.SourceIfMatch.ToString().empty())
8699 request.SetHeader(
"x-ms-source-if-match", options.SourceIfMatch.ToString());
8701 if (options.SourceIfNoneMatch.HasValue() && !options.SourceIfNoneMatch.ToString().empty())
8703 request.SetHeader(
"x-ms-source-if-none-match", options.SourceIfNoneMatch.ToString());
8705 auto pHttpResponse = pipeline.Send(request, context);
8706 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
8707 StageBlockFromUriResult response;
8708 auto http_status_code
8709 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
8710 httpResponse.GetStatusCode());
8711 if (!(http_status_code == 201))
8713 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
8716 const auto& headers = httpResponse.GetHeaders();
8717 auto content_md5_iterator = headers.find(
"content-md5");
8718 if (content_md5_iterator != headers.end())
8721 hash.Algorithm = HashAlgorithm::Md5;
8722 hash.Value = Azure::Core::Convert::Base64Decode(content_md5_iterator->second);
8723 response.TransactionalContentHash = std::move(hash);
8725 auto x_ms_content_crc64_iterator = headers.find(
"x-ms-content-crc64");
8726 if (x_ms_content_crc64_iterator != headers.end())
8729 hash.Algorithm = HashAlgorithm::Crc64;
8730 hash.Value = Azure::Core::Convert::Base64Decode(x_ms_content_crc64_iterator->second);
8731 response.TransactionalContentHash = std::move(hash);
8734 response.IsServerEncrypted
8735 = httpResponse.GetHeaders().at(
"x-ms-request-server-encrypted") ==
"true";
8736 auto x_ms_encryption_key_sha256__iterator
8737 = httpResponse.GetHeaders().find(
"x-ms-encryption-key-sha256");
8738 if (x_ms_encryption_key_sha256__iterator != httpResponse.GetHeaders().end())
8740 response.EncryptionKeySha256
8741 = Azure::Core::Convert::Base64Decode(x_ms_encryption_key_sha256__iterator->second);
8743 auto x_ms_encryption_scope__iterator
8744 = httpResponse.GetHeaders().find(
"x-ms-encryption-scope");
8745 if (x_ms_encryption_scope__iterator != httpResponse.GetHeaders().end())
8747 response.EncryptionScope = x_ms_encryption_scope__iterator->second;
8749 return Azure::Response<StageBlockFromUriResult>(
8750 std::move(response), std::move(pHttpResponse));
8753 struct CommitBlockListOptions final
8755 Azure::Nullable<int32_t> Timeout;
8756 std::vector<std::pair<BlockType, std::string>> BlockList;
8757 BlobHttpHeaders HttpHeaders;
8758 Storage::Metadata Metadata;
8759 Azure::Nullable<std::string> LeaseId;
8760 Azure::Nullable<std::string> EncryptionKey;
8761 Azure::Nullable<std::vector<uint8_t>> EncryptionKeySha256;
8762 Azure::Nullable<EncryptionAlgorithmType> EncryptionAlgorithm;
8763 Azure::Nullable<std::string> EncryptionScope;
8764 Azure::Nullable<Azure::DateTime> IfModifiedSince;
8765 Azure::Nullable<Azure::DateTime> IfUnmodifiedSince;
8766 Azure::ETag IfMatch;
8767 Azure::ETag IfNoneMatch;
8768 Azure::Nullable<std::string> IfTags;
8769 Azure::Nullable<Models::AccessTier> AccessTier;
8772 static Azure::Response<CommitBlockListResult> CommitBlockList(
8773 Azure::Core::Http::_internal::HttpPipeline& pipeline,
8774 const Azure::Core::Url& url,
8775 const CommitBlockListOptions& options,
8776 const Azure::Core::Context& context)
8779 std::string xml_body;
8781 _internal::XmlWriter writer;
8782 CommitBlockListOptionsToXml(writer, options);
8783 xml_body = writer.GetDocument();
8784 writer.Write(_internal::XmlNode{_internal::XmlNodeType::End});
8786 Azure::Core::IO::MemoryBodyStream xml_body_stream(
8787 reinterpret_cast<const uint8_t*
>(xml_body.data()), xml_body.length());
8788 auto request = Azure::Core::Http::Request(
8789 Azure::Core::Http::HttpMethod::Put, url, &xml_body_stream);
8790 request.SetHeader(
"Content-Length", std::to_string(xml_body_stream.Length()));
8791 request.GetUrl().AppendQueryParameter(
"comp",
"blocklist");
8792 request.SetHeader(
"x-ms-version",
"2020-02-10");
8793 if (options.Timeout.HasValue())
8795 request.GetUrl().AppendQueryParameter(
8796 "timeout", std::to_string(options.Timeout.Value()));
8798 if (!options.HttpHeaders.ContentType.empty())
8800 request.SetHeader(
"x-ms-blob-content-type", options.HttpHeaders.ContentType);
8802 if (!options.HttpHeaders.ContentEncoding.empty())
8804 request.SetHeader(
"x-ms-blob-content-encoding", options.HttpHeaders.ContentEncoding);
8806 if (!options.HttpHeaders.ContentLanguage.empty())
8808 request.SetHeader(
"x-ms-blob-content-language", options.HttpHeaders.ContentLanguage);
8810 if (!options.HttpHeaders.CacheControl.empty())
8812 request.SetHeader(
"x-ms-blob-cache-control", options.HttpHeaders.CacheControl);
8814 if (!Azure::Core::Convert::Base64Encode(options.HttpHeaders.ContentHash.Value).empty())
8817 "x-ms-blob-content-md5",
8818 Azure::Core::Convert::Base64Encode(options.HttpHeaders.ContentHash.Value));
8820 if (!options.HttpHeaders.ContentDisposition.empty())
8823 "x-ms-blob-content-disposition", options.HttpHeaders.ContentDisposition);
8825 for (
const auto& pair : options.Metadata)
8827 request.SetHeader(
"x-ms-meta-" + pair.first, pair.second);
8829 if (options.LeaseId.HasValue())
8831 request.SetHeader(
"x-ms-lease-id", options.LeaseId.Value());
8833 if (options.EncryptionKey.HasValue())
8835 request.SetHeader(
"x-ms-encryption-key", options.EncryptionKey.Value());
8837 if (options.EncryptionKeySha256.HasValue())
8840 "x-ms-encryption-key-sha256",
8841 Azure::Core::Convert::Base64Encode(options.EncryptionKeySha256.Value()));
8843 if (options.EncryptionAlgorithm.HasValue())
8846 "x-ms-encryption-algorithm", options.EncryptionAlgorithm.Value().ToString());
8848 if (options.EncryptionScope.HasValue())
8850 request.SetHeader(
"x-ms-encryption-scope", options.EncryptionScope.Value());
8852 if (options.AccessTier.HasValue())
8854 request.SetHeader(
"x-ms-access-tier", options.AccessTier.Value().ToString());
8856 if (options.IfModifiedSince.HasValue())
8859 "If-Modified-Since",
8860 options.IfModifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
8862 if (options.IfUnmodifiedSince.HasValue())
8865 "If-Unmodified-Since",
8866 options.IfUnmodifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
8868 if (options.IfMatch.HasValue() && !options.IfMatch.ToString().empty())
8870 request.SetHeader(
"If-Match", options.IfMatch.ToString());
8872 if (options.IfNoneMatch.HasValue() && !options.IfNoneMatch.ToString().empty())
8874 request.SetHeader(
"If-None-Match", options.IfNoneMatch.ToString());
8876 if (options.IfTags.HasValue())
8878 request.SetHeader(
"x-ms-if-tags", options.IfTags.Value());
8880 auto pHttpResponse = pipeline.Send(request, context);
8881 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
8882 CommitBlockListResult response;
8883 auto http_status_code
8884 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
8885 httpResponse.GetStatusCode());
8886 if (!(http_status_code == 201))
8888 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
8890 response.ETag = Azure::ETag(httpResponse.GetHeaders().at(
"etag"));
8891 response.LastModified = Azure::DateTime::Parse(
8892 httpResponse.GetHeaders().at(
"last-modified"), Azure::DateTime::DateFormat::Rfc1123);
8893 auto x_ms_version_id__iterator = httpResponse.GetHeaders().find(
"x-ms-version-id");
8894 if (x_ms_version_id__iterator != httpResponse.GetHeaders().end())
8896 response.VersionId = x_ms_version_id__iterator->second;
8898 response.IsServerEncrypted
8899 = httpResponse.GetHeaders().at(
"x-ms-request-server-encrypted") ==
"true";
8900 auto x_ms_encryption_key_sha256__iterator
8901 = httpResponse.GetHeaders().find(
"x-ms-encryption-key-sha256");
8902 if (x_ms_encryption_key_sha256__iterator != httpResponse.GetHeaders().end())
8904 response.EncryptionKeySha256
8905 = Azure::Core::Convert::Base64Decode(x_ms_encryption_key_sha256__iterator->second);
8907 auto x_ms_encryption_scope__iterator
8908 = httpResponse.GetHeaders().find(
"x-ms-encryption-scope");
8909 if (x_ms_encryption_scope__iterator != httpResponse.GetHeaders().end())
8911 response.EncryptionScope = x_ms_encryption_scope__iterator->second;
8913 return Azure::Response<CommitBlockListResult>(
8914 std::move(response), std::move(pHttpResponse));
8917 struct GetBlockListOptions final
8919 Azure::Nullable<int32_t> Timeout;
8921 Azure::Nullable<std::string> LeaseId;
8922 Azure::Nullable<std::string> IfTags;
8925 static Azure::Response<GetBlockListResult> GetBlockList(
8926 Azure::Core::Http::_internal::HttpPipeline& pipeline,
8927 const Azure::Core::Url& url,
8928 const GetBlockListOptions& options,
8929 const Azure::Core::Context& context)
8932 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url);
8933 request.GetUrl().AppendQueryParameter(
"comp",
"blocklist");
8934 request.GetUrl().AppendQueryParameter(
8935 "blocklisttype", _internal::UrlEncodeQueryParameter(options.ListType.ToString()));
8936 request.SetHeader(
"x-ms-version",
"2020-02-10");
8937 if (options.Timeout.HasValue())
8939 request.GetUrl().AppendQueryParameter(
8940 "timeout", std::to_string(options.Timeout.Value()));
8942 if (options.LeaseId.HasValue())
8944 request.SetHeader(
"x-ms-lease-id", options.LeaseId.Value());
8946 if (options.IfTags.HasValue())
8948 request.SetHeader(
"x-ms-if-tags", options.IfTags.Value());
8950 auto pHttpResponse = pipeline.Send(request, context);
8951 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
8952 GetBlockListResult response;
8953 auto http_status_code
8954 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
8955 httpResponse.GetStatusCode());
8956 if (!(http_status_code == 200))
8958 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
8961 const auto& httpResponseBody = httpResponse.GetBody();
8962 _internal::XmlReader reader(
8963 reinterpret_cast<const char*
>(httpResponseBody.data()), httpResponseBody.size());
8964 response = GetBlockListResultFromXml(reader);
8966 response.ETag = Azure::ETag(httpResponse.GetHeaders().at(
"etag"));
8967 response.LastModified = Azure::DateTime::Parse(
8968 httpResponse.GetHeaders().at(
"last-modified"), Azure::DateTime::DateFormat::Rfc1123);
8969 response.BlobSize = std::stoll(httpResponse.GetHeaders().at(
"x-ms-blob-content-length"));
8970 return Azure::Response<GetBlockListResult>(std::move(response), std::move(pHttpResponse));
8974 static GetBlockListResult GetBlockListResultFromXml(_internal::XmlReader& reader)
8976 GetBlockListResult ret;
8977 enum class XmlTagName
8982 k_UncommittedBlocks,
8985 std::vector<XmlTagName> path;
8988 auto node = reader.Read();
8989 if (node.Type == _internal::XmlNodeType::End)
8993 else if (node.Type == _internal::XmlNodeType::EndTag)
8995 if (path.size() > 0)
9004 else if (node.Type == _internal::XmlNodeType::StartTag)
9006 if (std::strcmp(node.Name,
"BlockList") == 0)
9008 path.emplace_back(XmlTagName::k_BlockList);
9010 else if (std::strcmp(node.Name,
"CommittedBlocks") == 0)
9012 path.emplace_back(XmlTagName::k_CommittedBlocks);
9014 else if (std::strcmp(node.Name,
"Block") == 0)
9016 path.emplace_back(XmlTagName::k_Block);
9018 else if (std::strcmp(node.Name,
"UncommittedBlocks") == 0)
9020 path.emplace_back(XmlTagName::k_UncommittedBlocks);
9024 path.emplace_back(XmlTagName::k_Unknown);
9026 if (path.size() == 3 && path[0] == XmlTagName::k_BlockList
9027 && path[1] == XmlTagName::k_CommittedBlocks && path[2] == XmlTagName::k_Block)
9029 ret.CommittedBlocks.emplace_back(BlobBlockFromXml(reader));
9033 path.size() == 3 && path[0] == XmlTagName::k_BlockList
9034 && path[1] == XmlTagName::k_UncommittedBlocks && path[2] == XmlTagName::k_Block)
9036 ret.UncommittedBlocks.emplace_back(BlobBlockFromXml(reader));
9040 else if (node.Type == _internal::XmlNodeType::Text)
9047 static BlobBlock BlobBlockFromXml(_internal::XmlReader& reader)
9050 enum class XmlTagName
9056 std::vector<XmlTagName> path;
9059 auto node = reader.Read();
9060 if (node.Type == _internal::XmlNodeType::End)
9064 else if (node.Type == _internal::XmlNodeType::EndTag)
9066 if (path.size() > 0)
9075 else if (node.Type == _internal::XmlNodeType::StartTag)
9077 if (std::strcmp(node.Name,
"Name") == 0)
9079 path.emplace_back(XmlTagName::k_Name);
9081 else if (std::strcmp(node.Name,
"Size") == 0)
9083 path.emplace_back(XmlTagName::k_Size);
9087 path.emplace_back(XmlTagName::k_Unknown);
9090 else if (node.Type == _internal::XmlNodeType::Text)
9092 if (path.size() == 1 && path[0] == XmlTagName::k_Name)
9094 ret.Name = node.Value;
9096 else if (path.size() == 1 && path[0] == XmlTagName::k_Size)
9098 ret.Size = std::stoll(node.Value);
9105 static void CommitBlockListOptionsToXml(
9106 _internal::XmlWriter& writer,
9107 const CommitBlockListOptions& options)
9109 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"BlockList"});
9110 for (
const auto& i : options.BlockList)
9112 writer.Write(_internal::XmlNode{
9113 _internal::XmlNodeType::StartTag, i.first.ToString().data(), i.second.data()});
9115 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
9120 class PageBlob final {
9122 struct CreatePageBlobOptions final
9124 Azure::Nullable<int32_t> Timeout;
9125 int64_t BlobSize = -1;
9126 Azure::Nullable<int64_t> SequenceNumber;
9127 BlobHttpHeaders HttpHeaders;
9128 Storage::Metadata Metadata;
9129 Azure::Nullable<std::string> LeaseId;
9130 Azure::Nullable<Models::AccessTier> AccessTier;
9131 Azure::Nullable<std::string> EncryptionKey;
9132 Azure::Nullable<std::vector<uint8_t>> EncryptionKeySha256;
9133 Azure::Nullable<EncryptionAlgorithmType> EncryptionAlgorithm;
9134 Azure::Nullable<std::string> EncryptionScope;
9135 Azure::Nullable<Azure::DateTime> IfModifiedSince;
9136 Azure::Nullable<Azure::DateTime> IfUnmodifiedSince;
9137 Azure::ETag IfMatch;
9138 Azure::ETag IfNoneMatch;
9139 Azure::Nullable<std::string> IfTags;
9142 static Azure::Response<CreatePageBlobResult> Create(
9143 Azure::Core::Http::_internal::HttpPipeline& pipeline,
9144 const Azure::Core::Url& url,
9145 const CreatePageBlobOptions& options,
9146 const Azure::Core::Context& context)
9149 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
9150 request.SetHeader(
"Content-Length",
"0");
9151 request.SetHeader(
"x-ms-version",
"2020-02-10");
9152 if (options.Timeout.HasValue())
9154 request.GetUrl().AppendQueryParameter(
9155 "timeout", std::to_string(options.Timeout.Value()));
9157 if (!options.HttpHeaders.ContentType.empty())
9159 request.SetHeader(
"x-ms-blob-content-type", options.HttpHeaders.ContentType);
9161 if (!options.HttpHeaders.ContentEncoding.empty())
9163 request.SetHeader(
"x-ms-blob-content-encoding", options.HttpHeaders.ContentEncoding);
9165 if (!options.HttpHeaders.ContentLanguage.empty())
9167 request.SetHeader(
"x-ms-blob-content-language", options.HttpHeaders.ContentLanguage);
9169 if (!options.HttpHeaders.CacheControl.empty())
9171 request.SetHeader(
"x-ms-blob-cache-control", options.HttpHeaders.CacheControl);
9173 if (!Azure::Core::Convert::Base64Encode(options.HttpHeaders.ContentHash.Value).empty())
9176 "x-ms-blob-content-md5",
9177 Azure::Core::Convert::Base64Encode(options.HttpHeaders.ContentHash.Value));
9179 if (!options.HttpHeaders.ContentDisposition.empty())
9182 "x-ms-blob-content-disposition", options.HttpHeaders.ContentDisposition);
9184 for (
const auto& pair : options.Metadata)
9186 request.SetHeader(
"x-ms-meta-" + pair.first, pair.second);
9188 if (options.LeaseId.HasValue())
9190 request.SetHeader(
"x-ms-lease-id", options.LeaseId.Value());
9192 request.SetHeader(
"x-ms-blob-type",
"PageBlob");
9193 request.SetHeader(
"x-ms-blob-content-length", std::to_string(options.BlobSize));
9194 if (options.SequenceNumber.HasValue())
9197 "x-ms-blob-sequence-number", std::to_string(options.SequenceNumber.Value()));
9199 if (options.AccessTier.HasValue())
9201 request.SetHeader(
"x-ms-access-tier", options.AccessTier.Value().ToString());
9203 if (options.EncryptionKey.HasValue())
9205 request.SetHeader(
"x-ms-encryption-key", options.EncryptionKey.Value());
9207 if (options.EncryptionKeySha256.HasValue())
9210 "x-ms-encryption-key-sha256",
9211 Azure::Core::Convert::Base64Encode(options.EncryptionKeySha256.Value()));
9213 if (options.EncryptionAlgorithm.HasValue())
9216 "x-ms-encryption-algorithm", options.EncryptionAlgorithm.Value().ToString());
9218 if (options.EncryptionScope.HasValue())
9220 request.SetHeader(
"x-ms-encryption-scope", options.EncryptionScope.Value());
9222 if (options.IfModifiedSince.HasValue())
9225 "If-Modified-Since",
9226 options.IfModifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
9228 if (options.IfUnmodifiedSince.HasValue())
9231 "If-Unmodified-Since",
9232 options.IfUnmodifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
9234 if (options.IfMatch.HasValue() && !options.IfMatch.ToString().empty())
9236 request.SetHeader(
"If-Match", options.IfMatch.ToString());
9238 if (options.IfNoneMatch.HasValue() && !options.IfNoneMatch.ToString().empty())
9240 request.SetHeader(
"If-None-Match", options.IfNoneMatch.ToString());
9242 if (options.IfTags.HasValue())
9244 request.SetHeader(
"x-ms-if-tags", options.IfTags.Value());
9246 auto pHttpResponse = pipeline.Send(request, context);
9247 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
9248 CreatePageBlobResult response;
9249 auto http_status_code
9250 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
9251 httpResponse.GetStatusCode());
9252 if (!(http_status_code == 201))
9254 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
9256 response.ETag = Azure::ETag(httpResponse.GetHeaders().at(
"etag"));
9257 response.LastModified = Azure::DateTime::Parse(
9258 httpResponse.GetHeaders().at(
"last-modified"), Azure::DateTime::DateFormat::Rfc1123);
9259 auto x_ms_version_id__iterator = httpResponse.GetHeaders().find(
"x-ms-version-id");
9260 if (x_ms_version_id__iterator != httpResponse.GetHeaders().end())
9262 response.VersionId = x_ms_version_id__iterator->second;
9264 response.IsServerEncrypted
9265 = httpResponse.GetHeaders().at(
"x-ms-request-server-encrypted") ==
"true";
9266 auto x_ms_encryption_key_sha256__iterator
9267 = httpResponse.GetHeaders().find(
"x-ms-encryption-key-sha256");
9268 if (x_ms_encryption_key_sha256__iterator != httpResponse.GetHeaders().end())
9270 response.EncryptionKeySha256
9271 = Azure::Core::Convert::Base64Decode(x_ms_encryption_key_sha256__iterator->second);
9273 auto x_ms_encryption_scope__iterator
9274 = httpResponse.GetHeaders().find(
"x-ms-encryption-scope");
9275 if (x_ms_encryption_scope__iterator != httpResponse.GetHeaders().end())
9277 response.EncryptionScope = x_ms_encryption_scope__iterator->second;
9279 return Azure::Response<CreatePageBlobResult>(
9280 std::move(response), std::move(pHttpResponse));
9283 struct UploadPageBlobPagesOptions final
9285 Azure::Nullable<int32_t> Timeout;
9286 Azure::Core::Http::HttpRange Range;
9287 Azure::Nullable<ContentHash> TransactionalContentHash;
9288 Azure::Nullable<std::string> LeaseId;
9289 Azure::Nullable<int64_t> IfSequenceNumberLessThanOrEqualTo;
9290 Azure::Nullable<int64_t> IfSequenceNumberLessThan;
9291 Azure::Nullable<int64_t> IfSequenceNumberEqualTo;
9292 Azure::Nullable<std::string> EncryptionKey;
9293 Azure::Nullable<std::vector<uint8_t>> EncryptionKeySha256;
9294 Azure::Nullable<EncryptionAlgorithmType> EncryptionAlgorithm;
9295 Azure::Nullable<std::string> EncryptionScope;
9296 Azure::Nullable<Azure::DateTime> IfModifiedSince;
9297 Azure::Nullable<Azure::DateTime> IfUnmodifiedSince;
9298 Azure::ETag IfMatch;
9299 Azure::ETag IfNoneMatch;
9300 Azure::Nullable<std::string> IfTags;
9303 static Azure::Response<UploadPagesResult> UploadPages(
9304 Azure::Core::Http::_internal::HttpPipeline& pipeline,
9305 const Azure::Core::Url& url,
9306 Azure::Core::IO::BodyStream& requestBody,
9307 const UploadPageBlobPagesOptions& options,
9308 const Azure::Core::Context& context)
9312 = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url, &requestBody);
9313 request.SetHeader(
"Content-Length", std::to_string(requestBody.Length()));
9314 request.GetUrl().AppendQueryParameter(
"comp",
"page");
9315 request.SetHeader(
"x-ms-version",
"2020-02-10");
9316 if (options.Timeout.HasValue())
9318 request.GetUrl().AppendQueryParameter(
9319 "timeout", std::to_string(options.Timeout.Value()));
9322 std::string headerValue =
"bytes=" + std::to_string(options.Range.Offset) +
"-";
9323 if (options.Range.Length.HasValue())
9326 += std::to_string(options.Range.Offset + options.Range.Length.Value() - 1);
9328 request.SetHeader(
"x-ms-range", std::move(headerValue));
9330 if (options.TransactionalContentHash.HasValue())
9332 if (options.TransactionalContentHash.Value().Algorithm == HashAlgorithm::Md5)
9336 Azure::Core::Convert::Base64Encode(
9337 options.TransactionalContentHash.Value().Value));
9339 else if (options.TransactionalContentHash.Value().Algorithm == HashAlgorithm::Crc64)
9342 "x-ms-content-crc64",
9343 Azure::Core::Convert::Base64Encode(
9344 options.TransactionalContentHash.Value().Value));
9347 request.SetHeader(
"x-ms-page-write",
"update");
9348 if (options.LeaseId.HasValue())
9350 request.SetHeader(
"x-ms-lease-id", options.LeaseId.Value());
9352 if (options.IfSequenceNumberLessThanOrEqualTo.HasValue())
9355 "x-ms-if-sequence-number-le",
9356 std::to_string(options.IfSequenceNumberLessThanOrEqualTo.Value()));
9358 if (options.IfSequenceNumberLessThan.HasValue())
9361 "x-ms-if-sequence-number-lt",
9362 std::to_string(options.IfSequenceNumberLessThan.Value()));
9364 if (options.IfSequenceNumberEqualTo.HasValue())
9367 "x-ms-if-sequence-number-eq",
9368 std::to_string(options.IfSequenceNumberEqualTo.Value()));
9370 if (options.EncryptionKey.HasValue())
9372 request.SetHeader(
"x-ms-encryption-key", options.EncryptionKey.Value());
9374 if (options.EncryptionKeySha256.HasValue())
9377 "x-ms-encryption-key-sha256",
9378 Azure::Core::Convert::Base64Encode(options.EncryptionKeySha256.Value()));
9380 if (options.EncryptionAlgorithm.HasValue())
9383 "x-ms-encryption-algorithm", options.EncryptionAlgorithm.Value().ToString());
9385 if (options.EncryptionScope.HasValue())
9387 request.SetHeader(
"x-ms-encryption-scope", options.EncryptionScope.Value());
9389 if (options.IfModifiedSince.HasValue())
9392 "If-Modified-Since",
9393 options.IfModifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
9395 if (options.IfUnmodifiedSince.HasValue())
9398 "If-Unmodified-Since",
9399 options.IfUnmodifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
9401 if (options.IfMatch.HasValue() && !options.IfMatch.ToString().empty())
9403 request.SetHeader(
"If-Match", options.IfMatch.ToString());
9405 if (options.IfNoneMatch.HasValue() && !options.IfNoneMatch.ToString().empty())
9407 request.SetHeader(
"If-None-Match", options.IfNoneMatch.ToString());
9409 if (options.IfTags.HasValue())
9411 request.SetHeader(
"x-ms-if-tags", options.IfTags.Value());
9413 auto pHttpResponse = pipeline.Send(request, context);
9414 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
9415 UploadPagesResult response;
9416 auto http_status_code
9417 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
9418 httpResponse.GetStatusCode());
9419 if (!(http_status_code == 201))
9421 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
9423 response.ETag = Azure::ETag(httpResponse.GetHeaders().at(
"etag"));
9424 response.LastModified = Azure::DateTime::Parse(
9425 httpResponse.GetHeaders().at(
"last-modified"), Azure::DateTime::DateFormat::Rfc1123);
9427 const auto& headers = httpResponse.GetHeaders();
9428 auto content_md5_iterator = headers.find(
"content-md5");
9429 if (content_md5_iterator != headers.end())
9432 hash.Algorithm = HashAlgorithm::Md5;
9433 hash.Value = Azure::Core::Convert::Base64Decode(content_md5_iterator->second);
9434 response.TransactionalContentHash = std::move(hash);
9436 auto x_ms_content_crc64_iterator = headers.find(
"x-ms-content-crc64");
9437 if (x_ms_content_crc64_iterator != headers.end())
9440 hash.Algorithm = HashAlgorithm::Crc64;
9441 hash.Value = Azure::Core::Convert::Base64Decode(x_ms_content_crc64_iterator->second);
9442 response.TransactionalContentHash = std::move(hash);
9445 response.SequenceNumber
9446 = std::stoll(httpResponse.GetHeaders().at(
"x-ms-blob-sequence-number"));
9447 response.IsServerEncrypted
9448 = httpResponse.GetHeaders().at(
"x-ms-request-server-encrypted") ==
"true";
9449 auto x_ms_encryption_key_sha256__iterator
9450 = httpResponse.GetHeaders().find(
"x-ms-encryption-key-sha256");
9451 if (x_ms_encryption_key_sha256__iterator != httpResponse.GetHeaders().end())
9453 response.EncryptionKeySha256
9454 = Azure::Core::Convert::Base64Decode(x_ms_encryption_key_sha256__iterator->second);
9456 auto x_ms_encryption_scope__iterator
9457 = httpResponse.GetHeaders().find(
"x-ms-encryption-scope");
9458 if (x_ms_encryption_scope__iterator != httpResponse.GetHeaders().end())
9460 response.EncryptionScope = x_ms_encryption_scope__iterator->second;
9462 return Azure::Response<UploadPagesResult>(std::move(response), std::move(pHttpResponse));
9465 struct UploadPageBlobPagesFromUriOptions final
9467 Azure::Nullable<int32_t> Timeout;
9468 std::string SourceUri;
9469 Azure::Core::Http::HttpRange SourceRange;
9470 Azure::Core::Http::HttpRange Range;
9471 Azure::Nullable<ContentHash> TransactionalContentHash;
9472 Azure::Nullable<std::string> LeaseId;
9473 Azure::Nullable<int64_t> IfSequenceNumberLessThanOrEqualTo;
9474 Azure::Nullable<int64_t> IfSequenceNumberLessThan;
9475 Azure::Nullable<int64_t> IfSequenceNumberEqualTo;
9476 Azure::Nullable<std::string> EncryptionKey;
9477 Azure::Nullable<std::vector<uint8_t>> EncryptionKeySha256;
9478 Azure::Nullable<EncryptionAlgorithmType> EncryptionAlgorithm;
9479 Azure::Nullable<std::string> EncryptionScope;
9480 Azure::Nullable<Azure::DateTime> IfModifiedSince;
9481 Azure::Nullable<Azure::DateTime> IfUnmodifiedSince;
9482 Azure::ETag IfMatch;
9483 Azure::ETag IfNoneMatch;
9484 Azure::Nullable<std::string> IfTags;
9487 static Azure::Response<UploadPagesFromUriResult> UploadPagesFromUri(
9488 Azure::Core::Http::_internal::HttpPipeline& pipeline,
9489 const Azure::Core::Url& url,
9490 const UploadPageBlobPagesFromUriOptions& options,
9491 const Azure::Core::Context& context)
9494 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
9495 request.SetHeader(
"Content-Length",
"0");
9496 request.GetUrl().AppendQueryParameter(
"comp",
"page");
9497 request.SetHeader(
"x-ms-version",
"2020-02-10");
9498 if (options.Timeout.HasValue())
9500 request.GetUrl().AppendQueryParameter(
9501 "timeout", std::to_string(options.Timeout.Value()));
9504 std::string headerValue =
"bytes=" + std::to_string(options.Range.Offset) +
"-";
9505 if (options.Range.Length.HasValue())
9508 += std::to_string(options.Range.Offset + options.Range.Length.Value() - 1);
9510 request.SetHeader(
"x-ms-range", std::move(headerValue));
9512 request.SetHeader(
"x-ms-copy-source", options.SourceUri);
9514 std::string headerValue =
"bytes=" + std::to_string(options.SourceRange.Offset) +
"-";
9515 if (options.SourceRange.Length.HasValue())
9517 headerValue += std::to_string(
9518 options.SourceRange.Offset + options.SourceRange.Length.Value() - 1);
9520 request.SetHeader(
"x-ms-source-range", std::move(headerValue));
9522 if (options.TransactionalContentHash.HasValue())
9524 if (options.TransactionalContentHash.Value().Algorithm == HashAlgorithm::Md5)
9527 "x-ms-source-content-md5",
9528 Azure::Core::Convert::Base64Encode(
9529 options.TransactionalContentHash.Value().Value));
9531 else if (options.TransactionalContentHash.Value().Algorithm == HashAlgorithm::Crc64)
9534 "x-ms-source-content-crc64",
9535 Azure::Core::Convert::Base64Encode(
9536 options.TransactionalContentHash.Value().Value));
9539 request.SetHeader(
"x-ms-page-write",
"update");
9540 if (options.LeaseId.HasValue())
9542 request.SetHeader(
"x-ms-lease-id", options.LeaseId.Value());
9544 if (options.IfSequenceNumberLessThanOrEqualTo.HasValue())
9547 "x-ms-if-sequence-number-le",
9548 std::to_string(options.IfSequenceNumberLessThanOrEqualTo.Value()));
9550 if (options.IfSequenceNumberLessThan.HasValue())
9553 "x-ms-if-sequence-number-lt",
9554 std::to_string(options.IfSequenceNumberLessThan.Value()));
9556 if (options.IfSequenceNumberEqualTo.HasValue())
9559 "x-ms-if-sequence-number-eq",
9560 std::to_string(options.IfSequenceNumberEqualTo.Value()));
9562 if (options.EncryptionKey.HasValue())
9564 request.SetHeader(
"x-ms-encryption-key", options.EncryptionKey.Value());
9566 if (options.EncryptionKeySha256.HasValue())
9569 "x-ms-encryption-key-sha256",
9570 Azure::Core::Convert::Base64Encode(options.EncryptionKeySha256.Value()));
9572 if (options.EncryptionAlgorithm.HasValue())
9575 "x-ms-encryption-algorithm", options.EncryptionAlgorithm.Value().ToString());
9577 if (options.EncryptionScope.HasValue())
9579 request.SetHeader(
"x-ms-encryption-scope", options.EncryptionScope.Value());
9581 if (options.IfModifiedSince.HasValue())
9584 "If-Modified-Since",
9585 options.IfModifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
9587 if (options.IfUnmodifiedSince.HasValue())
9590 "If-Unmodified-Since",
9591 options.IfUnmodifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
9593 if (options.IfMatch.HasValue() && !options.IfMatch.ToString().empty())
9595 request.SetHeader(
"If-Match", options.IfMatch.ToString());
9597 if (options.IfNoneMatch.HasValue() && !options.IfNoneMatch.ToString().empty())
9599 request.SetHeader(
"If-None-Match", options.IfNoneMatch.ToString());
9601 if (options.IfTags.HasValue())
9603 request.SetHeader(
"x-ms-if-tags", options.IfTags.Value());
9605 auto pHttpResponse = pipeline.Send(request, context);
9606 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
9607 UploadPagesFromUriResult response;
9608 auto http_status_code
9609 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
9610 httpResponse.GetStatusCode());
9611 if (!(http_status_code == 201))
9613 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
9615 response.ETag = Azure::ETag(httpResponse.GetHeaders().at(
"etag"));
9616 response.LastModified = Azure::DateTime::Parse(
9617 httpResponse.GetHeaders().at(
"last-modified"), Azure::DateTime::DateFormat::Rfc1123);
9619 const auto& headers = httpResponse.GetHeaders();
9620 auto content_md5_iterator = headers.find(
"content-md5");
9621 if (content_md5_iterator != headers.end())
9624 hash.Algorithm = HashAlgorithm::Md5;
9625 hash.Value = Azure::Core::Convert::Base64Decode(content_md5_iterator->second);
9626 response.TransactionalContentHash = std::move(hash);
9628 auto x_ms_content_crc64_iterator = headers.find(
"x-ms-content-crc64");
9629 if (x_ms_content_crc64_iterator != headers.end())
9632 hash.Algorithm = HashAlgorithm::Crc64;
9633 hash.Value = Azure::Core::Convert::Base64Decode(x_ms_content_crc64_iterator->second);
9634 response.TransactionalContentHash = std::move(hash);
9637 response.SequenceNumber
9638 = std::stoll(httpResponse.GetHeaders().at(
"x-ms-blob-sequence-number"));
9639 response.IsServerEncrypted
9640 = httpResponse.GetHeaders().at(
"x-ms-request-server-encrypted") ==
"true";
9641 auto x_ms_encryption_key_sha256__iterator
9642 = httpResponse.GetHeaders().find(
"x-ms-encryption-key-sha256");
9643 if (x_ms_encryption_key_sha256__iterator != httpResponse.GetHeaders().end())
9645 response.EncryptionKeySha256
9646 = Azure::Core::Convert::Base64Decode(x_ms_encryption_key_sha256__iterator->second);
9648 auto x_ms_encryption_scope__iterator
9649 = httpResponse.GetHeaders().find(
"x-ms-encryption-scope");
9650 if (x_ms_encryption_scope__iterator != httpResponse.GetHeaders().end())
9652 response.EncryptionScope = x_ms_encryption_scope__iterator->second;
9654 return Azure::Response<UploadPagesFromUriResult>(
9655 std::move(response), std::move(pHttpResponse));
9658 struct ClearPageBlobPagesOptions final
9660 Azure::Nullable<int32_t> Timeout;
9661 Azure::Core::Http::HttpRange Range;
9662 Azure::Nullable<std::string> LeaseId;
9663 Azure::Nullable<int64_t> IfSequenceNumberLessThanOrEqualTo;
9664 Azure::Nullable<int64_t> IfSequenceNumberLessThan;
9665 Azure::Nullable<int64_t> IfSequenceNumberEqualTo;
9666 Azure::Nullable<std::string> EncryptionKey;
9667 Azure::Nullable<std::vector<uint8_t>> EncryptionKeySha256;
9668 Azure::Nullable<EncryptionAlgorithmType> EncryptionAlgorithm;
9669 Azure::Nullable<std::string> EncryptionScope;
9670 Azure::Nullable<Azure::DateTime> IfModifiedSince;
9671 Azure::Nullable<Azure::DateTime> IfUnmodifiedSince;
9672 Azure::ETag IfMatch;
9673 Azure::ETag IfNoneMatch;
9674 Azure::Nullable<std::string> IfTags;
9677 static Azure::Response<ClearPagesResult> ClearPages(
9678 Azure::Core::Http::_internal::HttpPipeline& pipeline,
9679 const Azure::Core::Url& url,
9680 const ClearPageBlobPagesOptions& options,
9681 const Azure::Core::Context& context)
9684 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
9685 request.SetHeader(
"Content-Length",
"0");
9686 request.GetUrl().AppendQueryParameter(
"comp",
"page");
9687 request.SetHeader(
"x-ms-version",
"2020-02-10");
9688 if (options.Timeout.HasValue())
9690 request.GetUrl().AppendQueryParameter(
9691 "timeout", std::to_string(options.Timeout.Value()));
9694 std::string headerValue =
"bytes=" + std::to_string(options.Range.Offset) +
"-";
9695 if (options.Range.Length.HasValue())
9698 += std::to_string(options.Range.Offset + options.Range.Length.Value() - 1);
9700 request.SetHeader(
"x-ms-range", std::move(headerValue));
9702 request.SetHeader(
"x-ms-page-write",
"clear");
9703 if (options.LeaseId.HasValue())
9705 request.SetHeader(
"x-ms-lease-id", options.LeaseId.Value());
9707 if (options.IfSequenceNumberLessThanOrEqualTo.HasValue())
9710 "x-ms-if-sequence-number-le",
9711 std::to_string(options.IfSequenceNumberLessThanOrEqualTo.Value()));
9713 if (options.IfSequenceNumberLessThan.HasValue())
9716 "x-ms-if-sequence-number-lt",
9717 std::to_string(options.IfSequenceNumberLessThan.Value()));
9719 if (options.IfSequenceNumberEqualTo.HasValue())
9722 "x-ms-if-sequence-number-eq",
9723 std::to_string(options.IfSequenceNumberEqualTo.Value()));
9725 if (options.EncryptionKey.HasValue())
9727 request.SetHeader(
"x-ms-encryption-key", options.EncryptionKey.Value());
9729 if (options.EncryptionKeySha256.HasValue())
9732 "x-ms-encryption-key-sha256",
9733 Azure::Core::Convert::Base64Encode(options.EncryptionKeySha256.Value()));
9735 if (options.EncryptionAlgorithm.HasValue())
9738 "x-ms-encryption-algorithm", options.EncryptionAlgorithm.Value().ToString());
9740 if (options.EncryptionScope.HasValue())
9742 request.SetHeader(
"x-ms-encryption-scope", options.EncryptionScope.Value());
9744 if (options.IfModifiedSince.HasValue())
9747 "If-Modified-Since",
9748 options.IfModifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
9750 if (options.IfUnmodifiedSince.HasValue())
9753 "If-Unmodified-Since",
9754 options.IfUnmodifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
9756 if (options.IfMatch.HasValue() && !options.IfMatch.ToString().empty())
9758 request.SetHeader(
"If-Match", options.IfMatch.ToString());
9760 if (options.IfNoneMatch.HasValue() && !options.IfNoneMatch.ToString().empty())
9762 request.SetHeader(
"If-None-Match", options.IfNoneMatch.ToString());
9764 if (options.IfTags.HasValue())
9766 request.SetHeader(
"x-ms-if-tags", options.IfTags.Value());
9768 auto pHttpResponse = pipeline.Send(request, context);
9769 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
9770 ClearPagesResult response;
9771 auto http_status_code
9772 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
9773 httpResponse.GetStatusCode());
9774 if (!(http_status_code == 201))
9776 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
9778 response.ETag = Azure::ETag(httpResponse.GetHeaders().at(
"etag"));
9779 response.LastModified = Azure::DateTime::Parse(
9780 httpResponse.GetHeaders().at(
"last-modified"), Azure::DateTime::DateFormat::Rfc1123);
9781 response.SequenceNumber
9782 = std::stoll(httpResponse.GetHeaders().at(
"x-ms-blob-sequence-number"));
9783 return Azure::Response<ClearPagesResult>(std::move(response), std::move(pHttpResponse));
9786 struct ResizePageBlobOptions final
9788 Azure::Nullable<int32_t> Timeout;
9789 int64_t BlobSize = -1;
9790 Azure::Nullable<std::string> LeaseId;
9791 Azure::Nullable<int64_t> IfSequenceNumberLessThanOrEqualTo;
9792 Azure::Nullable<int64_t> IfSequenceNumberLessThan;
9793 Azure::Nullable<int64_t> IfSequenceNumberEqualTo;
9794 Azure::Nullable<std::string> EncryptionKey;
9795 Azure::Nullable<std::vector<uint8_t>> EncryptionKeySha256;
9796 Azure::Nullable<EncryptionAlgorithmType> EncryptionAlgorithm;
9797 Azure::Nullable<std::string> EncryptionScope;
9798 Azure::Nullable<Azure::DateTime> IfModifiedSince;
9799 Azure::Nullable<Azure::DateTime> IfUnmodifiedSince;
9800 Azure::ETag IfMatch;
9801 Azure::ETag IfNoneMatch;
9802 Azure::Nullable<std::string> IfTags;
9805 static Azure::Response<ResizePageBlobResult> Resize(
9806 Azure::Core::Http::_internal::HttpPipeline& pipeline,
9807 const Azure::Core::Url& url,
9808 const ResizePageBlobOptions& options,
9809 const Azure::Core::Context& context)
9812 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
9813 request.SetHeader(
"Content-Length",
"0");
9814 request.GetUrl().AppendQueryParameter(
"comp",
"properties");
9815 request.SetHeader(
"x-ms-version",
"2020-02-10");
9816 if (options.Timeout.HasValue())
9818 request.GetUrl().AppendQueryParameter(
9819 "timeout", std::to_string(options.Timeout.Value()));
9821 request.SetHeader(
"x-ms-blob-content-length", std::to_string(options.BlobSize));
9822 if (options.LeaseId.HasValue())
9824 request.SetHeader(
"x-ms-lease-id", options.LeaseId.Value());
9826 if (options.IfSequenceNumberLessThanOrEqualTo.HasValue())
9829 "x-ms-if-sequence-number-le",
9830 std::to_string(options.IfSequenceNumberLessThanOrEqualTo.Value()));
9832 if (options.IfSequenceNumberLessThan.HasValue())
9835 "x-ms-if-sequence-number-lt",
9836 std::to_string(options.IfSequenceNumberLessThan.Value()));
9838 if (options.IfSequenceNumberEqualTo.HasValue())
9841 "x-ms-if-sequence-number-eq",
9842 std::to_string(options.IfSequenceNumberEqualTo.Value()));
9844 if (options.EncryptionKey.HasValue())
9846 request.SetHeader(
"x-ms-encryption-key", options.EncryptionKey.Value());
9848 if (options.EncryptionKeySha256.HasValue())
9851 "x-ms-encryption-key-sha256",
9852 Azure::Core::Convert::Base64Encode(options.EncryptionKeySha256.Value()));
9854 if (options.EncryptionAlgorithm.HasValue())
9857 "x-ms-encryption-algorithm", options.EncryptionAlgorithm.Value().ToString());
9859 if (options.EncryptionScope.HasValue())
9861 request.SetHeader(
"x-ms-encryption-scope", options.EncryptionScope.Value());
9863 if (options.IfModifiedSince.HasValue())
9866 "If-Modified-Since",
9867 options.IfModifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
9869 if (options.IfUnmodifiedSince.HasValue())
9872 "If-Unmodified-Since",
9873 options.IfUnmodifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
9875 if (options.IfMatch.HasValue() && !options.IfMatch.ToString().empty())
9877 request.SetHeader(
"If-Match", options.IfMatch.ToString());
9879 if (options.IfNoneMatch.HasValue() && !options.IfNoneMatch.ToString().empty())
9881 request.SetHeader(
"If-None-Match", options.IfNoneMatch.ToString());
9883 if (options.IfTags.HasValue())
9885 request.SetHeader(
"x-ms-if-tags", options.IfTags.Value());
9887 auto pHttpResponse = pipeline.Send(request, context);
9888 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
9889 ResizePageBlobResult response;
9890 auto http_status_code
9891 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
9892 httpResponse.GetStatusCode());
9893 if (!(http_status_code == 200))
9895 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
9897 response.ETag = Azure::ETag(httpResponse.GetHeaders().at(
"etag"));
9898 response.LastModified = Azure::DateTime::Parse(
9899 httpResponse.GetHeaders().at(
"last-modified"), Azure::DateTime::DateFormat::Rfc1123);
9900 response.SequenceNumber
9901 = std::stoll(httpResponse.GetHeaders().at(
"x-ms-blob-sequence-number"));
9902 return Azure::Response<ResizePageBlobResult>(
9903 std::move(response), std::move(pHttpResponse));
9906 struct GetPageBlobPageRangesOptions final
9908 Azure::Nullable<int32_t> Timeout;
9909 Azure::Nullable<std::string> PreviousSnapshot;
9910 Azure::Nullable<std::string> PreviousSnapshotUrl;
9911 Azure::Nullable<Azure::Core::Http::HttpRange> Range;
9912 Azure::Nullable<std::string> LeaseId;
9913 Azure::Nullable<Azure::DateTime> IfModifiedSince;
9914 Azure::Nullable<Azure::DateTime> IfUnmodifiedSince;
9915 Azure::ETag IfMatch;
9916 Azure::ETag IfNoneMatch;
9917 Azure::Nullable<std::string> IfTags;
9920 static Azure::Response<Models::_detail::GetPageRangesResult> GetPageRanges(
9921 Azure::Core::Http::_internal::HttpPipeline& pipeline,
9922 const Azure::Core::Url& url,
9923 const GetPageBlobPageRangesOptions& options,
9924 const Azure::Core::Context& context)
9927 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url);
9928 request.GetUrl().AppendQueryParameter(
"comp",
"pagelist");
9929 if (options.PreviousSnapshot.HasValue())
9931 request.GetUrl().AppendQueryParameter(
9933 _internal::UrlEncodeQueryParameter(options.PreviousSnapshot.Value()));
9935 request.SetHeader(
"x-ms-version",
"2020-02-10");
9936 if (options.Timeout.HasValue())
9938 request.GetUrl().AppendQueryParameter(
9939 "timeout", std::to_string(options.Timeout.Value()));
9941 if (options.Range.HasValue())
9943 std::string headerValue =
"bytes=" + std::to_string(options.Range.Value().Offset) +
"-";
9944 if (options.Range.Value().Length.HasValue())
9946 headerValue += std::to_string(
9947 options.Range.Value().Offset + options.Range.Value().Length.Value() - 1);
9949 request.SetHeader(
"x-ms-range", std::move(headerValue));
9951 if (options.LeaseId.HasValue())
9953 request.SetHeader(
"x-ms-lease-id", options.LeaseId.Value());
9955 if (options.PreviousSnapshotUrl.HasValue())
9957 request.SetHeader(
"x-ms-previous-snapshot-url", options.PreviousSnapshotUrl.Value());
9959 if (options.IfModifiedSince.HasValue())
9962 "If-Modified-Since",
9963 options.IfModifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
9965 if (options.IfUnmodifiedSince.HasValue())
9968 "If-Unmodified-Since",
9969 options.IfUnmodifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
9971 if (options.IfMatch.HasValue() && !options.IfMatch.ToString().empty())
9973 request.SetHeader(
"If-Match", options.IfMatch.ToString());
9975 if (options.IfNoneMatch.HasValue() && !options.IfNoneMatch.ToString().empty())
9977 request.SetHeader(
"If-None-Match", options.IfNoneMatch.ToString());
9979 if (options.IfTags.HasValue())
9981 request.SetHeader(
"x-ms-if-tags", options.IfTags.Value());
9983 auto pHttpResponse = pipeline.Send(request, context);
9984 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
9985 Models::_detail::GetPageRangesResult response;
9986 auto http_status_code
9987 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
9988 httpResponse.GetStatusCode());
9989 if (!(http_status_code == 200))
9991 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
9994 const auto& httpResponseBody = httpResponse.GetBody();
9995 _internal::XmlReader reader(
9996 reinterpret_cast<const char*
>(httpResponseBody.data()), httpResponseBody.size());
9997 response = GetPageRangesResultInternalFromXml(reader);
9999 response.ETag = Azure::ETag(httpResponse.GetHeaders().at(
"etag"));
10000 response.LastModified = Azure::DateTime::Parse(
10001 httpResponse.GetHeaders().at(
"last-modified"), Azure::DateTime::DateFormat::Rfc1123);
10002 response.BlobSize = std::stoll(httpResponse.GetHeaders().at(
"x-ms-blob-content-length"));
10003 return Azure::Response<Models::_detail::GetPageRangesResult>(
10004 std::move(response), std::move(pHttpResponse));
10007 struct StartBlobCopyIncrementalOptions final
10009 Azure::Nullable<int32_t> Timeout;
10010 std::string CopySource;
10011 Azure::Nullable<Azure::DateTime> IfModifiedSince;
10012 Azure::Nullable<Azure::DateTime> IfUnmodifiedSince;
10013 Azure::ETag IfMatch;
10014 Azure::ETag IfNoneMatch;
10015 Azure::Nullable<std::string> IfTags;
10018 static Azure::Response<Models::_detail::StartBlobCopyIncrementalResult>
10019 StartCopyIncremental(
10020 Azure::Core::Http::_internal::HttpPipeline& pipeline,
10021 const Azure::Core::Url& url,
10022 const StartBlobCopyIncrementalOptions& options,
10023 const Azure::Core::Context& context)
10026 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
10027 request.SetHeader(
"Content-Length",
"0");
10028 request.GetUrl().AppendQueryParameter(
"comp",
"incrementalcopy");
10029 request.SetHeader(
"x-ms-version",
"2020-02-10");
10030 if (options.Timeout.HasValue())
10032 request.GetUrl().AppendQueryParameter(
10033 "timeout", std::to_string(options.Timeout.Value()));
10035 request.SetHeader(
"x-ms-copy-source", options.CopySource);
10036 if (options.IfModifiedSince.HasValue())
10039 "If-Modified-Since",
10040 options.IfModifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
10042 if (options.IfUnmodifiedSince.HasValue())
10045 "If-Unmodified-Since",
10046 options.IfUnmodifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
10048 if (options.IfMatch.HasValue() && !options.IfMatch.ToString().empty())
10050 request.SetHeader(
"If-Match", options.IfMatch.ToString());
10052 if (options.IfNoneMatch.HasValue() && !options.IfNoneMatch.ToString().empty())
10054 request.SetHeader(
"If-None-Match", options.IfNoneMatch.ToString());
10056 if (options.IfTags.HasValue())
10058 request.SetHeader(
"x-ms-if-tags", options.IfTags.Value());
10060 auto pHttpResponse = pipeline.Send(request, context);
10061 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
10062 Models::_detail::StartBlobCopyIncrementalResult response;
10063 auto http_status_code
10064 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
10065 httpResponse.GetStatusCode());
10066 if (!(http_status_code == 202))
10068 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
10070 response.ETag = Azure::ETag(httpResponse.GetHeaders().at(
"etag"));
10071 response.LastModified = Azure::DateTime::Parse(
10072 httpResponse.GetHeaders().at(
"last-modified"), Azure::DateTime::DateFormat::Rfc1123);
10073 response.CopyId = httpResponse.GetHeaders().at(
"x-ms-copy-id");
10074 response.CopyStatus = CopyStatus(httpResponse.GetHeaders().at(
"x-ms-copy-status"));
10075 auto x_ms_version_id__iterator = httpResponse.GetHeaders().find(
"x-ms-version-id");
10076 if (x_ms_version_id__iterator != httpResponse.GetHeaders().end())
10078 response.VersionId = x_ms_version_id__iterator->second;
10080 return Azure::Response<Models::_detail::StartBlobCopyIncrementalResult>(
10081 std::move(response), std::move(pHttpResponse));
10085 static Models::_detail::GetPageRangesResult GetPageRangesResultInternalFromXml(
10086 _internal::XmlReader& reader)
10088 Models::_detail::GetPageRangesResult ret;
10089 enum class XmlTagName
10096 std::vector<XmlTagName> path;
10099 auto node = reader.Read();
10100 if (node.Type == _internal::XmlNodeType::End)
10104 else if (node.Type == _internal::XmlNodeType::EndTag)
10106 if (path.size() > 0)
10115 else if (node.Type == _internal::XmlNodeType::StartTag)
10117 if (std::strcmp(node.Name,
"PageList") == 0)
10119 path.emplace_back(XmlTagName::k_PageList);
10121 else if (std::strcmp(node.Name,
"PageRange") == 0)
10123 path.emplace_back(XmlTagName::k_PageRange);
10125 else if (std::strcmp(node.Name,
"ClearRange") == 0)
10127 path.emplace_back(XmlTagName::k_ClearRange);
10131 path.emplace_back(XmlTagName::k_Unknown);
10133 if (path.size() == 2 && path[0] == XmlTagName::k_PageList
10134 && path[1] == XmlTagName::k_PageRange)
10136 ret.PageRanges.emplace_back(PageRangesFromXml(reader));
10140 path.size() == 2 && path[0] == XmlTagName::k_PageList
10141 && path[1] == XmlTagName::k_ClearRange)
10143 ret.ClearRanges.emplace_back(ClearRangesFromXml(reader));
10147 else if (node.Type == _internal::XmlNodeType::Text)
10154 static Azure::Core::Http::HttpRange ClearRangesFromXml(_internal::XmlReader& reader)
10157 bool is_start =
false;
10158 bool is_end =
false;
10163 auto node = reader.Read();
10164 if (node.Type == _internal::XmlNodeType::End)
10169 node.Type == _internal::XmlNodeType::StartTag && strcmp(node.Name,
"Start") == 0)
10174 else if (node.Type == _internal::XmlNodeType::StartTag && strcmp(node.Name,
"End") == 0)
10179 else if (node.Type == _internal::XmlNodeType::EndTag)
10188 if (depth == 1 && node.Type == _internal::XmlNodeType::Text)
10192 start = std::stoll(node.Value);
10196 end = std::stoll(node.Value);
10200 Azure::Core::Http::HttpRange ret;
10201 ret.Offset = start;
10202 ret.Length = end - start + 1;
10206 static Azure::Core::Http::HttpRange PageRangesFromXml(_internal::XmlReader& reader)
10209 bool is_start =
false;
10210 bool is_end =
false;
10215 auto node = reader.Read();
10216 if (node.Type == _internal::XmlNodeType::End)
10221 node.Type == _internal::XmlNodeType::StartTag && strcmp(node.Name,
"Start") == 0)
10226 else if (node.Type == _internal::XmlNodeType::StartTag && strcmp(node.Name,
"End") == 0)
10231 else if (node.Type == _internal::XmlNodeType::EndTag)
10240 if (depth == 1 && node.Type == _internal::XmlNodeType::Text)
10244 start = std::stoll(node.Value);
10248 end = std::stoll(node.Value);
10252 Azure::Core::Http::HttpRange ret;
10253 ret.Offset = start;
10254 ret.Length = end - start + 1;
10260 class AppendBlob final {
10262 struct CreateAppendBlobOptions final
10264 Azure::Nullable<int32_t> Timeout;
10265 BlobHttpHeaders HttpHeaders;
10266 Storage::Metadata Metadata;
10267 Azure::Nullable<std::string> LeaseId;
10268 Azure::Nullable<std::string> EncryptionKey;
10269 Azure::Nullable<std::vector<uint8_t>> EncryptionKeySha256;
10270 Azure::Nullable<EncryptionAlgorithmType> EncryptionAlgorithm;
10271 Azure::Nullable<std::string> EncryptionScope;
10272 Azure::Nullable<Azure::DateTime> IfModifiedSince;
10273 Azure::Nullable<Azure::DateTime> IfUnmodifiedSince;
10274 Azure::ETag IfMatch;
10275 Azure::ETag IfNoneMatch;
10276 Azure::Nullable<std::string> IfTags;
10279 static Azure::Response<CreateAppendBlobResult> Create(
10280 Azure::Core::Http::_internal::HttpPipeline& pipeline,
10281 const Azure::Core::Url& url,
10282 const CreateAppendBlobOptions& options,
10283 const Azure::Core::Context& context)
10286 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
10287 request.SetHeader(
"Content-Length",
"0");
10288 request.SetHeader(
"x-ms-version",
"2020-02-10");
10289 if (options.Timeout.HasValue())
10291 request.GetUrl().AppendQueryParameter(
10292 "timeout", std::to_string(options.Timeout.Value()));
10294 if (!options.HttpHeaders.ContentType.empty())
10296 request.SetHeader(
"x-ms-blob-content-type", options.HttpHeaders.ContentType);
10298 if (!options.HttpHeaders.ContentEncoding.empty())
10300 request.SetHeader(
"x-ms-blob-content-encoding", options.HttpHeaders.ContentEncoding);
10302 if (!options.HttpHeaders.ContentLanguage.empty())
10304 request.SetHeader(
"x-ms-blob-content-language", options.HttpHeaders.ContentLanguage);
10306 if (!options.HttpHeaders.CacheControl.empty())
10308 request.SetHeader(
"x-ms-blob-cache-control", options.HttpHeaders.CacheControl);
10310 if (!Azure::Core::Convert::Base64Encode(options.HttpHeaders.ContentHash.Value).empty())
10313 "x-ms-blob-content-md5",
10314 Azure::Core::Convert::Base64Encode(options.HttpHeaders.ContentHash.Value));
10316 if (!options.HttpHeaders.ContentDisposition.empty())
10319 "x-ms-blob-content-disposition", options.HttpHeaders.ContentDisposition);
10321 for (
const auto& pair : options.Metadata)
10323 request.SetHeader(
"x-ms-meta-" + pair.first, pair.second);
10325 if (options.LeaseId.HasValue())
10327 request.SetHeader(
"x-ms-lease-id", options.LeaseId.Value());
10329 request.SetHeader(
"x-ms-blob-type",
"AppendBlob");
10330 if (options.EncryptionKey.HasValue())
10332 request.SetHeader(
"x-ms-encryption-key", options.EncryptionKey.Value());
10334 if (options.EncryptionKeySha256.HasValue())
10337 "x-ms-encryption-key-sha256",
10338 Azure::Core::Convert::Base64Encode(options.EncryptionKeySha256.Value()));
10340 if (options.EncryptionAlgorithm.HasValue())
10343 "x-ms-encryption-algorithm", options.EncryptionAlgorithm.Value().ToString());
10345 if (options.EncryptionScope.HasValue())
10347 request.SetHeader(
"x-ms-encryption-scope", options.EncryptionScope.Value());
10349 if (options.IfModifiedSince.HasValue())
10352 "If-Modified-Since",
10353 options.IfModifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
10355 if (options.IfUnmodifiedSince.HasValue())
10358 "If-Unmodified-Since",
10359 options.IfUnmodifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
10361 if (options.IfMatch.HasValue() && !options.IfMatch.ToString().empty())
10363 request.SetHeader(
"If-Match", options.IfMatch.ToString());
10365 if (options.IfNoneMatch.HasValue() && !options.IfNoneMatch.ToString().empty())
10367 request.SetHeader(
"If-None-Match", options.IfNoneMatch.ToString());
10369 if (options.IfTags.HasValue())
10371 request.SetHeader(
"x-ms-if-tags", options.IfTags.Value());
10373 auto pHttpResponse = pipeline.Send(request, context);
10374 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
10375 CreateAppendBlobResult response;
10376 auto http_status_code
10377 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
10378 httpResponse.GetStatusCode());
10379 if (!(http_status_code == 201))
10381 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
10383 response.ETag = Azure::ETag(httpResponse.GetHeaders().at(
"etag"));
10384 response.LastModified = Azure::DateTime::Parse(
10385 httpResponse.GetHeaders().at(
"last-modified"), Azure::DateTime::DateFormat::Rfc1123);
10386 auto x_ms_version_id__iterator = httpResponse.GetHeaders().find(
"x-ms-version-id");
10387 if (x_ms_version_id__iterator != httpResponse.GetHeaders().end())
10389 response.VersionId = x_ms_version_id__iterator->second;
10391 response.IsServerEncrypted
10392 = httpResponse.GetHeaders().at(
"x-ms-request-server-encrypted") ==
"true";
10393 auto x_ms_encryption_key_sha256__iterator
10394 = httpResponse.GetHeaders().find(
"x-ms-encryption-key-sha256");
10395 if (x_ms_encryption_key_sha256__iterator != httpResponse.GetHeaders().end())
10397 response.EncryptionKeySha256
10398 = Azure::Core::Convert::Base64Decode(x_ms_encryption_key_sha256__iterator->second);
10400 auto x_ms_encryption_scope__iterator
10401 = httpResponse.GetHeaders().find(
"x-ms-encryption-scope");
10402 if (x_ms_encryption_scope__iterator != httpResponse.GetHeaders().end())
10404 response.EncryptionScope = x_ms_encryption_scope__iterator->second;
10406 return Azure::Response<CreateAppendBlobResult>(
10407 std::move(response), std::move(pHttpResponse));
10410 struct AppendBlockOptions final
10412 Azure::Nullable<int32_t> Timeout;
10413 Azure::Nullable<ContentHash> TransactionalContentHash;
10414 Azure::Nullable<std::string> LeaseId;
10415 Azure::Nullable<int64_t> MaxSize;
10416 Azure::Nullable<int64_t> AppendPosition;
10417 Azure::Nullable<std::string> EncryptionKey;
10418 Azure::Nullable<std::vector<uint8_t>> EncryptionKeySha256;
10419 Azure::Nullable<EncryptionAlgorithmType> EncryptionAlgorithm;
10420 Azure::Nullable<std::string> EncryptionScope;
10421 Azure::Nullable<Azure::DateTime> IfModifiedSince;
10422 Azure::Nullable<Azure::DateTime> IfUnmodifiedSince;
10423 Azure::ETag IfMatch;
10424 Azure::ETag IfNoneMatch;
10425 Azure::Nullable<std::string> IfTags;
10428 static Azure::Response<AppendBlockResult> AppendBlock(
10429 Azure::Core::Http::_internal::HttpPipeline& pipeline,
10430 const Azure::Core::Url& url,
10431 Azure::Core::IO::BodyStream& requestBody,
10432 const AppendBlockOptions& options,
10433 const Azure::Core::Context& context)
10437 = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url, &requestBody);
10438 request.SetHeader(
"Content-Length", std::to_string(requestBody.Length()));
10439 request.GetUrl().AppendQueryParameter(
"comp",
"appendblock");
10440 request.SetHeader(
"x-ms-version",
"2020-02-10");
10441 if (options.Timeout.HasValue())
10443 request.GetUrl().AppendQueryParameter(
10444 "timeout", std::to_string(options.Timeout.Value()));
10446 if (options.TransactionalContentHash.HasValue())
10448 if (options.TransactionalContentHash.Value().Algorithm == HashAlgorithm::Md5)
10452 Azure::Core::Convert::Base64Encode(
10453 options.TransactionalContentHash.Value().Value));
10455 else if (options.TransactionalContentHash.Value().Algorithm == HashAlgorithm::Crc64)
10458 "x-ms-content-crc64",
10459 Azure::Core::Convert::Base64Encode(
10460 options.TransactionalContentHash.Value().Value));
10463 if (options.LeaseId.HasValue())
10465 request.SetHeader(
"x-ms-lease-id", options.LeaseId.Value());
10467 if (options.MaxSize.HasValue())
10470 "x-ms-blob-condition-maxsize", std::to_string(options.MaxSize.Value()));
10472 if (options.AppendPosition.HasValue())
10475 "x-ms-blob-condition-appendpos", std::to_string(options.AppendPosition.Value()));
10477 if (options.EncryptionKey.HasValue())
10479 request.SetHeader(
"x-ms-encryption-key", options.EncryptionKey.Value());
10481 if (options.EncryptionKeySha256.HasValue())
10484 "x-ms-encryption-key-sha256",
10485 Azure::Core::Convert::Base64Encode(options.EncryptionKeySha256.Value()));
10487 if (options.EncryptionAlgorithm.HasValue())
10490 "x-ms-encryption-algorithm", options.EncryptionAlgorithm.Value().ToString());
10492 if (options.EncryptionScope.HasValue())
10494 request.SetHeader(
"x-ms-encryption-scope", options.EncryptionScope.Value());
10496 if (options.IfModifiedSince.HasValue())
10499 "If-Modified-Since",
10500 options.IfModifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
10502 if (options.IfUnmodifiedSince.HasValue())
10505 "If-Unmodified-Since",
10506 options.IfUnmodifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
10508 if (options.IfMatch.HasValue() && !options.IfMatch.ToString().empty())
10510 request.SetHeader(
"If-Match", options.IfMatch.ToString());
10512 if (options.IfNoneMatch.HasValue() && !options.IfNoneMatch.ToString().empty())
10514 request.SetHeader(
"If-None-Match", options.IfNoneMatch.ToString());
10516 if (options.IfTags.HasValue())
10518 request.SetHeader(
"x-ms-if-tags", options.IfTags.Value());
10520 auto pHttpResponse = pipeline.Send(request, context);
10521 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
10522 AppendBlockResult response;
10523 auto http_status_code
10524 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
10525 httpResponse.GetStatusCode());
10526 if (!(http_status_code == 201))
10528 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
10530 response.ETag = Azure::ETag(httpResponse.GetHeaders().at(
"etag"));
10531 response.LastModified = Azure::DateTime::Parse(
10532 httpResponse.GetHeaders().at(
"last-modified"), Azure::DateTime::DateFormat::Rfc1123);
10534 const auto& headers = httpResponse.GetHeaders();
10535 auto content_md5_iterator = headers.find(
"content-md5");
10536 if (content_md5_iterator != headers.end())
10539 hash.Algorithm = HashAlgorithm::Md5;
10540 hash.Value = Azure::Core::Convert::Base64Decode(content_md5_iterator->second);
10541 response.TransactionalContentHash = std::move(hash);
10543 auto x_ms_content_crc64_iterator = headers.find(
"x-ms-content-crc64");
10544 if (x_ms_content_crc64_iterator != headers.end())
10547 hash.Algorithm = HashAlgorithm::Crc64;
10548 hash.Value = Azure::Core::Convert::Base64Decode(x_ms_content_crc64_iterator->second);
10549 response.TransactionalContentHash = std::move(hash);
10552 response.AppendOffset
10553 = std::stoll(httpResponse.GetHeaders().at(
"x-ms-blob-append-offset"));
10554 response.CommittedBlockCount
10555 = std::stoi(httpResponse.GetHeaders().at(
"x-ms-blob-committed-block-count"));
10556 response.IsServerEncrypted
10557 = httpResponse.GetHeaders().at(
"x-ms-request-server-encrypted") ==
"true";
10558 auto x_ms_encryption_key_sha256__iterator
10559 = httpResponse.GetHeaders().find(
"x-ms-encryption-key-sha256");
10560 if (x_ms_encryption_key_sha256__iterator != httpResponse.GetHeaders().end())
10562 response.EncryptionKeySha256
10563 = Azure::Core::Convert::Base64Decode(x_ms_encryption_key_sha256__iterator->second);
10565 auto x_ms_encryption_scope__iterator
10566 = httpResponse.GetHeaders().find(
"x-ms-encryption-scope");
10567 if (x_ms_encryption_scope__iterator != httpResponse.GetHeaders().end())
10569 response.EncryptionScope = x_ms_encryption_scope__iterator->second;
10571 return Azure::Response<AppendBlockResult>(std::move(response), std::move(pHttpResponse));
10574 struct AppendBlockFromUriOptions final
10576 Azure::Nullable<int32_t> Timeout;
10577 std::string SourceUri;
10578 Azure::Nullable<Azure::Core::Http::HttpRange> SourceRange;
10579 Azure::Nullable<ContentHash> TransactionalContentHash;
10580 Azure::Nullable<std::string> LeaseId;
10581 Azure::Nullable<int64_t> MaxSize;
10582 Azure::Nullable<int64_t> AppendPosition;
10583 Azure::Nullable<std::string> EncryptionKey;
10584 Azure::Nullable<std::vector<uint8_t>> EncryptionKeySha256;
10585 Azure::Nullable<EncryptionAlgorithmType> EncryptionAlgorithm;
10586 Azure::Nullable<std::string> EncryptionScope;
10587 Azure::Nullable<Azure::DateTime> IfModifiedSince;
10588 Azure::Nullable<Azure::DateTime> IfUnmodifiedSince;
10589 Azure::ETag IfMatch;
10590 Azure::ETag IfNoneMatch;
10591 Azure::Nullable<std::string> IfTags;
10594 static Azure::Response<AppendBlockFromUriResult> AppendBlockFromUri(
10595 Azure::Core::Http::_internal::HttpPipeline& pipeline,
10596 const Azure::Core::Url& url,
10597 const AppendBlockFromUriOptions& options,
10598 const Azure::Core::Context& context)
10601 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
10602 request.SetHeader(
"Content-Length",
"0");
10603 request.GetUrl().AppendQueryParameter(
"comp",
"appendblock");
10604 request.SetHeader(
"x-ms-version",
"2020-02-10");
10605 if (options.Timeout.HasValue())
10607 request.GetUrl().AppendQueryParameter(
10608 "timeout", std::to_string(options.Timeout.Value()));
10610 request.SetHeader(
"x-ms-copy-source", options.SourceUri);
10611 if (options.SourceRange.HasValue())
10613 std::string headerValue
10614 =
"bytes=" + std::to_string(options.SourceRange.Value().Offset) +
"-";
10615 if (options.SourceRange.Value().Length.HasValue())
10617 headerValue += std::to_string(
10618 options.SourceRange.Value().Offset + options.SourceRange.Value().Length.Value()
10621 request.SetHeader(
"x-ms-source-range", std::move(headerValue));
10623 if (options.TransactionalContentHash.HasValue())
10625 if (options.TransactionalContentHash.Value().Algorithm == HashAlgorithm::Md5)
10628 "x-ms-source-content-md5",
10629 Azure::Core::Convert::Base64Encode(
10630 options.TransactionalContentHash.Value().Value));
10632 else if (options.TransactionalContentHash.Value().Algorithm == HashAlgorithm::Crc64)
10635 "x-ms-source-content-crc64",
10636 Azure::Core::Convert::Base64Encode(
10637 options.TransactionalContentHash.Value().Value));
10640 if (options.LeaseId.HasValue())
10642 request.SetHeader(
"x-ms-lease-id", options.LeaseId.Value());
10644 if (options.MaxSize.HasValue())
10647 "x-ms-blob-condition-maxsize", std::to_string(options.MaxSize.Value()));
10649 if (options.AppendPosition.HasValue())
10652 "x-ms-blob-condition-appendpos", std::to_string(options.AppendPosition.Value()));
10654 if (options.EncryptionKey.HasValue())
10656 request.SetHeader(
"x-ms-encryption-key", options.EncryptionKey.Value());
10658 if (options.EncryptionKeySha256.HasValue())
10661 "x-ms-encryption-key-sha256",
10662 Azure::Core::Convert::Base64Encode(options.EncryptionKeySha256.Value()));
10664 if (options.EncryptionAlgorithm.HasValue())
10667 "x-ms-encryption-algorithm", options.EncryptionAlgorithm.Value().ToString());
10669 if (options.EncryptionScope.HasValue())
10671 request.SetHeader(
"x-ms-encryption-scope", options.EncryptionScope.Value());
10673 if (options.IfModifiedSince.HasValue())
10676 "If-Modified-Since",
10677 options.IfModifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
10679 if (options.IfUnmodifiedSince.HasValue())
10682 "If-Unmodified-Since",
10683 options.IfUnmodifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
10685 if (options.IfMatch.HasValue() && !options.IfMatch.ToString().empty())
10687 request.SetHeader(
"If-Match", options.IfMatch.ToString());
10689 if (options.IfNoneMatch.HasValue() && !options.IfNoneMatch.ToString().empty())
10691 request.SetHeader(
"If-None-Match", options.IfNoneMatch.ToString());
10693 if (options.IfTags.HasValue())
10695 request.SetHeader(
"x-ms-if-tags", options.IfTags.Value());
10697 auto pHttpResponse = pipeline.Send(request, context);
10698 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
10699 AppendBlockFromUriResult response;
10700 auto http_status_code
10701 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
10702 httpResponse.GetStatusCode());
10703 if (!(http_status_code == 201))
10705 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
10707 response.ETag = Azure::ETag(httpResponse.GetHeaders().at(
"etag"));
10708 response.LastModified = Azure::DateTime::Parse(
10709 httpResponse.GetHeaders().at(
"last-modified"), Azure::DateTime::DateFormat::Rfc1123);
10711 const auto& headers = httpResponse.GetHeaders();
10712 auto content_md5_iterator = headers.find(
"content-md5");
10713 if (content_md5_iterator != headers.end())
10716 hash.Algorithm = HashAlgorithm::Md5;
10717 hash.Value = Azure::Core::Convert::Base64Decode(content_md5_iterator->second);
10718 response.TransactionalContentHash = std::move(hash);
10720 auto x_ms_content_crc64_iterator = headers.find(
"x-ms-content-crc64");
10721 if (x_ms_content_crc64_iterator != headers.end())
10724 hash.Algorithm = HashAlgorithm::Crc64;
10725 hash.Value = Azure::Core::Convert::Base64Decode(x_ms_content_crc64_iterator->second);
10726 response.TransactionalContentHash = std::move(hash);
10729 response.AppendOffset
10730 = std::stoll(httpResponse.GetHeaders().at(
"x-ms-blob-append-offset"));
10731 response.CommittedBlockCount
10732 = std::stoi(httpResponse.GetHeaders().at(
"x-ms-blob-committed-block-count"));
10733 response.IsServerEncrypted
10734 = httpResponse.GetHeaders().at(
"x-ms-request-server-encrypted") ==
"true";
10735 auto x_ms_encryption_key_sha256__iterator
10736 = httpResponse.GetHeaders().find(
"x-ms-encryption-key-sha256");
10737 if (x_ms_encryption_key_sha256__iterator != httpResponse.GetHeaders().end())
10739 response.EncryptionKeySha256
10740 = Azure::Core::Convert::Base64Decode(x_ms_encryption_key_sha256__iterator->second);
10742 auto x_ms_encryption_scope__iterator
10743 = httpResponse.GetHeaders().find(
"x-ms-encryption-scope");
10744 if (x_ms_encryption_scope__iterator != httpResponse.GetHeaders().end())
10746 response.EncryptionScope = x_ms_encryption_scope__iterator->second;
10748 return Azure::Response<AppendBlockFromUriResult>(
10749 std::move(response), std::move(pHttpResponse));
10752 struct SealAppendBlobOptions final
10754 Azure::Nullable<int32_t> Timeout;
10755 Azure::Nullable<std::string> LeaseId;
10756 Azure::Nullable<Azure::DateTime> IfModifiedSince;
10757 Azure::Nullable<Azure::DateTime> IfUnmodifiedSince;
10758 Azure::ETag IfMatch;
10759 Azure::ETag IfNoneMatch;
10760 Azure::Nullable<std::string> IfTags;
10761 Azure::Nullable<int64_t> AppendPosition;
10764 static Azure::Response<SealAppendBlobResult> Seal(
10765 Azure::Core::Http::_internal::HttpPipeline& pipeline,
10766 const Azure::Core::Url& url,
10767 const SealAppendBlobOptions& options,
10768 const Azure::Core::Context& context)
10771 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
10772 request.SetHeader(
"Content-Length",
"0");
10773 request.GetUrl().AppendQueryParameter(
"comp",
"seal");
10774 request.SetHeader(
"x-ms-version",
"2020-02-10");
10775 if (options.Timeout.HasValue())
10777 request.GetUrl().AppendQueryParameter(
10778 "timeout", std::to_string(options.Timeout.Value()));
10780 if (options.LeaseId.HasValue())
10782 request.SetHeader(
"x-ms-lease-id", options.LeaseId.Value());
10784 if (options.IfModifiedSince.HasValue())
10787 "If-Modified-Since",
10788 options.IfModifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
10790 if (options.IfUnmodifiedSince.HasValue())
10793 "If-Unmodified-Since",
10794 options.IfUnmodifiedSince.Value().ToString(Azure::DateTime::DateFormat::Rfc1123));
10796 if (options.IfMatch.HasValue() && !options.IfMatch.ToString().empty())
10798 request.SetHeader(
"If-Match", options.IfMatch.ToString());
10800 if (options.IfNoneMatch.HasValue() && !options.IfNoneMatch.ToString().empty())
10802 request.SetHeader(
"If-None-Match", options.IfNoneMatch.ToString());
10804 if (options.IfTags.HasValue())
10806 request.SetHeader(
"x-ms-if-tags", options.IfTags.Value());
10808 if (options.AppendPosition.HasValue())
10811 "x-ms-blob-condition-appendpos", std::to_string(options.AppendPosition.Value()));
10813 auto pHttpResponse = pipeline.Send(request, context);
10814 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
10815 SealAppendBlobResult response;
10816 auto http_status_code
10817 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
10818 httpResponse.GetStatusCode());
10819 if (!(http_status_code == 200))
10821 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
10823 response.ETag = Azure::ETag(httpResponse.GetHeaders().at(
"etag"));
10824 response.LastModified = Azure::DateTime::Parse(
10825 httpResponse.GetHeaders().at(
"last-modified"), Azure::DateTime::DateFormat::Rfc1123);
10826 return Azure::Response<SealAppendBlobResult>(
10827 std::move(response), std::move(pHttpResponse));
10833 class BlobBatch final {
10835 struct SubmitBlobBatchOptions final
10837 Azure::Nullable<int32_t> Timeout;
10838 std::string ContentType;
10841 static Azure::Response<Models::_detail::SubmitBlobBatchResult> SubmitBatch(
10842 Azure::Core::Http::_internal::HttpPipeline& pipeline,
10843 const Azure::Core::Url& url,
10844 Azure::Core::IO::BodyStream& requestBody,
10845 const SubmitBlobBatchOptions& options,
10846 const Azure::Core::Context& context)
10850 = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Post, url, &requestBody);
10851 request.SetHeader(
"Content-Length", std::to_string(requestBody.Length()));
10852 request.GetUrl().AppendQueryParameter(
"comp",
"batch");
10853 request.SetHeader(
"x-ms-version",
"2020-02-10");
10854 if (options.Timeout.HasValue())
10856 request.GetUrl().AppendQueryParameter(
10857 "timeout", std::to_string(options.Timeout.Value()));
10859 request.SetHeader(
"Content-Type", options.ContentType);
10860 auto pHttpResponse = pipeline.Send(request, context);
10861 Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
10862 Models::_detail::SubmitBlobBatchResult response;
10863 auto http_status_code
10864 =
static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type
>(
10865 httpResponse.GetStatusCode());
10866 if (!(http_status_code == 202))
10868 throw StorageException::CreateFromResponse(std::move(pHttpResponse));
10870 response.ContentType = httpResponse.GetHeaders().at(
"content-type");
10871 return Azure::Response<Models::_detail::SubmitBlobBatchResult>(
10872 std::move(response), std::move(pHttpResponse));