github/azure-sdk-for-cpp
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

remove c_ (#1000)

Browse Source 
* remove c_

* remove more c_

* remove more
This commit is contained in:
JinmingHu 2020-11-20 12:24:23 +08:00 committed by GitHub
parent 2b56b8b026
commit fadb43e664
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
41 changed files with 330 additions and 330 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
sdk/storage/azure-storage-blobs/inc/azure/storage/blobs/blob_client.hpp
View File

@ -287,7 +287,7 @@ namespace Azure { namespace Storage { namespace Blobs {
*
* @param proposedLeaseId Proposed lease ID, in a GUID string format.
* @param duration Specifies the duration of
* the lease, in seconds, or Azure::Storage::c_InfiniteLeaseDuration for a lease that never
* the lease, in seconds, or Azure::Storage::InfiniteLeaseDuration for a lease that never
* expires. A non-infinite lease can be between 15 and 60 seconds. A lease duration cannot be
* changed using renew or change.
* @param options Optional parameters to execute this function.

2
sdk/storage/azure-storage-blobs/inc/azure/storage/blobs/blob_container_client.hpp
View File

@ -241,7 +241,7 @@ namespace Azure { namespace Storage { namespace Blobs {
* @param proposedLeaseId
* Proposed lease ID, in a GUID string format.
* @param duration Specifies the duration of
* the lease, in seconds, or Azure::Storage::c_InfiniteLeaseDuration for a lease that never
* the lease, in seconds, or Azure::Storage::InfiniteLeaseDuration for a lease that never
* expires. A non-infinite lease can be between 15 and 60 seconds. A lease duration cannot be
* changed using renew or change.
* @param options Optional parameters to execute this

114
sdk/storage/azure-storage-blobs/inc/azure/storage/blobs/protocol/blob_rest_client.hpp
View File

@ -26,7 +26,7 @@
namespace Azure { namespace Storage { namespace Blobs {
namespace Details {
constexpr static const char* c_ApiVersion = "2020-02-10";
constexpr static const char* ApiVersion = "2020-02-10";
} // namespace Details
namespace Models {
@ -1719,7 +1719,7 @@ namespace Azure { namespace Storage { namespace Blobs {
{
unused(options);
auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url);
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -1798,7 +1798,7 @@ namespace Azure { namespace Storage { namespace Blobs {
request.AddHeader("Content-Length", std::to_string(xml_body_stream.Length()));
request.GetUrl().AppendQueryParameter("restype", "service");
request.GetUrl().AppendQueryParameter("comp", "userdelegationkey");
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -1839,7 +1839,7 @@ namespace Azure { namespace Storage { namespace Blobs {
auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url);
request.GetUrl().AppendQueryParameter("restype", "service");
request.GetUrl().AppendQueryParameter("comp", "properties");
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -1892,7 +1892,7 @@ namespace Azure { namespace Storage { namespace Blobs {
request.AddHeader("Content-Length", std::to_string(xml_body_stream.Length()));
request.GetUrl().AppendQueryParameter("restype", "service");
request.GetUrl().AppendQueryParameter("comp", "properties");
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -1927,7 +1927,7 @@ namespace Azure { namespace Storage { namespace Blobs {
auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Head, url);
request.GetUrl().AppendQueryParameter("restype", "account");
request.GetUrl().AppendQueryParameter("comp", "properties");
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -1965,7 +1965,7 @@ namespace Azure { namespace Storage { namespace Blobs {
auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url);
request.GetUrl().AppendQueryParameter("restype", "service");
request.GetUrl().AppendQueryParameter("comp", "stats");
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -2007,7 +2007,7 @@ namespace Azure { namespace Storage { namespace Blobs {
{
unused(options);
auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url);
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -3557,7 +3557,7 @@ namespace Azure { namespace Storage { namespace Blobs {
auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
request.AddHeader("Content-Length", "0");
request.GetUrl().AppendQueryParameter("restype", "container");
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -3622,7 +3622,7 @@ namespace Azure { namespace Storage { namespace Blobs {
unused(options);
auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Delete, url);
request.GetUrl().AppendQueryParameter("restype", "container");
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -3672,7 +3672,7 @@ namespace Azure { namespace Storage { namespace Blobs {
request.AddHeader("Content-Length", "0");
request.GetUrl().AppendQueryParameter("restype", "container");
request.GetUrl().AppendQueryParameter("comp", "undelete");
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -3709,7 +3709,7 @@ namespace Azure { namespace Storage { namespace Blobs {
unused(options);
auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Head, url);
request.GetUrl().AppendQueryParameter("restype", "container");
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -3783,7 +3783,7 @@ namespace Azure { namespace Storage { namespace Blobs {
request.AddHeader("Content-Length", "0");
request.GetUrl().AppendQueryParameter("restype", "container");
request.GetUrl().AppendQueryParameter("comp", "metadata");
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -3840,7 +3840,7 @@ namespace Azure { namespace Storage { namespace Blobs {
{
unused(options);
auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url);
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -3908,7 +3908,7 @@ namespace Azure { namespace Storage { namespace Blobs {
{
unused(options);
auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url);
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -3978,7 +3978,7 @@ namespace Azure { namespace Storage { namespace Blobs {
{
unused(options);
auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url);
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -4039,7 +4039,7 @@ namespace Azure { namespace Storage { namespace Blobs {
auto request = Azure::Core::Http::Request(
Azure::Core::Http::HttpMethod::Put, url, &xml_body_stream);
request.AddHeader("Content-Length", std::to_string(xml_body_stream.Length()));
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -4098,7 +4098,7 @@ namespace Azure { namespace Storage { namespace Blobs {
unused(options);
auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
request.AddHeader("Content-Length", "0");
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -4154,7 +4154,7 @@ namespace Azure { namespace Storage { namespace Blobs {
unused(options);
auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
request.AddHeader("Content-Length", "0");
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -4207,7 +4207,7 @@ namespace Azure { namespace Storage { namespace Blobs {
unused(options);
auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
request.AddHeader("Content-Length", "0");
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -4260,7 +4260,7 @@ namespace Azure { namespace Storage { namespace Blobs {
unused(options);
auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
request.AddHeader("Content-Length", "0");
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -4311,7 +4311,7 @@ namespace Azure { namespace Storage { namespace Blobs {
unused(options);
auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
request.AddHeader("Content-Length", "0");
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -5293,7 +5293,7 @@ namespace Azure { namespace Storage { namespace Blobs {
{
unused(options);
auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url, true);
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -5565,7 +5565,7 @@ namespace Azure { namespace Storage { namespace Blobs {
{
unused(options);
auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Delete, url);
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -5649,7 +5649,7 @@ namespace Azure { namespace Storage { namespace Blobs {
unused(options);
auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
request.AddHeader("Content-Length", "0");
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -5690,7 +5690,7 @@ namespace Azure { namespace Storage { namespace Blobs {
unused(options);
auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
request.AddHeader("Content-Length", "0");
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -5733,7 +5733,7 @@ namespace Azure { namespace Storage { namespace Blobs {
{
unused(options);
auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Head, url);
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -6027,7 +6027,7 @@ namespace Azure { namespace Storage { namespace Blobs {
auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
request.AddHeader("Content-Length", "0");
request.GetUrl().AppendQueryParameter("comp", "properties");
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -6130,7 +6130,7 @@ namespace Azure { namespace Storage { namespace Blobs {
auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
request.AddHeader("Content-Length", "0");
request.GetUrl().AppendQueryParameter("comp", "metadata");
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -6220,7 +6220,7 @@ namespace Azure { namespace Storage { namespace Blobs {
auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
request.AddHeader("Content-Length", "0");
request.GetUrl().AppendQueryParameter("comp", "tier");
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -6300,7 +6300,7 @@ namespace Azure { namespace Storage { namespace Blobs {
unused(options);
auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
request.AddHeader("Content-Length", "0");
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -6422,7 +6422,7 @@ namespace Azure { namespace Storage { namespace Blobs {
unused(options);
auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
request.AddHeader("Content-Length", "0");
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -6476,7 +6476,7 @@ namespace Azure { namespace Storage { namespace Blobs {
auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
request.AddHeader("Content-Length", "0");
request.GetUrl().AppendQueryParameter("comp", "snapshot");
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -6588,7 +6588,7 @@ namespace Azure { namespace Storage { namespace Blobs {
{
unused(options);
auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url);
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -6645,7 +6645,7 @@ namespace Azure { namespace Storage { namespace Blobs {
auto request = Azure::Core::Http::Request(
Azure::Core::Http::HttpMethod::Put, url, &xml_body_stream);
request.AddHeader("Content-Length", std::to_string(xml_body_stream.Length()));
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -6692,7 +6692,7 @@ namespace Azure { namespace Storage { namespace Blobs {
unused(options);
auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
request.AddHeader("Content-Length", "0");
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -6762,7 +6762,7 @@ namespace Azure { namespace Storage { namespace Blobs {
unused(options);
auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
request.AddHeader("Content-Length", "0");
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -6829,7 +6829,7 @@ namespace Azure { namespace Storage { namespace Blobs {
unused(options);
auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
request.AddHeader("Content-Length", "0");
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -6896,7 +6896,7 @@ namespace Azure { namespace Storage { namespace Blobs {
unused(options);
auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
request.AddHeader("Content-Length", "0");
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -6967,7 +6967,7 @@ namespace Azure { namespace Storage { namespace Blobs {
unused(options);
auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
request.AddHeader("Content-Length", "0");
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -7184,7 +7184,7 @@ namespace Azure { namespace Storage { namespace Blobs {
auto request
= Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url, requestBody);
request.AddHeader("Content-Length", std::to_string(requestBody->Length()));
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -7359,7 +7359,7 @@ namespace Azure { namespace Storage { namespace Blobs {
request.GetUrl().AppendQueryParameter("comp", "block");
request.GetUrl().AppendQueryParameter(
"blockid", Storage::Details::UrlEncodeQueryParameter(options.BlockId));
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -7471,7 +7471,7 @@ namespace Azure { namespace Storage { namespace Blobs {
request.GetUrl().AppendQueryParameter("comp", "block");
request.GetUrl().AppendQueryParameter(
"blockid", Storage::Details::UrlEncodeQueryParameter(options.BlockId));
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -7627,7 +7627,7 @@ namespace Azure { namespace Storage { namespace Blobs {
Azure::Core::Http::HttpMethod::Put, url, &xml_body_stream);
request.AddHeader("Content-Length", std::to_string(xml_body_stream.Length()));
request.GetUrl().AppendQueryParameter("comp", "blocklist");
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -7777,7 +7777,7 @@ namespace Azure { namespace Storage { namespace Blobs {
request.GetUrl().AppendQueryParameter(
"blocklisttype", Storage::Details::UrlEncodeQueryParameter(block_list_type_option));
}
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -7997,7 +7997,7 @@ namespace Azure { namespace Storage { namespace Blobs {
unused(options);
auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
request.AddHeader("Content-Length", "0");
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -8163,7 +8163,7 @@ namespace Azure { namespace Storage { namespace Blobs {
= Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url, requestBody);
request.AddHeader("Content-Length", std::to_string(requestBody->Length()));
request.GetUrl().AppendQueryParameter("comp", "page");
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -8324,7 +8324,7 @@ namespace Azure { namespace Storage { namespace Blobs {
auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
request.AddHeader("Content-Length", "0");
request.GetUrl().AppendQueryParameter("comp", "page");
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -8488,7 +8488,7 @@ namespace Azure { namespace Storage { namespace Blobs {
auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
request.AddHeader("Content-Length", "0");
request.GetUrl().AppendQueryParameter("comp", "page");
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -8624,7 +8624,7 @@ namespace Azure { namespace Storage { namespace Blobs {
auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
request.AddHeader("Content-Length", "0");
request.GetUrl().AppendQueryParameter("comp", "properties");
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -8738,7 +8738,7 @@ namespace Azure { namespace Storage { namespace Blobs {
"prevsnapshot",
Storage::Details::UrlEncodeQueryParameter(options.PreviousSnapshot.GetValue()));
}
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -8832,7 +8832,7 @@ namespace Azure { namespace Storage { namespace Blobs {
auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
request.AddHeader("Content-Length", "0");
request.GetUrl().AppendQueryParameter("comp", "incrementalcopy");
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -9087,7 +9087,7 @@ namespace Azure { namespace Storage { namespace Blobs {
unused(options);
auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
request.AddHeader("Content-Length", "0");
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -9241,7 +9241,7 @@ namespace Azure { namespace Storage { namespace Blobs {
= Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url, requestBody);
request.AddHeader("Content-Length", std::to_string(requestBody->Length()));
request.GetUrl().AppendQueryParameter("comp", "appendblock");
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -9389,7 +9389,7 @@ namespace Azure { namespace Storage { namespace Blobs {
auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
request.AddHeader("Content-Length", "0");
request.GetUrl().AppendQueryParameter("comp", "appendblock");
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -9546,7 +9546,7 @@ namespace Azure { namespace Storage { namespace Blobs {
auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
request.AddHeader("Content-Length", "0");
request.GetUrl().AppendQueryParameter("comp", "seal");
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -9620,7 +9620,7 @@ namespace Azure { namespace Storage { namespace Blobs {
= Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Post, url, requestBody);
request.AddHeader("Content-Length", std::to_string(requestBody->Length()));
request.GetUrl().AppendQueryParameter("comp", "batch");
request.AddHeader("x-ms-version", c_ApiVersion);
request.AddHeader("x-ms-version", "2020-02-10");
if (options.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(

8
sdk/storage/azure-storage-blobs/src/append_blob_client.cpp
View File

@ -47,12 +47,12 @@ namespace Azure { namespace Storage { namespace Blobs {
AppendBlobClient newClient(*this);
if (snapshot.empty())
{
newClient.m_blobUrl.RemoveQueryParameter(Storage::Details::c_HttpQuerySnapshot);
newClient.m_blobUrl.RemoveQueryParameter(Storage::Details::HttpQuerySnapshot);
}
else
{
newClient.m_blobUrl.AppendQueryParameter(
Storage::Details::c_HttpQuerySnapshot,
Storage::Details::HttpQuerySnapshot,
Storage::Details::UrlEncodeQueryParameter(snapshot));
}
return newClient;
@ -63,12 +63,12 @@ namespace Azure { namespace Storage { namespace Blobs {
AppendBlobClient newClient(*this);
if (versionId.empty())
{
newClient.m_blobUrl.RemoveQueryParameter(Storage::Details::c_HttpQueryVersionId);
newClient.m_blobUrl.RemoveQueryParameter(Storage::Details::HttpQueryVersionId);
}
else
{
newClient.m_blobUrl.AppendQueryParameter(
Storage::Details::c_HttpQueryVersionId,
Storage::Details::HttpQueryVersionId,
Storage::Details::UrlEncodeQueryParameter(versionId));
}
return newClient;

46
sdk/storage/azure-storage-blobs/src/blob_batch_client.cpp
View File

@ -91,7 +91,7 @@ namespace Azure { namespace Storage { namespace Blobs {
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::c_BlobServicePackageName, Version::VersionString()));
Storage::Details::BlobServicePackageName, Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
@ -132,7 +132,7 @@ namespace Azure { namespace Storage { namespace Blobs {
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::c_BlobServicePackageName, Version::VersionString()));
Storage::Details::BlobServicePackageName, Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
@ -146,7 +146,7 @@ namespace Azure { namespace Storage { namespace Blobs {
}
policies.emplace_back(std::make_unique<StoragePerRetryPolicy>());
policies.emplace_back(std::make_unique<Core::BearerTokenAuthenticationPolicy>(
credential, Storage::Details::c_StorageScope));
credential, Storage::Details::StorageScope));
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Http::HttpPipeline>(policies);
@ -162,7 +162,7 @@ namespace Azure { namespace Storage { namespace Blobs {
}
policies.emplace_back(std::make_unique<StoragePerRetryPolicy>());
policies.emplace_back(std::make_unique<Core::BearerTokenAuthenticationPolicy>(
credential, Storage::Details::c_StorageScope));
credential, Storage::Details::StorageScope));
policies.emplace_back(std::make_unique<NoopTransportPolicy>());
m_subRequestPipeline = std::make_shared<Azure::Core::Http::HttpPipeline>(policies);
}
@ -172,7 +172,7 @@ namespace Azure { namespace Storage { namespace Blobs {
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::c_BlobServicePackageName, Version::VersionString()));
Storage::Details::BlobServicePackageName, Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
@ -207,8 +207,8 @@ namespace Azure { namespace Storage { namespace Blobs {
const BlobBatch& batch,
const SubmitBlobBatchOptions& options) const
{
const std::string c_lineEnding = "\r\n";
const std::string c_contentTypePrefix = "multipart/mixed; boundary=";
const std::string LineEnding = "\r\n";
const std::string ContentTypePrefix = "multipart/mixed; boundary=";
std::string boundary = "batch_" + Azure::Core::Uuid::CreateUuid().GetUuidString();
@ -222,12 +222,12 @@ namespace Azure { namespace Storage { namespace Blobs {
std::string requestBody;
{
auto getBatchBoundary = [&c_lineEnding, &boundary, subRequestCounter = 0]() mutable {
auto getBatchBoundary = [&LineEnding, &boundary, subRequestCounter = 0]() mutable {
std::string ret;
ret += "--" + boundary + c_lineEnding;
ret += "Content-Type: application/http" + c_lineEnding + "Content-Transfer-Encoding: binary"
+ c_lineEnding + "Content-ID: " + std::to_string(subRequestCounter++) + c_lineEnding
+ c_lineEnding;
ret += "--" + boundary + LineEnding;
ret += "Content-Type: application/http" + LineEnding + "Content-Transfer-Encoding: binary"
+ LineEnding + "Content-ID: " + std::to_string(subRequestCounter++) + LineEnding
+ LineEnding;
return ret;
};
for (const auto& subrequest : batch.m_deleteBlobSubRequests)
@ -249,7 +249,7 @@ namespace Azure { namespace Storage { namespace Blobs {
protocolLayerOptions.LeaseId = subrequest.Options.AccessConditions.LeaseId;
auto message
= Details::BlobRestClient::Blob::DeleteCreateMessage(blobUrl, protocolLayerOptions);
message.RemoveHeader(Storage::Details::c_HttpHeaderXMsVersion);
message.RemoveHeader(Storage::Details::HttpHeaderXMsVersion);
m_subRequestPipeline->Send(options.Context, message);
requestBody += message.GetHTTPMessagePreBody();
}
@ -267,15 +267,15 @@ namespace Azure { namespace Storage { namespace Blobs {
protocolLayerOptions.RehydratePriority = subrequest.Options.RehydratePriority;
auto message = Details::BlobRestClient::Blob::SetAccessTierCreateMessage(
blobUrl, protocolLayerOptions);
message.RemoveHeader(Storage::Details::c_HttpHeaderXMsVersion);
message.RemoveHeader(Storage::Details::HttpHeaderXMsVersion);
m_subRequestPipeline->Send(options.Context, message);
requestBody += message.GetHTTPMessagePreBody();
}
requestBody += "--" + boundary + "--" + c_lineEnding;
requestBody += "--" + boundary + "--" + LineEnding;
}
Details::BlobRestClient::BlobBatch::SubmitBlobBatchOptions protocolLayerOptions;
protocolLayerOptions.ContentType = c_contentTypePrefix + boundary;
protocolLayerOptions.ContentType = ContentTypePrefix + boundary;
Azure::Core::Http::MemoryBodyStream requestBodyStream(
reinterpret_cast<const uint8_t*>(requestBody.data()), requestBody.length());
@ -283,9 +283,9 @@ namespace Azure { namespace Storage { namespace Blobs {
auto rawResponse = Details::BlobRestClient::BlobBatch::SubmitBatch(
options.Context, *m_pipeline, m_serviceUrl, &requestBodyStream, protocolLayerOptions);
if (rawResponse->ContentType.substr(0, c_contentTypePrefix.length()) == c_contentTypePrefix)
if (rawResponse->ContentType.substr(0, ContentTypePrefix.length()) == ContentTypePrefix)
{
boundary = rawResponse->ContentType.substr(c_contentTypePrefix.length());
boundary = rawResponse->ContentType.substr(ContentTypePrefix.length());
}
else
{
@ -360,7 +360,7 @@ namespace Azure { namespace Storage { namespace Blobs {
break;
}
currPos = parseFindNextAfter(c_lineEnding + c_lineEnding);
currPos = parseFindNextAfter(LineEnding + LineEnding);
auto boundaryPos = parseFindNext("--" + boundary);
// now (currPos, boundaryPos) is a subresponse body
@ -368,7 +368,7 @@ namespace Azure { namespace Storage { namespace Blobs {
int32_t httpMajorVersion = std::stoi(parseGetUntilAfter("."));
int32_t httpMinorVersion = std::stoi(parseGetUntilAfter(" "));
int32_t httpStatusCode = std::stoi(parseGetUntilAfter(" "));
std::string httpReasonPhrase = parseGetUntilAfter(c_lineEnding);
std::string httpReasonPhrase = parseGetUntilAfter(LineEnding);
auto rawSubresponse = std::make_unique<Azure::Core::Http::RawResponse>(
httpMajorVersion,
@ -378,17 +378,17 @@ namespace Azure { namespace Storage { namespace Blobs {
while (currPos < boundaryPos)
{
if (parseLookAhead(c_lineEnding))
if (parseLookAhead(LineEnding))
{
break;
}
std::string headerName = parseGetUntilAfter(": ");
std::string headerValue = parseGetUntilAfter(c_lineEnding);
std::string headerValue = parseGetUntilAfter(LineEnding);
rawSubresponse->AddHeader(headerName, headerValue);
}
parseConsume(c_lineEnding);
parseConsume(LineEnding);
rawSubresponse->SetBody(std::vector<uint8_t>(currPos, boundaryPos));
currPos = boundaryPos;

38
sdk/storage/azure-storage-blobs/src/blob_client.cpp
View File

@ -48,7 +48,7 @@ namespace Azure { namespace Storage { namespace Blobs {
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::c_BlobServicePackageName, Version::VersionString()));
Storage::Details::BlobServicePackageName, Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
@ -74,7 +74,7 @@ namespace Azure { namespace Storage { namespace Blobs {
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::c_BlobServicePackageName, Version::VersionString()));
Storage::Details::BlobServicePackageName, Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
@ -87,7 +87,7 @@ namespace Azure { namespace Storage { namespace Blobs {
}
policies.emplace_back(std::make_unique<StoragePerRetryPolicy>());
policies.emplace_back(std::make_unique<Core::BearerTokenAuthenticationPolicy>(
credential, Storage::Details::c_StorageScope));
credential, Storage::Details::StorageScope));
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Http::HttpPipeline>(policies);
@ -99,7 +99,7 @@ namespace Azure { namespace Storage { namespace Blobs {
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::c_BlobServicePackageName, Version::VersionString()));
Storage::Details::BlobServicePackageName, Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
@ -127,12 +127,12 @@ namespace Azure { namespace Storage { namespace Blobs {
BlobClient newClient(*this);
if (snapshot.empty())
{
newClient.m_blobUrl.RemoveQueryParameter(Storage::Details::c_HttpQuerySnapshot);
newClient.m_blobUrl.RemoveQueryParameter(Storage::Details::HttpQuerySnapshot);
}
else
{
newClient.m_blobUrl.AppendQueryParameter(
Storage::Details::c_HttpQuerySnapshot,
Storage::Details::HttpQuerySnapshot,
Storage::Details::UrlEncodeQueryParameter(snapshot));
}
return newClient;
@ -143,12 +143,12 @@ namespace Azure { namespace Storage { namespace Blobs {
BlobClient newClient(*this);
if (versionId.empty())
{
newClient.m_blobUrl.RemoveQueryParameter(Storage::Details::c_HttpQueryVersionId);
newClient.m_blobUrl.RemoveQueryParameter(Storage::Details::HttpQueryVersionId);
}
else
{
newClient.m_blobUrl.AppendQueryParameter(
Storage::Details::c_HttpQueryVersionId,
Storage::Details::HttpQueryVersionId,
Storage::Details::UrlEncodeQueryParameter(versionId));
}
return newClient;
@ -211,7 +211,7 @@ namespace Azure { namespace Storage { namespace Blobs {
};
ReliableStreamOptions reliableStreamOptions;
reliableStreamOptions.MaxRetryRequests = Storage::Details::c_reliableStreamRetryCount;
reliableStreamOptions.MaxRetryRequests = Storage::Details::ReliableStreamRetryCount;
downloadResponse->BodyStream = std::make_unique<ReliableStream>(
std::move(downloadResponse->BodyStream), reliableStreamOptions, retryFunction);
}
@ -223,13 +223,13 @@ namespace Azure { namespace Storage { namespace Blobs {
std::size_t bufferSize,
const DownloadBlobToOptions& options) const
{
constexpr int64_t c_defaultChunkSize = 4 * 1024 * 1024;
constexpr int64_t DefaultChunkSize = 4 * 1024 * 1024;
// Just start downloading using an initial chunk. If it's a small blob, we'll get the whole
// thing in one shot. If it's a large blob, we'll get its full size in Content-Range and can
// keep downloading it in chunks.
int64_t firstChunkOffset = options.Offset.HasValue() ? options.Offset.GetValue() : 0;
int64_t firstChunkLength = c_defaultChunkSize;
int64_t firstChunkLength = DefaultChunkSize;
if (options.InitialChunkSize.HasValue())
{
firstChunkLength = options.InitialChunkSize.GetValue();
@ -334,10 +334,10 @@ namespace Azure { namespace Storage { namespace Blobs {
}
else
{
int64_t c_grainSize = 4 * 1024;
int64_t GrainSize = 4 * 1024;
chunkSize = remainingSize / options.Concurrency;
chunkSize = (std::max(chunkSize, int64_t(1)) + c_grainSize - 1) / c_grainSize * c_grainSize;
chunkSize = std::min(chunkSize, c_defaultChunkSize);
chunkSize = (std::max(chunkSize, int64_t(1)) + GrainSize - 1) / GrainSize * GrainSize;
chunkSize = std::min(chunkSize, DefaultChunkSize);
}
Storage::Details::ConcurrentTransfer(
@ -350,13 +350,13 @@ namespace Azure { namespace Storage { namespace Blobs {
const std::string& fileName,
const DownloadBlobToOptions& options) const
{
constexpr int64_t c_defaultChunkSize = 4 * 1024 * 1024;
constexpr int64_t DefaultChunkSize = 4 * 1024 * 1024;
// Just start downloading using an initial chunk. If it's a small blob, we'll get the whole
// thing in one shot. If it's a large blob, we'll get its full size in Content-Range and can
// keep downloading it in chunks.
int64_t firstChunkOffset = options.Offset.HasValue() ? options.Offset.GetValue() : 0;
int64_t firstChunkLength = c_defaultChunkSize;
int64_t firstChunkLength = DefaultChunkSize;
if (options.InitialChunkSize.HasValue())
{
firstChunkLength = options.InitialChunkSize.GetValue();
@ -472,10 +472,10 @@ namespace Azure { namespace Storage { namespace Blobs {
}
else
{
int64_t c_grainSize = 4 * 1024;
int64_t GrainSize = 4 * 1024;
chunkSize = remainingSize / options.Concurrency;
chunkSize = (std::max(chunkSize, int64_t(1)) + c_grainSize - 1) / c_grainSize * c_grainSize;
chunkSize = std::min(chunkSize, c_defaultChunkSize);
chunkSize = (std::max(chunkSize, int64_t(1)) + GrainSize - 1) / GrainSize * GrainSize;
chunkSize = std::min(chunkSize, DefaultChunkSize);
}
Storage::Details::ConcurrentTransfer(

8
sdk/storage/azure-storage-blobs/src/blob_container_client.cpp
View File

@ -44,7 +44,7 @@ namespace Azure { namespace Storage { namespace Blobs {
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::c_BlobServicePackageName, Version::VersionString()));
Storage::Details::BlobServicePackageName, Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
@ -70,7 +70,7 @@ namespace Azure { namespace Storage { namespace Blobs {
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::c_BlobServicePackageName, Version::VersionString()));
Storage::Details::BlobServicePackageName, Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
@ -83,7 +83,7 @@ namespace Azure { namespace Storage { namespace Blobs {
}
policies.emplace_back(std::make_unique<StoragePerRetryPolicy>());
policies.emplace_back(std::make_unique<Core::BearerTokenAuthenticationPolicy>(
credential, Storage::Details::c_StorageScope));
credential, Storage::Details::StorageScope));
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Http::HttpPipeline>(policies);
@ -97,7 +97,7 @@ namespace Azure { namespace Storage { namespace Blobs {
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::c_BlobServicePackageName, Version::VersionString()));
Storage::Details::BlobServicePackageName, Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{

8
sdk/storage/azure-storage-blobs/src/blob_sas_builder.cpp
View File

@ -131,7 +131,7 @@ namespace Azure { namespace Storage { namespace Blobs {
std::string stringToSign = Permissions + "\n" + (StartsOn.HasValue() ? StartsOn.GetValue() : "")
+ "\n" + ExpiresOn + "\n" + canonicalName + "\n" + Identifier + "\n"
+ (IPRange.HasValue() ? IPRange.GetValue() : "") + "\n" + protocol + "\n"
+ Storage::Details::c_defaultSasVersion + "\n" + resource + "\n" + snapshotVersion + "\n"
+ Storage::Details::DefaultSasVersion + "\n" + resource + "\n" + snapshotVersion + "\n"
+ CacheControl + "\n" + ContentDisposition + "\n" + ContentEncoding + "\n" + ContentLanguage
+ "\n" + ContentType;
@ -140,7 +140,7 @@ namespace Azure { namespace Storage { namespace Blobs {
Azure::Core::Http::Url builder;
builder.AppendQueryParameter(
"sv", Storage::Details::UrlEncodeQueryParameter(Storage::Details::c_defaultSasVersion));
"sv", Storage::Details::UrlEncodeQueryParameter(Storage::Details::DefaultSasVersion));
builder.AppendQueryParameter("spr", Storage::Details::UrlEncodeQueryParameter(protocol));
if (StartsOn.HasValue())
{
@ -222,7 +222,7 @@ namespace Azure { namespace Storage { namespace Blobs {
+ userDelegationKey.SignedExpiresOn + "\n" + userDelegationKey.SignedService + "\n"
+ userDelegationKey.SignedVersion + "\n\n\n\n"
+ (IPRange.HasValue() ? IPRange.GetValue() : "") + "\n" + protocol + "\n"
+ Storage::Details::c_defaultSasVersion + "\n" + resource + "\n" + snapshotVersion + "\n"
+ Storage::Details::DefaultSasVersion + "\n" + resource + "\n" + snapshotVersion + "\n"
+ CacheControl + "\n" + ContentDisposition + "\n" + ContentEncoding + "\n" + ContentLanguage
+ "\n" + ContentType;
@ -231,7 +231,7 @@ namespace Azure { namespace Storage { namespace Blobs {
Azure::Core::Http::Url builder;
builder.AppendQueryParameter(
"sv", Storage::Details::UrlEncodeQueryParameter(Storage::Details::c_defaultSasVersion));
"sv", Storage::Details::UrlEncodeQueryParameter(Storage::Details::DefaultSasVersion));
builder.AppendQueryParameter("sr", Storage::Details::UrlEncodeQueryParameter(resource));
if (StartsOn.HasValue())
{

8
sdk/storage/azure-storage-blobs/src/blob_service_client.cpp
View File

@ -39,7 +39,7 @@ namespace Azure { namespace Storage { namespace Blobs {
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::c_BlobServicePackageName, Version::VersionString()));
Storage::Details::BlobServicePackageName, Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
@ -65,7 +65,7 @@ namespace Azure { namespace Storage { namespace Blobs {
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::c_BlobServicePackageName, Version::VersionString()));
Storage::Details::BlobServicePackageName, Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
@ -78,7 +78,7 @@ namespace Azure { namespace Storage { namespace Blobs {
}
policies.emplace_back(std::make_unique<StoragePerRetryPolicy>());
policies.emplace_back(std::make_unique<Core::BearerTokenAuthenticationPolicy>(
credential, Storage::Details::c_StorageScope));
credential, Storage::Details::StorageScope));
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Http::HttpPipeline>(policies);
@ -91,7 +91,7 @@ namespace Azure { namespace Storage { namespace Blobs {
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Storage::Details::c_BlobServicePackageName, Version::VersionString()));
Storage::Details::BlobServicePackageName, Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{

40
sdk/storage/azure-storage-blobs/src/block_blob_client.cpp
View File

@ -50,12 +50,12 @@ namespace Azure { namespace Storage { namespace Blobs {
BlockBlobClient newClient(*this);
if (snapshot.empty())
{
newClient.m_blobUrl.RemoveQueryParameter(Storage::Details::c_HttpQuerySnapshot);
newClient.m_blobUrl.RemoveQueryParameter(Storage::Details::HttpQuerySnapshot);
}
else
{
newClient.m_blobUrl.AppendQueryParameter(
Storage::Details::c_HttpQuerySnapshot,
Storage::Details::HttpQuerySnapshot,
Storage::Details::UrlEncodeQueryParameter(snapshot));
}
return newClient;
@ -66,12 +66,12 @@ namespace Azure { namespace Storage { namespace Blobs {
BlockBlobClient newClient(*this);
if (versionId.empty())
{
newClient.m_blobUrl.RemoveQueryParameter(Storage::Details::c_HttpQueryVersionId);
newClient.m_blobUrl.RemoveQueryParameter(Storage::Details::HttpQueryVersionId);
}
else
{
newClient.m_blobUrl.AppendQueryParameter(
Storage::Details::c_HttpQueryVersionId,
Storage::Details::HttpQueryVersionId,
Storage::Details::UrlEncodeQueryParameter(versionId));
}
return newClient;
@ -109,20 +109,20 @@ namespace Azure { namespace Storage { namespace Blobs {
std::size_t bufferSize,
const UploadBlockBlobFromOptions& options) const
{
constexpr int64_t c_defaultBlockSize = 8 * 1024 * 1024;
constexpr int64_t c_maximumNumberBlocks = 50000;
constexpr int64_t c_grainSize = 4 * 1024;
constexpr int64_t DefaultBlockSize = 8 * 1024 * 1024;
constexpr int64_t MaximumNumberBlocks = 50000;
constexpr int64_t GrainSize = 4 * 1024;
int64_t chunkSize = c_defaultBlockSize;
int64_t chunkSize = DefaultBlockSize;
if (options.ChunkSize.HasValue())
{
chunkSize = options.ChunkSize.GetValue();
}
else
{
int64_t minBlockSize = (bufferSize + c_maximumNumberBlocks - 1) / c_maximumNumberBlocks;
int64_t minBlockSize = (bufferSize + MaximumNumberBlocks - 1) / MaximumNumberBlocks;
chunkSize = std::max(chunkSize, minBlockSize);
chunkSize = (chunkSize + c_grainSize - 1) / c_grainSize * c_grainSize;
chunkSize = (chunkSize + GrainSize - 1) / GrainSize * GrainSize;
}
if (bufferSize <= static_cast<std::size_t>(chunkSize))
@ -138,9 +138,9 @@ namespace Azure { namespace Storage { namespace Blobs {
std::vector<std::pair<Models::BlockType, std::string>> blockIds;
auto getBlockId = [](int64_t id) {
constexpr std::size_t c_blockIdLength = 64;
constexpr std::size_t BlockIdLength = 64;
std::string blockId = std::to_string(id);
blockId = std::string(c_blockIdLength - blockId.length(), '0') + blockId;
blockId = std::string(BlockIdLength - blockId.length(), '0') + blockId;
return Base64Encode(blockId);
};
@ -187,13 +187,13 @@ namespace Azure { namespace Storage { namespace Blobs {
const std::string& fileName,
const UploadBlockBlobFromOptions& options) const
{
constexpr int64_t c_defaultBlockSize = 8 * 1024 * 1024;
constexpr int64_t c_maximumNumberBlocks = 50000;
constexpr int64_t c_grainSize = 4 * 1024;
constexpr int64_t DefaultBlockSize = 8 * 1024 * 1024;
constexpr int64_t MaximumNumberBlocks = 50000;
constexpr int64_t GrainSize = 4 * 1024;
Storage::Details::FileReader fileReader(fileName);
int64_t chunkSize = c_defaultBlockSize;
int64_t chunkSize = DefaultBlockSize;
if (options.ChunkSize.HasValue())
{
chunkSize = options.ChunkSize.GetValue();
@ -201,9 +201,9 @@ namespace Azure { namespace Storage { namespace Blobs {
else
{
int64_t minBlockSize
= (fileReader.GetFileSize() + c_maximumNumberBlocks - 1) / c_maximumNumberBlocks;
= (fileReader.GetFileSize() + MaximumNumberBlocks - 1) / MaximumNumberBlocks;
chunkSize = std::max(chunkSize, minBlockSize);
chunkSize = (chunkSize + c_grainSize - 1) / c_grainSize * c_grainSize;
chunkSize = (chunkSize + GrainSize - 1) / GrainSize * GrainSize;
}
if (fileReader.GetFileSize() <= chunkSize)
@ -220,9 +220,9 @@ namespace Azure { namespace Storage { namespace Blobs {
std::vector<std::pair<Models::BlockType, std::string>> blockIds;
auto getBlockId = [](int64_t id) {
constexpr std::size_t c_blockIdLength = 64;
constexpr std::size_t BlockIdLength = 64;
std::string blockId = std::to_string(id);
blockId = std::string(c_blockIdLength - blockId.length(), '0') + blockId;
blockId = std::string(BlockIdLength - blockId.length(), '0') + blockId;
return Base64Encode(blockId);
};

8
sdk/storage/azure-storage-blobs/src/page_blob_client.cpp
View File

@ -49,12 +49,12 @@ namespace Azure { namespace Storage { namespace Blobs {
PageBlobClient newClient(*this);
if (snapshot.empty())
{
newClient.m_blobUrl.RemoveQueryParameter(Storage::Details::c_HttpQuerySnapshot);
newClient.m_blobUrl.RemoveQueryParameter(Storage::Details::HttpQuerySnapshot);
}
else
{
newClient.m_blobUrl.AppendQueryParameter(
Storage::Details::c_HttpQuerySnapshot,
Storage::Details::HttpQuerySnapshot,
Storage::Details::UrlEncodeQueryParameter(snapshot));
}
return newClient;
@ -65,12 +65,12 @@ namespace Azure { namespace Storage { namespace Blobs {
PageBlobClient newClient(*this);
if (versionId.empty())
{
newClient.m_blobUrl.RemoveQueryParameter(Storage::Details::c_HttpQueryVersionId);
newClient.m_blobUrl.RemoveQueryParameter(Storage::Details::HttpQueryVersionId);
}
else
{
newClient.m_blobUrl.AppendQueryParameter(
Storage::Details::c_HttpQueryVersionId,
Storage::Details::HttpQueryVersionId,
Storage::Details::UrlEncodeQueryParameter(versionId));
}
return newClient;

10
sdk/storage/azure-storage-blobs/test/append_blob_client_test.cpp
View File

@ -153,9 +153,9 @@ namespace Azure { namespace Storage { namespace Test {
EXPECT_THROW(appendBlobClient.Create(createOptions), StorageException);
std::string eTag = appendBlobClient.GetProperties()->ETag;
for (std::string match : {eTag, std::string(c_dummyETag), std::string()})
for (std::string match : {eTag, std::string(DummyETag), std::string()})
{
for (std::string noneMatch : {eTag, std::string(c_dummyETag), std::string()})
for (std::string noneMatch : {eTag, std::string(DummyETag), std::string()})
{
Blobs::GetBlobPropertiesOptions options;
if (!match.empty())
@ -199,7 +199,7 @@ namespace Azure { namespace Storage { namespace Test {
StandardStorageConnectionString(), m_containerName, RandomString());
sourceBlobClient.Create();
auto leaseResponse
= sourceBlobClient.AcquireLease(CreateUniqueLeaseId(), c_InfiniteLeaseDuration);
= sourceBlobClient.AcquireLease(CreateUniqueLeaseId(), InfiniteLeaseDuration);
std::string leaseId = leaseResponse->LeaseId;
std::string eTag = leaseResponse->ETag;
auto lastModifiedTime = FromRfc1123(leaseResponse->LastModified);
@ -225,13 +225,13 @@ namespace Azure { namespace Storage { namespace Test {
Blobs::StartCopyBlobFromUriOptions options;
options.SourceConditions.IfMatch = eTag;
EXPECT_NO_THROW(destBlobClient.StartCopyFromUri(sourceBlobClient.GetUrl(), options));
options.SourceConditions.IfMatch = c_dummyETag;
options.SourceConditions.IfMatch = DummyETag;
EXPECT_THROW(
destBlobClient.StartCopyFromUri(sourceBlobClient.GetUrl(), options), StorageException);
}
{
Blobs::StartCopyBlobFromUriOptions options;
options.SourceConditions.IfNoneMatch = c_dummyETag;
options.SourceConditions.IfNoneMatch = DummyETag;
EXPECT_NO_THROW(destBlobClient.StartCopyFromUri(sourceBlobClient.GetUrl(), options));
options.SourceConditions.IfNoneMatch = eTag;
EXPECT_THROW(

48
sdk/storage/azure-storage-blobs/test/blob_container_client_test.cpp
View File

@ -59,17 +59,17 @@ namespace Azure { namespace Storage { namespace Test {
metadata["key2"] = "TWO";
options.Metadata = metadata;
auto res = container_client.Create(options);
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderRequestId).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderDate).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderXMsVersion).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderRequestId).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderDate).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderXMsVersion).empty());
EXPECT_FALSE(res->ETag.empty());
EXPECT_FALSE(res->LastModified.empty());
EXPECT_THROW(container_client.Create(), StorageException);
auto res2 = container_client.Delete();
EXPECT_FALSE(res2.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderRequestId).empty());
EXPECT_FALSE(res2.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderDate).empty());
EXPECT_FALSE(res2.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderXMsVersion).empty());
EXPECT_FALSE(res2.GetRawResponse().GetHeaders().at(Details::HttpHeaderRequestId).empty());
EXPECT_FALSE(res2.GetRawResponse().GetHeaders().at(Details::HttpHeaderDate).empty());
EXPECT_FALSE(res2.GetRawResponse().GetHeaders().at(Details::HttpHeaderXMsVersion).empty());
}
TEST_F(BlobContainerClientTest, Metadata)
@ -78,16 +78,16 @@ namespace Azure { namespace Storage { namespace Test {
metadata["key1"] = "one";
metadata["key2"] = "TWO";
auto res = m_blobContainerClient->SetMetadata(metadata);
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderRequestId).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderDate).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderXMsVersion).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderRequestId).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderDate).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderXMsVersion).empty());
EXPECT_FALSE(res->ETag.empty());
EXPECT_FALSE(res->LastModified.empty());
auto res2 = m_blobContainerClient->GetProperties();
EXPECT_FALSE(res2.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderRequestId).empty());
EXPECT_FALSE(res2.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderDate).empty());
EXPECT_FALSE(res2.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderXMsVersion).empty());
EXPECT_FALSE(res2.GetRawResponse().GetHeaders().at(Details::HttpHeaderRequestId).empty());
EXPECT_FALSE(res2.GetRawResponse().GetHeaders().at(Details::HttpHeaderDate).empty());
EXPECT_FALSE(res2.GetRawResponse().GetHeaders().at(Details::HttpHeaderXMsVersion).empty());
auto properties = *res2;
EXPECT_FALSE(properties.ETag.empty());
EXPECT_FALSE(properties.LastModified.empty());
@ -141,9 +141,9 @@ namespace Azure { namespace Storage { namespace Test {
do
{
auto res = m_blobContainerClient->ListBlobsFlatSegment(options);
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderRequestId).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderDate).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderXMsVersion).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderRequestId).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderDate).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderXMsVersion).empty());
EXPECT_FALSE(res->ServiceEndpoint.empty());
EXPECT_EQ(res->Container, m_containerName);
@ -412,7 +412,7 @@ namespace Azure { namespace Storage { namespace Test {
EXPECT_FALSE(containerInfo.ETag.empty());
EXPECT_FALSE(containerInfo.LastModified.empty());
aLease = *m_blobContainerClient->AcquireLease(CreateUniqueLeaseId(), c_InfiniteLeaseDuration);
aLease = *m_blobContainerClient->AcquireLease(CreateUniqueLeaseId(), InfiniteLeaseDuration);
properties = *m_blobContainerClient->GetProperties();
EXPECT_FALSE(properties.LeaseDuration.GetValue().empty());
auto brokenLease = *m_blobContainerClient->BreakLease();
@ -435,18 +435,18 @@ namespace Azure { namespace Storage { namespace Test {
{
{
auto properties = *m_blobContainerClient->GetProperties();
EXPECT_EQ(properties.DefaultEncryptionScope, c_AccountEncryptionKey);
EXPECT_EQ(properties.DefaultEncryptionScope, AccountEncryptionKey);
EXPECT_EQ(properties.PreventEncryptionScopeOverride, false);
}
{
std::string containerName = LowercaseRandomString();
std::string blobName = RandomString();
Blobs::BlobClientOptions options;
options.EncryptionScope = c_TestEncryptionScope;
options.EncryptionScope = TestEncryptionScope;
auto containerClient = Azure::Storage::Blobs::BlobContainerClient::CreateFromConnectionString(
StandardStorageConnectionString(), containerName, options);
Blobs::CreateContainerOptions createOptions;
createOptions.DefaultEncryptionScope = c_TestEncryptionScope;
createOptions.DefaultEncryptionScope = TestEncryptionScope;
createOptions.PreventEncryptionScopeOverride = true;
EXPECT_NO_THROW(containerClient.Create(createOptions));
auto properties = *containerClient.GetProperties();
@ -458,28 +458,28 @@ namespace Azure { namespace Storage { namespace Test {
auto blobContentInfo = appendBlobClient.Create();
appendBlobClient.Delete();
EXPECT_TRUE(blobContentInfo->EncryptionScope.HasValue());
EXPECT_EQ(blobContentInfo->EncryptionScope.GetValue(), c_TestEncryptionScope);
EXPECT_EQ(blobContentInfo->EncryptionScope.GetValue(), TestEncryptionScope);
auto appendBlobClientWithoutEncryptionScope
= Azure::Storage::Blobs::AppendBlobClient::CreateFromConnectionString(
StandardStorageConnectionString(), containerName, blobName);
blobContentInfo = appendBlobClientWithoutEncryptionScope.Create();
appendBlobClientWithoutEncryptionScope.Delete();
EXPECT_TRUE(blobContentInfo->EncryptionScope.HasValue());
EXPECT_EQ(blobContentInfo->EncryptionScope.GetValue(), c_TestEncryptionScope);
EXPECT_EQ(blobContentInfo->EncryptionScope.GetValue(), TestEncryptionScope);
containerClient.Delete();
}
{
std::string blobName = RandomString();
Blobs::BlobClientOptions options;
options.EncryptionScope = c_TestEncryptionScope;
options.EncryptionScope = TestEncryptionScope;
auto appendBlobClient = Azure::Storage::Blobs::AppendBlobClient::CreateFromConnectionString(
StandardStorageConnectionString(), m_containerName, blobName, options);
auto blobContentInfo = appendBlobClient.Create();
EXPECT_TRUE(blobContentInfo->EncryptionScope.HasValue());
EXPECT_EQ(blobContentInfo->EncryptionScope.GetValue(), c_TestEncryptionScope);
EXPECT_EQ(blobContentInfo->EncryptionScope.GetValue(), TestEncryptionScope);
auto properties = *appendBlobClient.GetProperties();
EXPECT_TRUE(properties.EncryptionScope.HasValue());
EXPECT_EQ(properties.EncryptionScope.GetValue(), c_TestEncryptionScope);
EXPECT_EQ(properties.EncryptionScope.GetValue(), TestEncryptionScope);
std::vector<uint8_t> appendContent(1);
Azure::Core::Http::MemoryBodyStream bodyStream(appendContent.data(), appendContent.size());
EXPECT_NO_THROW(appendBlobClient.AppendBlock(&bodyStream));

16
sdk/storage/azure-storage-blobs/test/blob_service_client_test.cpp
View File

@ -111,9 +111,9 @@ namespace Azure { namespace Storage { namespace Test {
do
{
auto res = m_blobServiceClient.ListBlobContainersSegment(options);
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderRequestId).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderDate).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderXMsVersion).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderRequestId).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderDate).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderXMsVersion).empty());
EXPECT_FALSE(res->ServiceEndpoint.empty());
options.ContinuationToken = res->ContinuationToken;
@ -133,9 +133,9 @@ namespace Azure { namespace Storage { namespace Test {
do
{
auto res = m_blobServiceClient.ListBlobContainersSegment(options);
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderRequestId).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderDate).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderXMsVersion).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderRequestId).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderDate).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderXMsVersion).empty());
EXPECT_FALSE(res->ServiceEndpoint.empty());
options.ContinuationToken = res->ContinuationToken;
@ -148,7 +148,7 @@ namespace Azure { namespace Storage { namespace Test {
EXPECT_FALSE(container.VersionId.HasValue());
EXPECT_FALSE(container.DeletedTime.HasValue());
EXPECT_FALSE(container.RemainingRetentionDays.HasValue());
EXPECT_EQ(container.DefaultEncryptionScope, c_AccountEncryptionKey);
EXPECT_EQ(container.DefaultEncryptionScope, AccountEncryptionKey);
EXPECT_FALSE(container.PreventEncryptionScopeOverride);
listContainers.insert(container.Name);
}
@ -228,7 +228,7 @@ namespace Azure { namespace Storage { namespace Test {
properties.MinuteMetrics.RetentionPolicy.Days = 4;
properties.MinuteMetrics.IncludeApis = true;
properties.DefaultServiceVersion = Blobs::Details::c_ApiVersion;
properties.DefaultServiceVersion = Blobs::Details::ApiVersion;
properties.StaticWebsite.Enabled = true;
properties.StaticWebsite.IndexDocument = "index.html";

36
sdk/storage/azure-storage-blobs/test/block_blob_client_test.cpp
View File

@ -78,9 +78,9 @@ namespace Azure { namespace Storage { namespace Test {
{
auto res = m_blockBlobClient->Download();
EXPECT_EQ(ReadBodyStream(res->BodyStream), m_blobContent);
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderRequestId).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderDate).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderXMsVersion).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderRequestId).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderDate).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderXMsVersion).empty());
EXPECT_FALSE(res->ETag.empty());
EXPECT_FALSE(res->LastModified.empty());
EXPECT_FALSE(res->CreationTime.empty());
@ -148,9 +148,9 @@ namespace Azure { namespace Storage { namespace Test {
auto res = blockBlobClient.Download();
EXPECT_EQ(res->BodyStream->Length(), 0);
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderRequestId).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderDate).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderXMsVersion).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderRequestId).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderDate).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderXMsVersion).empty());
EXPECT_FALSE(res->ETag.empty());
EXPECT_FALSE(res->LastModified.empty());
EXPECT_EQ(res->HttpHeaders, m_blobUploadOptions.HttpHeaders);
@ -169,9 +169,9 @@ namespace Azure { namespace Storage { namespace Test {
auto blobClient = m_blobContainerClient->GetBlobClient(RandomString());
auto res = blobClient.StartCopyFromUri(m_blockBlobClient->GetUrl());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderRequestId).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderDate).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderXMsVersion).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderRequestId).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderDate).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderXMsVersion).empty());
EXPECT_FALSE(res->ETag.empty());
EXPECT_FALSE(res->LastModified.empty());
EXPECT_FALSE(res->CopyId.empty());
@ -196,9 +196,9 @@ namespace Azure { namespace Storage { namespace Test {
TEST_F(BlockBlobClientTest, SnapShotVersions)
{
auto res = m_blockBlobClient->CreateSnapshot();
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderRequestId).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderDate).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderXMsVersion).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderRequestId).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderDate).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderXMsVersion).empty());
EXPECT_FALSE(res->ETag.empty());
EXPECT_FALSE(res->LastModified.empty());
EXPECT_FALSE(res->Snapshot.empty());
@ -248,9 +248,9 @@ namespace Azure { namespace Storage { namespace Test {
blockBlobClient.SetHttpHeaders(m_blobUploadOptions.HttpHeaders);
auto res = blockBlobClient.GetProperties();
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderRequestId).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderDate).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderXMsVersion).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderRequestId).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderDate).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderXMsVersion).empty());
EXPECT_FALSE(res->ETag.empty());
EXPECT_FALSE(res->LastModified.empty());
EXPECT_FALSE(res->CreationTime.empty());
@ -283,9 +283,9 @@ namespace Azure { namespace Storage { namespace Test {
EXPECT_TRUE(blobContentInfo->VersionId.HasValue());
EXPECT_FALSE(blobContentInfo->VersionId.GetValue().empty());
auto res = blockBlobClient.GetBlockList();
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderRequestId).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderDate).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderXMsVersion).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderRequestId).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderDate).empty());
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::HttpHeaderXMsVersion).empty());
EXPECT_FALSE(res->ETag.empty());
EXPECT_FALSE(res->LastModified.empty());
EXPECT_EQ(res->ContentLength, static_cast<int64_t>(block1Content.size()));

6
sdk/storage/azure-storage-blobs/test/page_blob_client_test.cpp
View File

@ -190,7 +190,7 @@ namespace Azure { namespace Storage { namespace Test {
EXPECT_FALSE(blobInfo.ETag.empty());
EXPECT_FALSE(blobInfo.LastModified.empty());
aLease = *m_pageBlobClient->AcquireLease(CreateUniqueLeaseId(), c_InfiniteLeaseDuration);
aLease = *m_pageBlobClient->AcquireLease(CreateUniqueLeaseId(), InfiniteLeaseDuration);
properties = *m_pageBlobClient->GetProperties();
EXPECT_FALSE(properties.LeaseDuration.GetValue().empty());
auto brokenLease = *m_pageBlobClient->BreakLease();
@ -226,7 +226,7 @@ namespace Azure { namespace Storage { namespace Test {
EXPECT_NO_THROW(pageBlobClient.UploadPages(0, &pageContent, options));
pageContent.Rewind();
options.TransactionalContentMd5 = c_dummyMd5;
options.TransactionalContentMd5 = DummyMd5;
EXPECT_THROW(pageBlobClient.UploadPages(0, &pageContent, options), StorageException);
}
@ -247,7 +247,7 @@ namespace Azure { namespace Storage { namespace Test {
EXPECT_NO_THROW(pageBlobClient.UploadPages(0, &pageContent, options));
pageContent.Rewind();
options.TransactionalContentCrc64 = c_dummyCrc64;
options.TransactionalContentCrc64 = DummyCrc64;
EXPECT_THROW(pageBlobClient.UploadPages(0, &pageContent, options), StorageException);
}

14
sdk/storage/azure-storage-blobs/test/storage_retry_policy_test.cpp
View File

@ -16,15 +16,15 @@ namespace Azure { namespace Storage { namespace Test {
explicit MockTransportPolicy(std::string primaryContent)
: m_primaryContent(std::make_shared<std::string>(std::move(primaryContent))),
m_primaryETag(c_dummyETag)
m_primaryETag(DummyETag)
{
}
explicit MockTransportPolicy(std::string primaryContent, std::string secondaryContent)
: m_primaryContent(std::make_shared<std::string>(std::move(primaryContent))),
m_secondaryContent(std::make_shared<std::string>(std::move(secondaryContent))),
m_primaryETag(c_dummyETag),
m_secondaryETag(*m_secondaryContent == *m_primaryContent ? c_dummyETag : c_dummyETag2)
m_primaryETag(DummyETag),
m_secondaryETag(*m_secondaryContent == *m_primaryContent ? DummyETag : DummyETag2)
{
}
@ -84,7 +84,7 @@ namespace Azure { namespace Storage { namespace Test {
response->AddHeader("content-length", std::to_string(errorResponseBody.length()));
response->AddHeader("content-type", "application/xml");
response->AddHeader("x-ms-request-id", Core::Uuid::CreateUuid().GetUuidString());
response->AddHeader("x-ms-version", Blobs::Details::c_ApiVersion);
response->AddHeader("x-ms-version", Blobs::Details::ApiVersion);
response->AddHeader("x-ms-error-code", "BlobNotFound");
response->AddHeader("date", ToRfc1123(std::chrono::system_clock::now()));
return response;
@ -106,7 +106,7 @@ namespace Azure { namespace Storage { namespace Test {
response->AddHeader("content-length", std::to_string(errorResponseBody.length()));
response->AddHeader("content-type", "application/xml");
response->AddHeader("x-ms-request-id", Core::Uuid::CreateUuid().GetUuidString());
response->AddHeader("x-ms-version", Blobs::Details::c_ApiVersion);
response->AddHeader("x-ms-version", Blobs::Details::ApiVersion);
response->AddHeader("x-ms-error-code", "ConditionNotMet");
response->AddHeader("date", ToRfc1123(std::chrono::system_clock::now()));
return response;
@ -129,7 +129,7 @@ namespace Azure { namespace Storage { namespace Test {
response->AddHeader("etag", m_primaryETag);
response->AddHeader("last-modified", "Thu 27 Aug 2001 07:00:00 GMT");
response->AddHeader("x-ms-request-id", Core::Uuid::CreateUuid().GetUuidString());
response->AddHeader("x-ms-version", Blobs::Details::c_ApiVersion);
response->AddHeader("x-ms-version", Blobs::Details::ApiVersion);
response->AddHeader("x-ms-creation-time", "Thu 27 Aug 2002 07:00:00 GMT");
response->AddHeader("x-ms-lease-status", "unlocked");
response->AddHeader("x-ms-lease-state", "available");
@ -156,7 +156,7 @@ namespace Azure { namespace Storage { namespace Test {
response->AddHeader("etag", m_secondaryETag);
response->AddHeader("last-modified", "Thu 27 Aug 2001 07:00:00 GMT");
response->AddHeader("x-ms-request-id", Core::Uuid::CreateUuid().GetUuidString());
response->AddHeader("x-ms-version", Blobs::Details::c_ApiVersion);
response->AddHeader("x-ms-version", Blobs::Details::ApiVersion);
response->AddHeader("x-ms-creation-time", "Thu 27 Aug 2002 07:00:00 GMT");
response->AddHeader("x-ms-lease-status", "unlocked");
response->AddHeader("x-ms-lease-state", "available");

28
sdk/storage/azure-storage-common/inc/azure/storage/common/constants.hpp
View File

@ -5,19 +5,19 @@
#pragma once
namespace Azure { namespace Storage { namespace Details {
constexpr static const char* c_BlobServicePackageName = "storage-blobs";
constexpr static const char* c_DatalakeServicePackageName = "storage-files-datalake";
constexpr static const char* c_FileServicePackageName = "storage-files-shares";
constexpr static const char* c_QueueServicePackageName = "storage-queues";
constexpr static const char* c_HttpQuerySnapshot = "snapshot";
constexpr static const char* c_HttpQueryVersionId = "versionid";
constexpr static const char* c_StorageScope = "https://storage.azure.com/.default";
constexpr static const char* c_HttpHeaderDate = "date";
constexpr static const char* c_HttpHeaderXMsVersion = "x-ms-version";
constexpr static const char* c_HttpHeaderRequestId = "x-ms-request-id";
constexpr static const char* c_HttpHeaderClientRequestId = "x-ms-client-request-id";
constexpr static const char* c_HttpHeaderContentType = "content-type";
constexpr static const char* c_defaultSasVersion = "2020-02-10";
constexpr static const char* BlobServicePackageName = "storage-blobs";
constexpr static const char* DatalakeServicePackageName = "storage-files-datalake";
constexpr static const char* FileServicePackageName = "storage-files-shares";
constexpr static const char* QueueServicePackageName = "storage-queues";
constexpr static const char* HttpQuerySnapshot = "snapshot";
constexpr static const char* HttpQueryVersionId = "versionid";
constexpr static const char* StorageScope = "https://storage.azure.com/.default";
constexpr static const char* HttpHeaderDate = "date";
constexpr static const char* HttpHeaderXMsVersion = "x-ms-version";
constexpr static const char* HttpHeaderRequestId = "x-ms-request-id";
constexpr static const char* HttpHeaderClientRequestId = "x-ms-client-request-id";
constexpr static const char* HttpHeaderContentType = "content-type";
constexpr static const char* DefaultSasVersion = "2020-02-10";
constexpr int c_reliableStreamRetryCount = 3;
constexpr int ReliableStreamRetryCount = 3;
}}} // namespace Azure::Storage::Details

6
sdk/storage/azure-storage-common/inc/azure/storage/common/storage_common.hpp
View File

@ -10,9 +10,9 @@ namespace Azure { namespace Storage {
template <class... T> void unused(T&&...) {}
constexpr int32_t c_InfiniteLeaseDuration = -1;
constexpr static const char* c_AccountEncryptionKey = "$account-encryption-key";
constexpr static const char* c_ETagWildcard = "*";
constexpr int32_t InfiniteLeaseDuration = -1;
constexpr static const char* AccountEncryptionKey = "$account-encryption-key";
constexpr static const char* ETagWildcard = "*";
std::string CreateUniqueLeaseId();

6
sdk/storage/azure-storage-common/sample/main.cpp
View File

@ -12,11 +12,11 @@
const std::string& GetConnectionString()
{
const static std::string c_ConnectionString = "";
const static std::string ConnectionString = "";
if (!c_ConnectionString.empty())
if (!ConnectionString.empty())
{
return c_ConnectionString;
return ConnectionString;
}
const static std::string envConnectionString = std::getenv("AZURE_STORAGE_CONNECTION_STRING");
if (!envConnectionString.empty())

4
sdk/storage/azure-storage-common/src/account_sas_builder.cpp
View File

@ -99,14 +99,14 @@ namespace Azure { namespace Storage {
std::string stringToSign = credential.AccountName + "\n" + Permissions + "\n" + services + "\n"
+ resourceTypes + "\n" + (StartsOn.HasValue() ? StartsOn.GetValue() : "") + "\n" + ExpiresOn
+ "\n" + (IPRange.HasValue() ? IPRange.GetValue() : "") + "\n" + protocol + "\n"
+ Details::c_defaultSasVersion + "\n";
+ Details::DefaultSasVersion + "\n";
std::string signature
= Base64Encode(Details::HmacSha256(stringToSign, Base64Decode(credential.GetAccountKey())));
Azure::Core::Http::Url builder;
builder.AppendQueryParameter(
"sv", Details::UrlEncodeQueryParameter(Details::c_defaultSasVersion));
"sv", Details::UrlEncodeQueryParameter(Details::DefaultSasVersion));
builder.AppendQueryParameter("ss", Details::UrlEncodeQueryParameter(services));
builder.AppendQueryParameter("srt", Details::UrlEncodeQueryParameter(resourceTypes));
builder.AppendQueryParameter("sp", Details::UrlEncodeQueryParameter(Permissions));

14
sdk/storage/azure-storage-common/src/crypt.cpp
View File

@ -25,13 +25,13 @@
namespace Azure { namespace Storage {
namespace Details {
static const char* c_subdelimiters = "!$&'()*+,;=";
static const char* Subdelimiters = "!$&'()*+,;=";
std::string UrlEncodeQueryParameter(const std::string& value)
{
const static std::string c_doNotEncodeCharacters = []() {
const static std::string DoNotEncodeCharacters = []() {
// Core::Http::Url::Encode won't encode unreserved characters.
std::string doNotEncodeCharacters = c_subdelimiters;
std::string doNotEncodeCharacters = Subdelimiters;
doNotEncodeCharacters += "/:@?";
doNotEncodeCharacters.erase(
std::remove_if(
@ -47,14 +47,14 @@ namespace Azure { namespace Storage {
doNotEncodeCharacters.end());
return doNotEncodeCharacters;
}();
return Core::Http::Url::Encode(value, c_doNotEncodeCharacters);
return Core::Http::Url::Encode(value, DoNotEncodeCharacters);
}
std::string UrlEncodePath(const std::string& value)
{
const static std::string c_doNotEncodeCharacters = []() {
const static std::string DoNotEncodeCharacters = []() {
// Core::Http::Url::Encode won't encode unreserved characters.
std::string doNotEncodeCharacters = c_subdelimiters;
std::string doNotEncodeCharacters = Subdelimiters;
doNotEncodeCharacters += "/:@";
doNotEncodeCharacters.erase(
std::remove_if(
@ -67,7 +67,7 @@ namespace Azure { namespace Storage {
doNotEncodeCharacters.end());
return doNotEncodeCharacters;
}();
return Core::Http::Url::Encode(value, c_doNotEncodeCharacters);
return Core::Http::Url::Encode(value, DoNotEncodeCharacters);
}
} // namespace Details

28
sdk/storage/azure-storage-common/src/storage_exception.cpp
View File

@ -34,10 +34,9 @@ namespace Azure { namespace Storage {
std::string errorCode;
std::string message;
if (response->GetHeaders().find(Details::c_HttpHeaderContentType)
!= response->GetHeaders().end())
if (response->GetHeaders().find(Details::HttpHeaderContentType) != response->GetHeaders().end())
{
if (response->GetHeaders().at(Details::c_HttpHeaderContentType).find("xml")
if (response->GetHeaders().at(Details::HttpHeaderContentType).find("xml")
!= std::string::npos)
{
auto xmlReader = Details::XmlReader(
@ -45,9 +44,9 @@ namespace Azure { namespace Storage {
enum class XmlTagName
{
c_Error,
c_Code,
c_Message,
XmlTagError,
XmlTagCode,
XmlTagMessage,
};
std::vector<XmlTagName> path;
@ -73,26 +72,27 @@ namespace Azure { namespace Storage {
{
if (std::strcmp(node.Name, "Error") == 0)
{
path.emplace_back(XmlTagName::c_Error);
path.emplace_back(XmlTagName::XmlTagError);
}
else if (std::strcmp(node.Name, "Code") == 0)
{
path.emplace_back(XmlTagName::c_Code);
path.emplace_back(XmlTagName::XmlTagCode);
}
else if (std::strcmp(node.Name, "Message") == 0)
{
path.emplace_back(XmlTagName::c_Message);
path.emplace_back(XmlTagName::XmlTagMessage);
}
}
else if (node.Type == Details::XmlNodeType::Text)
{
if (path.size() == 2 && path[0] == XmlTagName::c_Error && path[1] == XmlTagName::c_Code)
if (path.size() == 2 && path[0] == XmlTagName::XmlTagError
&& path[1] == XmlTagName::XmlTagCode)
{
errorCode = node.Value;
}
else if (
path.size() == 2 && path[0] == XmlTagName::c_Error
&& path[1] == XmlTagName::c_Message)
path.size() == 2 && path[0] == XmlTagName::XmlTagError
&& path[1] == XmlTagName::XmlTagMessage)
{
message = node.Value;
}
@ -100,14 +100,14 @@ namespace Azure { namespace Storage {
}
}
else if (
response->GetHeaders().at(Details::c_HttpHeaderContentType).find("html")
response->GetHeaders().at(Details::HttpHeaderContentType).find("html")
!= std::string::npos)
{
// TODO: add a refined message parsed from result.
message = std::string(bodyBuffer.begin(), bodyBuffer.end());
}
else if (
response->GetHeaders().at(Details::c_HttpHeaderContentType).find("json")
response->GetHeaders().at(Details::HttpHeaderContentType).find("json")
!= std::string::npos)
{
auto jsonParser = nlohmann::json::parse(bodyBuffer);

8
sdk/storage/azure-storage-common/src/storage_per_retry_policy.cpp
View File

@ -12,11 +12,11 @@ namespace Azure { namespace Storage {
Core::Http::Request& request,
Core::Http::NextHttpPolicy nextHttpPolicy) const
{
const char* c_HttpHeaderDate = "Date";
const char* c_HttpHeaderXMsDate = "x-ms-date";
const char* HttpHeaderDate = "Date";
const char* HttpHeaderXMsDate = "x-ms-date";
const auto& headers = request.GetHeaders();
if (headers.find(c_HttpHeaderDate) == headers.end())
if (headers.find(HttpHeaderDate) == headers.end())
{
// add x-ms-date header in RFC1123 format
// TODO: call helper function provided by Azure Core when they provide one.
@ -36,7 +36,7 @@ namespace Azure { namespace Storage {
char datetimeStr[32];
std::strftime(datetimeStr, sizeof(datetimeStr), rfc1123Format.data(), &ct);
request.AddHeader(c_HttpHeaderXMsDate, datetimeStr);
request.AddHeader(HttpHeaderXMsDate, datetimeStr);
}
return nextHttpPolicy.Send(ctx, request);

48
sdk/storage/azure-storage-common/test/test_base.cpp
View File

@ -23,14 +23,14 @@
namespace Azure { namespace Storage { namespace Test {
constexpr static const char* c_StandardStorageConnectionString = "";
constexpr static const char* c_PremiumStorageConnectionString = "";
constexpr static const char* c_BlobStorageConnectionString = "";
constexpr static const char* c_PremiumFileConnectionString = "";
constexpr static const char* c_AdlsGen2ConnectionString = "";
constexpr static const char* c_AadTenantId = "";
constexpr static const char* c_AadClientId = "";
constexpr static const char* c_AadClientSecret = "";
constexpr static const char* StandardStorageConnectionStringValue = "";
constexpr static const char* PremiumStorageConnectionStringValue = "";
constexpr static const char* BlobStorageConnectionStringValue = "";
constexpr static const char* PremiumFileConnectionStringValue = "";
constexpr static const char* AdlsGen2ConnectionStringValue = "";
constexpr static const char* AadTenantIdValue = "";
constexpr static const char* AadClientIdValue = "";
constexpr static const char* AadClientSecretValue = "";
std::string GetEnv(const std::string& name)
{
@ -46,9 +46,9 @@ namespace Azure { namespace Storage { namespace Test {
const std::string& StandardStorageConnectionString()
{
const static std::string connectionString = []() -> std::string {
if (strlen(c_StandardStorageConnectionString) != 0)
if (strlen(StandardStorageConnectionStringValue) != 0)
{
return c_StandardStorageConnectionString;
return StandardStorageConnectionStringValue;
}
return GetEnv("STANDARD_STORAGE_CONNECTION_STRING");
}();
@ -58,9 +58,9 @@ namespace Azure { namespace Storage { namespace Test {
const std::string& PremiumStorageConnectionString()
{
const static std::string connectionString = []() -> std::string {
if (strlen(c_PremiumStorageConnectionString) != 0)
if (strlen(PremiumStorageConnectionStringValue) != 0)
{
return c_PremiumStorageConnectionString;
return PremiumStorageConnectionStringValue;
}
return GetEnv("PREMIUM_STORAGE_CONNECTION_STRING");
}();
@ -70,9 +70,9 @@ namespace Azure { namespace Storage { namespace Test {
const std::string& BlobStorageConnectionString()
{
const static std::string connectionString = []() -> std::string {
if (strlen(c_BlobStorageConnectionString) != 0)
if (strlen(BlobStorageConnectionStringValue) != 0)
{
return c_BlobStorageConnectionString;
return BlobStorageConnectionStringValue;
}
return GetEnv("BLOB_STORAGE_CONNECTION_STRING");
}();
@ -82,9 +82,9 @@ namespace Azure { namespace Storage { namespace Test {
const std::string& PremiumFileConnectionString()
{
const static std::string connectionString = []() -> std::string {
if (strlen(c_PremiumFileConnectionString) != 0)
if (strlen(PremiumFileConnectionStringValue) != 0)
{
return c_PremiumFileConnectionString;
return PremiumFileConnectionStringValue;
}
return GetEnv("PREMIUM_FILE_CONNECTION_STRING");
}();
@ -94,9 +94,9 @@ namespace Azure { namespace Storage { namespace Test {
const std::string& AdlsGen2ConnectionString()
{
const static std::string connectionString = []() -> std::string {
if (strlen(c_AdlsGen2ConnectionString) != 0)
if (strlen(AdlsGen2ConnectionStringValue) != 0)
{
return c_AdlsGen2ConnectionString;
return AdlsGen2ConnectionStringValue;
}
return GetEnv("ADLS_GEN2_CONNECTION_STRING");
}();
@ -106,9 +106,9 @@ namespace Azure { namespace Storage { namespace Test {
const std::string& AadTenantId()
{
const static std::string connectionString = []() -> std::string {
if (strlen(c_AadTenantId) != 0)
if (strlen(AadTenantIdValue) != 0)
{
return c_AadTenantId;
return AadTenantIdValue;
}
return GetEnv("AAD_TENANT_ID");
}();
@ -118,9 +118,9 @@ namespace Azure { namespace Storage { namespace Test {
const std::string& AadClientId()
{
const static std::string connectionString = []() -> std::string {
if (strlen(c_AadClientId) != 0)
if (strlen(AadClientIdValue) != 0)
{
return c_AadClientId;
return AadClientIdValue;
}
return GetEnv("AAD_CLIENT_ID");
}();
@ -130,9 +130,9 @@ namespace Azure { namespace Storage { namespace Test {
const std::string& AadClientSecret()
{
const static std::string connectionString = []() -> std::string {
if (strlen(c_AadClientSecret) != 0)
if (strlen(AadClientSecretValue) != 0)
{
return c_AadClientSecret;
return AadClientSecretValue;
}
return GetEnv("AAD_CLIENT_SECRET");
}();

10
sdk/storage/azure-storage-common/test/test_base.hpp
View File

@ -22,7 +22,7 @@ namespace Azure { namespace Storage { namespace Test {
const std::string& AadClientId();
const std::string& AadClientSecret();
constexpr static const char* c_TestEncryptionScope = "EncryptionScopeForTest";
constexpr static const char* TestEncryptionScope = "EncryptionScopeForTest";
constexpr inline unsigned long long operator""_KB(unsigned long long x) { return x * 1024; }
constexpr inline unsigned long long operator""_MB(unsigned long long x)
@ -38,10 +38,10 @@ namespace Azure { namespace Storage { namespace Test {
return x * 1024 * 1024 * 1024 * 1024;
}
constexpr static const char* c_dummyETag = "0x8D83B58BDF51D75";
constexpr static const char* c_dummyETag2 = "0x8D812645BFB0CDE";
constexpr static const char* c_dummyMd5 = "tQbD1aMPeB+LiPffUwFQJQ==";
constexpr static const char* c_dummyCrc64 = "+DNR5PON4EM=";
constexpr static const char* DummyETag = "0x8D83B58BDF51D75";
constexpr static const char* DummyETag2 = "0x8D812645BFB0CDE";
constexpr static const char* DummyMd5 = "tQbD1aMPeB+LiPffUwFQJQ==";
constexpr static const char* DummyCrc64 = "+DNR5PON4EM=";
uint64_t RandomInt(
uint64_t minNumber = std::numeric_limits<uint64_t>::min(),

2
sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/datalake_path_client.hpp
View File

@ -174,7 +174,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
* @brief Acquires a lease on the path.
* @param proposedLeaseId Proposed lease ID, in a GUID string format.
* @param duration Specifies the duration of the lease, in seconds, or
* Azure::Storage::c_InfiniteLeaseDuration for a lease that never expires. A non-infinite lease
* Azure::Storage::InfiniteLeaseDuration for a lease that never expires. A non-infinite lease
* can be between 15 and 60 seconds. A lease duration cannot be changed using renew or change.
* @param options Optional parameters to execute this function.
* @return Azure::Core::Response<Models::AcquirePathLeaseResult> describing the lease.

8
sdk/storage/azure-storage-files-datalake/src/datalake_directory_client.cpp
View File

@ -50,7 +50,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::c_DatalakeServicePackageName, Version::VersionString()));
Azure::Storage::Details::DatalakeServicePackageName, Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
@ -80,7 +80,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::c_DatalakeServicePackageName, Version::VersionString()));
Azure::Storage::Details::DatalakeServicePackageName, Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
@ -96,7 +96,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
policies.emplace_back(std::make_unique<StoragePerRetryPolicy>());
policies.emplace_back(std::make_unique<Core::BearerTokenAuthenticationPolicy>(
credential, Azure::Storage::Details::c_StorageScope));
credential, Azure::Storage::Details::StorageScope));
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Http::HttpPipeline>(policies);
@ -109,7 +109,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::c_DatalakeServicePackageName, Version::VersionString()));
Azure::Storage::Details::DatalakeServicePackageName, Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{

8
sdk/storage/azure-storage-files-datalake/src/datalake_file_client.cpp
View File

@ -128,7 +128,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::c_DatalakeServicePackageName, Version::VersionString()));
Azure::Storage::Details::DatalakeServicePackageName, Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
@ -159,7 +159,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::c_DatalakeServicePackageName, Version::VersionString()));
Azure::Storage::Details::DatalakeServicePackageName, Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
@ -176,7 +176,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
policies.emplace_back(std::make_unique<StoragePerRetryPolicy>());
policies.emplace_back(std::make_unique<Core::BearerTokenAuthenticationPolicy>(
credential, Azure::Storage::Details::c_StorageScope));
credential, Azure::Storage::Details::StorageScope));
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Http::HttpPipeline>(policies);
@ -187,7 +187,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::c_DatalakeServicePackageName, Version::VersionString()));
Azure::Storage::Details::DatalakeServicePackageName, Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{

8
sdk/storage/azure-storage-files-datalake/src/datalake_file_system_client.cpp
View File

@ -71,7 +71,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::c_DatalakeServicePackageName, Version::VersionString()));
Azure::Storage::Details::DatalakeServicePackageName, Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
@ -105,7 +105,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::c_DatalakeServicePackageName, Version::VersionString()));
Azure::Storage::Details::DatalakeServicePackageName, Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
@ -122,7 +122,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
policies.emplace_back(std::make_unique<StoragePerRetryPolicy>());
policies.emplace_back(std::make_unique<Core::BearerTokenAuthenticationPolicy>(
credential, Azure::Storage::Details::c_StorageScope));
credential, Azure::Storage::Details::StorageScope));
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Http::HttpPipeline>(policies);
@ -138,7 +138,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::c_DatalakeServicePackageName, Version::VersionString()));
Azure::Storage::Details::DatalakeServicePackageName, Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{

8
sdk/storage/azure-storage-files-datalake/src/datalake_path_client.cpp
View File

@ -112,7 +112,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::c_DatalakeServicePackageName, Version::VersionString()));
Azure::Storage::Details::DatalakeServicePackageName, Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
@ -143,7 +143,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::c_DatalakeServicePackageName, Version::VersionString()));
Azure::Storage::Details::DatalakeServicePackageName, Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
@ -160,7 +160,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
policies.emplace_back(std::make_unique<StoragePerRetryPolicy>());
policies.emplace_back(std::make_unique<Core::BearerTokenAuthenticationPolicy>(
credential, Azure::Storage::Details::c_StorageScope));
credential, Azure::Storage::Details::StorageScope));
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Http::HttpPipeline>(policies);
@ -172,7 +172,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::c_DatalakeServicePackageName, Version::VersionString()));
Azure::Storage::Details::DatalakeServicePackageName, Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{

8
sdk/storage/azure-storage-files-datalake/src/datalake_sas_builder.cpp
View File

@ -126,7 +126,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
std::string stringToSign = Permissions + "\n" + (StartsOn.HasValue() ? StartsOn.GetValue() : "")
+ "\n" + ExpiresOn + "\n" + canonicalName + "\n" + Identifier + "\n"
+ (IPRange.HasValue() ? IPRange.GetValue() : "") + "\n" + protocol + "\n"
+ Storage::Details::c_defaultSasVersion + "\n" + resource + "\n" + "\n" + CacheControl
+ Storage::Details::DefaultSasVersion + "\n" + resource + "\n" + "\n" + CacheControl
+ "\n" + ContentDisposition + "\n" + ContentEncoding + "\n" + ContentLanguage + "\n"
+ ContentType;
@ -135,7 +135,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
Azure::Core::Http::Url builder;
builder.AppendQueryParameter(
"sv", Storage::Details::UrlEncodeQueryParameter(Storage::Details::c_defaultSasVersion));
"sv", Storage::Details::UrlEncodeQueryParameter(Storage::Details::DefaultSasVersion));
builder.AppendQueryParameter("spr", Storage::Details::UrlEncodeQueryParameter(protocol));
if (StartsOn.HasValue())
{
@ -206,7 +206,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
+ userDelegationKey.SignedExpiresOn + "\n" + userDelegationKey.SignedService + "\n"
+ userDelegationKey.SignedVersion + "\n" + PreauthorizedAgentObjectId + "\n" + AgentObjectId
+ "\n" + CorrelationId + "\n" + (IPRange.HasValue() ? IPRange.GetValue() : "") + "\n"
+ protocol + "\n" + Storage::Details::c_defaultSasVersion + "\n" + resource + "\n" + "\n"
+ protocol + "\n" + Storage::Details::DefaultSasVersion + "\n" + resource + "\n" + "\n"
+ CacheControl + "\n" + ContentDisposition + "\n" + ContentEncoding + "\n" + ContentLanguage
+ "\n" + ContentType;
@ -215,7 +215,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
Azure::Core::Http::Url builder;
builder.AppendQueryParameter(
"sv", Storage::Details::UrlEncodeQueryParameter(Storage::Details::c_defaultSasVersion));
"sv", Storage::Details::UrlEncodeQueryParameter(Storage::Details::DefaultSasVersion));
builder.AppendQueryParameter("sr", Storage::Details::UrlEncodeQueryParameter(resource));
if (StartsOn.HasValue())
{

8
sdk/storage/azure-storage-files-datalake/src/datalake_service_client.cpp
View File

@ -80,7 +80,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::c_DatalakeServicePackageName, Version::VersionString()));
Azure::Storage::Details::DatalakeServicePackageName, Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
@ -112,7 +112,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::c_DatalakeServicePackageName, Version::VersionString()));
Azure::Storage::Details::DatalakeServicePackageName, Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
@ -128,7 +128,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
policies.emplace_back(std::make_unique<StoragePerRetryPolicy>());
policies.emplace_back(std::make_unique<Core::BearerTokenAuthenticationPolicy>(
credential, Azure::Storage::Details::c_StorageScope));
credential, Azure::Storage::Details::StorageScope));
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Http::HttpPipeline>(policies);
@ -143,7 +143,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::c_DatalakeServicePackageName, Version::VersionString()));
Azure::Storage::Details::DatalakeServicePackageName, Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{

2
sdk/storage/azure-storage-files-datalake/test/datalake_path_client_test.cpp
View File

@ -268,7 +268,7 @@ namespace Azure { namespace Storage { namespace Test {
EXPECT_FALSE(pathInfo.ETag.empty());
EXPECT_FALSE(pathInfo.LastModified.empty());
aLease = *m_pathClient->AcquireLease(CreateUniqueLeaseId(), c_InfiniteLeaseDuration);
aLease = *m_pathClient->AcquireLease(CreateUniqueLeaseId(), InfiniteLeaseDuration);
properties = *m_pathClient->GetProperties();
EXPECT_FALSE(properties.LeaseDuration.GetValue().empty());
auto brokenLease = *m_pathClient->BreakLease();

2
sdk/storage/azure-storage-files-shares/inc/azure/storage/files/shares/share_client.hpp
View File

@ -224,7 +224,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
*
* @param proposedLeaseId Proposed lease ID, in a GUID string format.
* @param duration Specifies the duration of the lease, in seconds, or
* Azure::Storage::c_InfiniteLeaseDuration for a lease that never expires. A non-infinite lease
* Azure::Storage::InfiniteLeaseDuration for a lease that never expires. A non-infinite lease
* can be between 15 and 60 seconds. A lease duration cannot be changed using renew or change.
* @param options Optional parameters to execute this function.
* @return Azure::Core::Response<Models::AcquireShareLeaseResult> describing the lease.

8
sdk/storage/azure-storage-files-shares/src/share_client.cpp
View File

@ -45,7 +45,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::c_FileServicePackageName, Version::VersionString()));
Azure::Storage::Details::FileServicePackageName, Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
@ -71,7 +71,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::c_FileServicePackageName, Version::VersionString()));
Azure::Storage::Details::FileServicePackageName, Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
@ -84,7 +84,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
}
policies.emplace_back(std::make_unique<StoragePerRetryPolicy>());
policies.emplace_back(std::make_unique<Core::BearerTokenAuthenticationPolicy>(
credential, Azure::Storage::Details::c_StorageScope));
credential, Azure::Storage::Details::StorageScope));
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Http::HttpPipeline>(policies);
@ -95,7 +95,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::c_FileServicePackageName, Version::VersionString()));
Azure::Storage::Details::FileServicePackageName, Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{

8
sdk/storage/azure-storage-files-shares/src/share_directory_client.cpp
View File

@ -46,7 +46,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::c_FileServicePackageName, Version::VersionString()));
Azure::Storage::Details::FileServicePackageName, Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
@ -72,7 +72,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::c_FileServicePackageName, Version::VersionString()));
Azure::Storage::Details::FileServicePackageName, Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
@ -85,7 +85,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
}
policies.emplace_back(std::make_unique<StoragePerRetryPolicy>());
policies.emplace_back(std::make_unique<Core::BearerTokenAuthenticationPolicy>(
credential, Azure::Storage::Details::c_StorageScope));
credential, Azure::Storage::Details::StorageScope));
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Http::HttpPipeline>(policies);
@ -98,7 +98,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::c_FileServicePackageName, Version::VersionString()));
Azure::Storage::Details::FileServicePackageName, Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{

10
sdk/storage/azure-storage-files-shares/src/share_file_client.cpp
View File

@ -49,7 +49,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::c_FileServicePackageName, Version::VersionString()));
Azure::Storage::Details::FileServicePackageName, Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
@ -75,7 +75,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::c_FileServicePackageName, Version::VersionString()));
Azure::Storage::Details::FileServicePackageName, Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
@ -88,7 +88,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
}
policies.emplace_back(std::make_unique<StoragePerRetryPolicy>());
policies.emplace_back(std::make_unique<Core::BearerTokenAuthenticationPolicy>(
credential, Azure::Storage::Details::c_StorageScope));
credential, Azure::Storage::Details::StorageScope));
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Http::HttpPipeline>(policies);
@ -99,7 +99,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::c_FileServicePackageName, Version::VersionString()));
Azure::Storage::Details::FileServicePackageName, Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
@ -264,7 +264,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
};
ReliableStreamOptions reliableStreamOptions;
reliableStreamOptions.MaxRetryRequests = Storage::Details::c_reliableStreamRetryCount;
reliableStreamOptions.MaxRetryRequests = Storage::Details::ReliableStreamRetryCount;
downloadResponse->BodyStream = std::make_unique<ReliableStream>(
std::move(downloadResponse->BodyStream), reliableStreamOptions, retryFunction);
}

4
sdk/storage/azure-storage-files-shares/src/share_sas_builder.cpp
View File

@ -87,7 +87,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
std::string stringToSign = Permissions + "\n" + (StartsOn.HasValue() ? StartsOn.GetValue() : "")
+ "\n" + ExpiresOn + "\n" + canonicalName + "\n" + Identifier + "\n"
+ (IPRange.HasValue() ? IPRange.GetValue() : "") + "\n" + protocol + "\n"
+ Details::c_defaultSasVersion + "\n" + CacheControl + "\n" + ContentDisposition + "\n"
+ Details::DefaultSasVersion + "\n" + CacheControl + "\n" + ContentDisposition + "\n"
+ ContentEncoding + "\n" + ContentLanguage + "\n" + ContentType;
std::string signature
@ -95,7 +95,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
Azure::Core::Http::Url builder;
builder.AppendQueryParameter(
"sv", Details::UrlEncodeQueryParameter(Details::c_defaultSasVersion));
"sv", Details::UrlEncodeQueryParameter(Details::DefaultSasVersion));
builder.AppendQueryParameter("spr", Details::UrlEncodeQueryParameter(protocol));
if (StartsOn.HasValue())
{

8
sdk/storage/azure-storage-files-shares/src/share_service_client.cpp
View File

@ -41,7 +41,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::c_FileServicePackageName, Version::VersionString()));
Azure::Storage::Details::FileServicePackageName, Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
@ -67,7 +67,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::c_FileServicePackageName, Version::VersionString()));
Azure::Storage::Details::FileServicePackageName, Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{
@ -80,7 +80,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
}
policies.emplace_back(std::make_unique<StoragePerRetryPolicy>());
policies.emplace_back(std::make_unique<Core::BearerTokenAuthenticationPolicy>(
credential, Azure::Storage::Details::c_StorageScope));
credential, Azure::Storage::Details::StorageScope));
policies.emplace_back(
std::make_unique<Azure::Core::Http::TransportPolicy>(options.TransportPolicyOptions));
m_pipeline = std::make_shared<Azure::Core::Http::HttpPipeline>(policies);
@ -93,7 +93,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares {
{
std::vector<std::unique_ptr<Azure::Core::Http::HttpPolicy>> policies;
policies.emplace_back(std::make_unique<Azure::Core::Http::TelemetryPolicy>(
Azure::Storage::Details::c_FileServicePackageName, Version::VersionString()));
Azure::Storage::Details::FileServicePackageName, Version::VersionString()));
policies.emplace_back(std::make_unique<Azure::Core::Http::RequestIdPolicy>());
for (const auto& p : options.PerOperationPolicies)
{

4
sdk/storage/azure-storage-files-shares/test/share_client_test.cpp
View File

@ -223,7 +223,7 @@ namespace Azure { namespace Storage { namespace Test {
// EXPECT_FALSE(blobInfo.ETag.empty());
// EXPECT_FALSE(blobInfo.LastModified.empty());
// aLease = *m_shareClient->AcquireLease(CreateUniqueLeaseId(), c_InfiniteLeaseDuration);
// aLease = *m_shareClient->AcquireLease(CreateUniqueLeaseId(), InfiniteLeaseDuration);
// properties = *m_shareClient->GetProperties();
// EXPECT_EQ(Files::Shares::LeaseDurationType::Infinite, properties.LeaseDuration.GetValue());
// auto brokenLease = *m_shareClient->BreakLease();
@ -278,7 +278,7 @@ namespace Azure { namespace Storage { namespace Test {
// EXPECT_FALSE(blobInfo.ETag.empty());
// EXPECT_FALSE(blobInfo.LastModified.empty());
// aLease = *shareSnapshot.AcquireLease(CreateUniqueLeaseId(), c_InfiniteLeaseDuration);
// aLease = *shareSnapshot.AcquireLease(CreateUniqueLeaseId(), InfiniteLeaseDuration);
// properties = *shareSnapshot.GetProperties();
// EXPECT_EQ(Files::Shares::LeaseDurationType::Infinite, properties.LeaseDuration.GetValue());
// auto brokenLease = *shareSnapshot.BreakLease();