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

Rename add headers (#1750)

Browse Source 
* Rename AddHeader to SetHeader
This commit is contained in:
Victor Vazquez 2021-03-04 22:09:22 +00:00 committed by GitHub
parent 92e680b6af
commit 16eb5710d1
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
22 changed files with 834 additions and 830 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
sdk/core/azure-core/CHANGELOG.md
View File

@ -16,6 +16,7 @@
- Moved `BodyStream` and its derived types from `Azure::Core::Http` namespace to `Azure::IO`, and moved the `body_stream.hpp` header from `azure/core/http` to `azure/core/io`.
- Moved `NullBodyStream` to internal usage only. It is not meant for public use.
- Removed `LimitBodyStream`.
- Renamed `AddHeader()` from `Request` and `RawResponse` to `SetHeader()`.
- Introduced `Azure::Core::CaseInsensitiveMap` which is now used to store headers in `Azure::Core::Http::Request` and `Azure::Core::Http::RawResponse`.
- Renamed `TransportPolicyOptions` to `TransportOptions`.
- Renamed `TelemetryPolicyOptions` to `TelemetryOptions`.

27
sdk/core/azure-core/inc/azure/core/http/http.hpp
View File

@ -525,14 +525,17 @@ namespace Azure { namespace Core { namespace Http {
explicit Request(HttpMethod httpMethod, Url url);
/**
* @brief Add HTTP header to the #Azure::Core::Http::Request.
* @brief Set an HTTP header to the #Azure::Core::Http::Request.
*
* @param name The name for the header to be added.
* @param value The value for the header to be added.
* @remark If the header key does not exists, it is added.
*
*
* @param name The name for the header to be set or added.
* @param value The value for the header to be set or added.
*
* @throw if \p name is an invalid header key.
*/
void AddHeader(std::string const& name, std::string const& value);
void SetHeader(std::string const& name, std::string const& value);
/**
* @brief Remove an HTTP header.
@ -660,19 +663,19 @@ namespace Azure { namespace Core { namespace Http {
// ===== Methods used to build HTTP response =====
/**
* @brief Add HTTP header to the #Azure::Core::Http::RawResponse.
* @brief Set an HTTP header to the #Azure::Core::Http::Request.
*
* @remark The \p name must contain valid header name characters (RFC 7230).
*
* @param name The name for the header to be added.
* @param value The value for the header to be added.
* @param name The name for the header to be set or added.
* @param value The value for the header to be set or added.
*
* @throw if \p name contains invalid characters.
*/
void AddHeader(std::string const& name, std::string const& value);
void SetHeader(std::string const& name, std::string const& value);
/**
* @brief Add HTTP header to the #Azure::Core::Http::RawResponse.
* @brief Set an HTTP header to the #Azure::Core::Http::Request.
*
* @remark The \p header must contain valid header name characters (RFC 7230).
* @remark Header name, value and delimiter are expected to be in \p header.
@ -681,10 +684,10 @@ namespace Azure { namespace Core { namespace Http {
*
* @throw if \p header has an invalid header name or if the delimiter is missing.
*/
void AddHeader(std::string const& header);
void SetHeader(std::string const& header);
/**
* @brief Add HTTP header to the #Azure::Core::Http::RawResponse.
* @brief Set an HTTP header to the #Azure::Core::Http::Request.
*
* @remark The string referenced by \p first and \p last must contain valid header name
* characters (RFC 7230).
@ -697,7 +700,7 @@ namespace Azure { namespace Core { namespace Http {
* @throw if the string referenced by \p first and \p last contains an invalid header name or if
* the delimiter is missing.
*/
void AddHeader(uint8_t const* const first, uint8_t const* const last);
void SetHeader(uint8_t const* const first, uint8_t const* const last);
/**
* @brief Set #Azure::IO::BodyStream for this HTTP response.

4
sdk/core/azure-core/inc/azure/core/http/policy.hpp
View File

@ -277,7 +277,7 @@ namespace Azure { namespace Core { namespace Http {
{
auto uuid = Uuid::CreateUuid().ToString();
request.AddHeader(RequestIdHeader, uuid);
request.SetHeader(RequestIdHeader, uuid);
return nextHttpPolicy.Send(ctx, request);
}
};
@ -454,7 +454,7 @@ namespace Azure { namespace Core { namespace Http {
{
for (auto const& hdrPair : m_options.HeaderValues)
{
request.AddHeader(hdrPair.first, hdrPair.second);
request.SetHeader(hdrPair.first, hdrPair.second);
}
{

2
sdk/core/azure-core/src/http/bearer_token_authentication_policy.cpp
View File

@ -22,7 +22,7 @@ std::unique_ptr<RawResponse> BearerTokenAuthenticationPolicy::Send(
m_accessToken = m_credential->GetToken(context, m_tokenRequestOptions);
}
request.AddHeader("authorization", "Bearer " + m_accessToken.Token);
request.SetHeader("authorization", "Bearer " + m_accessToken.Token);
}
return policy.Send(context, request);

14
sdk/core/azure-core/src/http/curl/curl.cpp
View File

@ -217,13 +217,13 @@ CURLcode CurlSession::Perform(Context const& context)
if (hostHeader == headers.end())
{
Log(LogLevel::Verbose, LogMsgPrefix + "No Host in request headers. Adding it");
this->m_request.AddHeader("Host", this->m_request.GetUrl().GetHost());
this->m_request.SetHeader("Host", this->m_request.GetUrl().GetHost());
}
auto isContentLengthHeaderInRequest = headers.find("content-length");
if (isContentLengthHeaderInRequest == headers.end())
{
Log(LogLevel::Verbose, LogMsgPrefix + "No content-length in headers. Adding it");
this->m_request.AddHeader(
this->m_request.SetHeader(
"content-length", std::to_string(this->m_request.GetBodyStream()->Length()));
}
}
@ -232,7 +232,7 @@ CURLcode CurlSession::Perform(Context const& context)
if (this->m_request.GetMethod() == HttpMethod::Put)
{
Log(LogLevel::Verbose, LogMsgPrefix + "Using 100-continue for PUT request");
this->m_request.AddHeader("expect", "100-continue");
this->m_request.SetHeader("expect", "100-continue");
}
// Send request. If the connection assigned to this curlSession is closed or the socket is
@ -851,7 +851,7 @@ int64_t CurlSession::ResponseBufferParser::Parse(
else if (this->state == ResponseParserState::Headers)
{
// will throw if header is invalid
this->m_response->AddHeader(this->m_internalBuffer);
this->m_response->SetHeader(this->m_internalBuffer);
this->m_delimiterStartInPrevPosition = false;
start = index + 1; // jump \n
}
@ -888,7 +888,7 @@ int64_t CurlSession::ResponseBufferParser::Parse(
}
// will throw if header is invalid
this->m_response->AddHeader(buffer + start, buffer + index - 1);
this->m_response->SetHeader(buffer + start, buffer + index - 1);
this->m_delimiterStartInPrevPosition = false;
start = index + 1; // jump \n
}
@ -1035,14 +1035,14 @@ int64_t CurlSession::ResponseBufferParser::BuildHeader(
this->m_internalBuffer.append(start, indexOfEndOfStatusLine);
}
// will throw if header is invalid
m_response->AddHeader(this->m_internalBuffer);
m_response->SetHeader(this->m_internalBuffer);
}
else
{
// Internal Buffer was not required, create response directly from buffer
std::string header(std::string(start, indexOfEndOfStatusLine));
// will throw if header is invalid
this->m_response->AddHeader(header);
this->m_response->SetHeader(header);
}
// reuse buffer

2
sdk/core/azure-core/src/http/http.cpp
View File

@ -15,7 +15,7 @@ void Azure::Core::Http::Details::InsertHeaderWithValidation(
std::string const& headerValue)
{
// Static table for validating header names. It is created just once for the program and reused
// each time AddHeader is called
// each time SetHeader is called
static const uint8_t validChars[256] = {
0, /* 0 - null */
0, /* 1 - start of heading */

10
sdk/core/azure-core/src/http/raw_response.cpp
View File

@ -18,7 +18,7 @@ std::string const& RawResponse::GetReasonPhrase() const { return m_reasonPhrase;
Azure::Core::CaseInsensitiveMap const& RawResponse::GetHeaders() const { return this->m_headers; }
void RawResponse::AddHeader(uint8_t const* const first, uint8_t const* const last)
void RawResponse::SetHeader(uint8_t const* const first, uint8_t const* const last)
{
// get name and value from header
auto start = first;
@ -40,17 +40,17 @@ void RawResponse::AddHeader(uint8_t const* const first, uint8_t const* const las
end = std::find(start, last, '\r');
auto headerValue = std::string(start, end); // remove \r
AddHeader(headerName, headerValue);
SetHeader(headerName, headerValue);
}
void RawResponse::AddHeader(std::string const& header)
void RawResponse::SetHeader(std::string const& header)
{
return AddHeader(
return SetHeader(
reinterpret_cast<uint8_t const*>(header.data()),
reinterpret_cast<uint8_t const*>(header.data() + header.size()));
}
void RawResponse::AddHeader(std::string const& name, std::string const& value)
void RawResponse::SetHeader(std::string const& name, std::string const& value)
{
return Details::InsertHeaderWithValidation(this->m_headers, name, value);
}

2
sdk/core/azure-core/src/http/request.cpp
View File

@ -22,7 +22,7 @@ static Azure::Core::CaseInsensitiveMap MergeMaps(
}
} // namespace
void Request::AddHeader(std::string const& name, std::string const& value)
void Request::SetHeader(std::string const& name, std::string const& value)
{
auto headerNameLowerCase = Azure::Core::Internal::Strings::ToLower(name);
return this->m_retryModeEnabled

2
sdk/core/azure-core/src/http/telemetry_policy.cpp
View File

@ -119,6 +119,6 @@ std::unique_ptr<RawResponse> TelemetryPolicy::Send(
Request& request,
NextHttpPolicy nextHttpPolicy) const
{
request.AddHeader("User-Agent", m_telemetryId);
request.SetHeader("User-Agent", m_telemetryId);
return nextHttpPolicy.Send(ctx, request);
}

6
sdk/core/azure-core/src/http/winhttp/win_http_transport.cpp
View File

@ -154,7 +154,7 @@ void ParseHttpVersion(
*
* @throw if \p headers has an invalid header name or if the delimiter is missing.
*/
void AddHeaders(std::string const& headers, std::unique_ptr<RawResponse>& rawResponse)
void SetHeaders(std::string const& headers, std::unique_ptr<RawResponse>& rawResponse)
{
auto begin = headers.data();
auto end = begin + headers.size();
@ -164,7 +164,7 @@ void AddHeaders(std::string const& headers, std::unique_ptr<RawResponse>& rawRes
auto delimiter = std::find(begin, end, '\0');
if (delimiter < end)
{
rawResponse->AddHeader(
rawResponse->SetHeader(
reinterpret_cast<uint8_t const*>(begin), reinterpret_cast<uint8_t const*>(delimiter));
}
else
@ -537,7 +537,7 @@ std::unique_ptr<RawResponse> WinHttpTransport::GetRawResponse(
auto rawResponse
= std::make_unique<RawResponse>(majorVersion, minorVersion, httpStatusCode, reasonPhrase);
AddHeaders(responseHeaders, rawResponse);
SetHeaders(responseHeaders, rawResponse);
int64_t contentLength
= GetContentLength(handleManager, requestMethod, rawResponse->GetStatusCode());

26
sdk/core/azure-core/test/ut/http.cpp
View File

@ -23,7 +23,7 @@ namespace Azure { namespace Core { namespace Test {
Http::Request req(httpMethod, url);
std::pair<std::string, std::string> expected("valid", "header");
EXPECT_NO_THROW(req.AddHeader(expected.first, expected.second));
EXPECT_NO_THROW(req.SetHeader(expected.first, expected.second));
EXPECT_PRED2(
[](Azure::Core::CaseInsensitiveMap headers, std::pair<std::string, std::string> expected) {
auto firstHeader = headers.begin();
@ -33,11 +33,11 @@ namespace Azure { namespace Core { namespace Test {
req.GetHeaders(),
expected);
EXPECT_THROW(req.AddHeader("invalid()", "header"), std::runtime_error);
EXPECT_THROW(req.SetHeader("invalid()", "header"), std::runtime_error);
// same header will just override
std::pair<std::string, std::string> expectedOverride("valid", "override");
EXPECT_NO_THROW(req.AddHeader(expectedOverride.first, expectedOverride.second));
EXPECT_NO_THROW(req.SetHeader(expectedOverride.first, expectedOverride.second));
EXPECT_PRED2(
[](Azure::Core::CaseInsensitiveMap headers, std::pair<std::string, std::string> expected) {
auto firstHeader = headers.begin();
@ -49,7 +49,7 @@ namespace Azure { namespace Core { namespace Test {
// adding header after one error happened before
std::pair<std::string, std::string> expected2("valid2", "header2");
EXPECT_NO_THROW(req.AddHeader(expected2.first, expected2.second));
EXPECT_NO_THROW(req.SetHeader(expected2.first, expected2.second));
EXPECT_PRED2(
[](Azure::Core::CaseInsensitiveMap headers, std::pair<std::string, std::string> expected) {
auto secondHeader = headers.begin();
@ -68,7 +68,7 @@ namespace Azure { namespace Core { namespace Test {
Http::RawResponse response(1, 1, Http::HttpStatusCode::Accepted, "Test");
std::pair<std::string, std::string> expected("valid", "header");
EXPECT_NO_THROW(response.AddHeader(expected.first, expected.second));
EXPECT_NO_THROW(response.SetHeader(expected.first, expected.second));
EXPECT_PRED2(
[](Azure::Core::CaseInsensitiveMap headers, std::pair<std::string, std::string> expected) {
auto firstHeader = headers.begin();
@ -79,11 +79,11 @@ namespace Azure { namespace Core { namespace Test {
expected);
EXPECT_THROW(
response.AddHeader("invalid()", "header"), Azure::Core::Http::InvalidHeaderException);
response.SetHeader("invalid()", "header"), Azure::Core::Http::InvalidHeaderException);
// same header will just override
std::pair<std::string, std::string> expectedOverride("valid", "override");
EXPECT_NO_THROW(response.AddHeader(expectedOverride.first, expectedOverride.second));
EXPECT_NO_THROW(response.SetHeader(expectedOverride.first, expectedOverride.second));
EXPECT_PRED2(
[](Azure::Core::CaseInsensitiveMap headers, std::pair<std::string, std::string> expected) {
auto firstHeader = headers.begin();
@ -95,7 +95,7 @@ namespace Azure { namespace Core { namespace Test {
// adding header after on error happened
std::pair<std::string, std::string> expected2("valid2", "header2");
EXPECT_NO_THROW(response.AddHeader(expected2.first, expected2.second));
EXPECT_NO_THROW(response.SetHeader(expected2.first, expected2.second));
EXPECT_PRED2(
[](Azure::Core::CaseInsensitiveMap headers, std::pair<std::string, std::string> expected) {
auto secondtHeader = headers.begin();
@ -106,13 +106,13 @@ namespace Azure { namespace Core { namespace Test {
response.GetHeaders(),
expected2);
// Response addHeader overload method to add from string
EXPECT_THROW(response.AddHeader("inv(): header"), Azure::Core::Http::InvalidHeaderException);
// Response SetHeader overload method to add from string
EXPECT_THROW(response.SetHeader("inv(): header"), Azure::Core::Http::InvalidHeaderException);
EXPECT_THROW(
response.AddHeader("no delimiter header"), Azure::Core::Http::InvalidHeaderException);
response.SetHeader("no delimiter header"), Azure::Core::Http::InvalidHeaderException);
// adding header after previous error just happened on add from string
EXPECT_NO_THROW(response.AddHeader("valid3: header3"));
EXPECT_NO_THROW(response.SetHeader("valid3: header3"));
EXPECT_PRED2(
[](Azure::Core::CaseInsensitiveMap headers, std::pair<std::string, std::string> expected) {
auto secondtHeader = headers.begin();
@ -167,7 +167,7 @@ namespace Azure { namespace Core { namespace Test {
req.StartTry();
EXPECT_NO_THROW(req.AddHeader("namE", "retryValue"));
EXPECT_NO_THROW(req.SetHeader("namE", "retryValue"));
auto headers = req.GetHeaders();

4
sdk/core/azure-core/test/ut/transport_adapter_base.cpp
View File

@ -41,7 +41,7 @@ namespace Azure { namespace Core { namespace Test {
// Need to init request again, since retry would be on after it is sent
request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, host);
// Add a header and send again. RawResponse should return that header in the body
request.AddHeader("123", "456");
request.SetHeader("123", "456");
response = m_pipeline->Send(Azure::Core::GetApplicationContext(), request);
checkResponseCode(response->GetStatusCode());
// header length is 6 (data) + 13 (formating) -> ` "123": "456"\r\n,`
@ -189,7 +189,7 @@ namespace Azure { namespace Core { namespace Test {
request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, host, true);
// Add a header and send again. Response should return that header in the body
request.AddHeader("123", "456");
request.SetHeader("123", "456");
response = m_pipeline->Send(Azure::Core::GetApplicationContext(), request);
checkResponseCode(response->GetStatusCode());
// header length is 6 (data) + 13 (formating) -> ` "123": "456"\r\n,`

10
sdk/core/azure-core/test/ut/url.cpp
View File

@ -30,8 +30,8 @@ namespace Azure { namespace Core { namespace Test {
req.GetUrl().GetAbsoluteUrl(),
url.GetAbsoluteUrl());
EXPECT_NO_THROW(req.AddHeader("Name", "value"));
EXPECT_NO_THROW(req.AddHeader("naME2", "value2"));
EXPECT_NO_THROW(req.SetHeader("Name", "value"));
EXPECT_NO_THROW(req.SetHeader("naME2", "value2"));
auto headers = req.GetHeaders();
@ -49,9 +49,9 @@ namespace Azure { namespace Core { namespace Test {
req.StartTry();
// same headers first, then one new
EXPECT_NO_THROW(req.AddHeader("namE", "retryValue"));
EXPECT_NO_THROW(req.AddHeader("HEADER-to-Lower-123", "retryValue2"));
EXPECT_NO_THROW(req.AddHeader("newHeader", "new"));
EXPECT_NO_THROW(req.SetHeader("namE", "retryValue"));
EXPECT_NO_THROW(req.SetHeader("HEADER-to-Lower-123", "retryValue2"));
EXPECT_NO_THROW(req.SetHeader("newHeader", "new"));
headers = req.GetHeaders();

4
sdk/identity/azure-identity/src/client_secret_credential.cpp
View File

@ -54,8 +54,8 @@ Azure::Core::AccessToken ClientSecretCredential::GetToken(
Request request(HttpMethod::Post, url, bodyStream.get());
bodyStream.release();
request.AddHeader("Content-Type", "application/x-www-form-urlencoded");
request.AddHeader("Content-Length", std::to_string(bodyString.size()));
request.SetHeader("Content-Type", "application/x-www-form-urlencoded");
request.SetHeader("Content-Length", std::to_string(bodyString.size()));
HttpPipeline httpPipeline(m_options, "Identity-client-secret-credential", "", {}, {});

4
sdk/keyvault/azure-security-keyvault-common/src/keyvault_pipeline.cpp
View File

@ -29,8 +29,8 @@ Azure::Core::Http::Request Internal::KeyVaultPipeline::CreateRequest(
auto request = ::InitRequest(method, content, m_vaultUrl);
request.AddHeader(Details::ContentType, Details::ApplicationJson);
request.AddHeader(Details::Accept, Details::ApplicationJson);
request.SetHeader(Details::ContentType, Details::ApplicationJson);
request.SetHeader(Details::Accept, Details::ApplicationJson);
request.GetUrl().AppendQueryParameter(Details::ApiVersion, m_apiVersion);

2
sdk/keyvault/azure-security-keyvault-keys/test/ut/mocked_transport_adapter_test.hpp
View File

@ -44,7 +44,7 @@ namespace Azure { namespace Security { namespace KeyVault { namespace Keys { nam
// Copy headers
for (auto header : request.GetHeaders())
{
response->AddHeader(header.first, header.second);
response->SetHeader(header.first, header.second);
}
std::string bodyCount(Details::FakeKey);
response->SetBodyStream(std::make_unique<Azure::IO::MemoryBodyStream>(

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

File diff suppressed because it is too large Load Diff

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

@ -83,12 +83,12 @@ namespace Azure { namespace Storage { namespace Test {
auto response = std::make_unique<Core::Http::RawResponse>(Core::Http::RawResponse(
1, 1, Core::Http::HttpStatusCode::NotFound, "The specified blob does not exist."));
response->SetBody(std::vector<uint8_t>(errorResponseBody.begin(), errorResponseBody.end()));
response->AddHeader("content-length", std::to_string(errorResponseBody.length()));
response->AddHeader("content-type", "application/xml");
response->AddHeader("x-ms-request-id", Core::Uuid::CreateUuid().ToString());
response->AddHeader("x-ms-version", Blobs::Details::ApiVersion);
response->AddHeader("x-ms-error-code", "BlobNotFound");
response->AddHeader(
response->SetHeader("content-length", std::to_string(errorResponseBody.length()));
response->SetHeader("content-type", "application/xml");
response->SetHeader("x-ms-request-id", Core::Uuid::CreateUuid().ToString());
response->SetHeader("x-ms-version", Blobs::Details::ApiVersion);
response->SetHeader("x-ms-error-code", "BlobNotFound");
response->SetHeader(
"date",
Azure::Core::DateTime(std::chrono::system_clock::now())
.ToString(Azure::Core::DateTime::DateFormat::Rfc1123));
@ -108,12 +108,12 @@ namespace Azure { namespace Storage { namespace Test {
Core::Http::HttpStatusCode::PreconditionFailed,
"The condition specified using HTTP conditional header(s) is not met."));
response->SetBody(std::vector<uint8_t>(errorResponseBody.begin(), errorResponseBody.end()));
response->AddHeader("content-length", std::to_string(errorResponseBody.length()));
response->AddHeader("content-type", "application/xml");
response->AddHeader("x-ms-request-id", Core::Uuid::CreateUuid().ToString());
response->AddHeader("x-ms-version", Blobs::Details::ApiVersion);
response->AddHeader("x-ms-error-code", "ConditionNotMet");
response->AddHeader(
response->SetHeader("content-length", std::to_string(errorResponseBody.length()));
response->SetHeader("content-type", "application/xml");
response->SetHeader("x-ms-request-id", Core::Uuid::CreateUuid().ToString());
response->SetHeader("x-ms-version", Blobs::Details::ApiVersion);
response->SetHeader("x-ms-error-code", "ConditionNotMet");
response->SetHeader(
"date",
Azure::Core::DateTime(std::chrono::system_clock::now())
.ToString(Azure::Core::DateTime::DateFormat::Rfc1123));
@ -133,17 +133,17 @@ namespace Azure { namespace Storage { namespace Test {
reinterpret_cast<const uint8_t*>(m_primaryContent->data() + requestOffset),
bodyLength);
response->SetBodyStream(std::move(bodyStream));
response->AddHeader("content-length", std::to_string(bodyLength));
response->AddHeader("etag", m_primaryETag.ToString());
response->AddHeader("last-modified", "Thu, 23 Aug 2001 07:00:00 GMT");
response->AddHeader("x-ms-request-id", Core::Uuid::CreateUuid().ToString());
response->AddHeader("x-ms-version", Blobs::Details::ApiVersion);
response->AddHeader("x-ms-creation-time", "Thu, 22 Aug 2002 07:00:00 GMT");
response->AddHeader("x-ms-lease-status", "unlocked");
response->AddHeader("x-ms-lease-state", "available");
response->AddHeader("x-ms-blob-type", "BlockBlob");
response->AddHeader("x-ms-server-encrypted", "true");
response->AddHeader(
response->SetHeader("content-length", std::to_string(bodyLength));
response->SetHeader("etag", m_primaryETag.ToString());
response->SetHeader("last-modified", "Thu, 23 Aug 2001 07:00:00 GMT");
response->SetHeader("x-ms-request-id", Core::Uuid::CreateUuid().ToString());
response->SetHeader("x-ms-version", Blobs::Details::ApiVersion);
response->SetHeader("x-ms-creation-time", "Thu, 22 Aug 2002 07:00:00 GMT");
response->SetHeader("x-ms-lease-status", "unlocked");
response->SetHeader("x-ms-lease-state", "available");
response->SetHeader("x-ms-blob-type", "BlockBlob");
response->SetHeader("x-ms-server-encrypted", "true");
response->SetHeader(
"date",
Azure::Core::DateTime(std::chrono::system_clock::now())
.ToString(Azure::Core::DateTime::DateFormat::Rfc1123));
@ -163,17 +163,17 @@ namespace Azure { namespace Storage { namespace Test {
reinterpret_cast<const uint8_t*>(m_secondaryContent->data() + requestOffset),
bodyLength);
response->SetBodyStream(std::move(bodyStream));
response->AddHeader("content-length", std::to_string(bodyLength));
response->AddHeader("etag", m_secondaryETag.ToString());
response->AddHeader("last-modified", "Thu, 23 Aug 2001 07:00:00 GMT");
response->AddHeader("x-ms-request-id", Core::Uuid::CreateUuid().ToString());
response->AddHeader("x-ms-version", Blobs::Details::ApiVersion);
response->AddHeader("x-ms-creation-time", "Thu, 22 Aug 2002 07:00:00 GMT");
response->AddHeader("x-ms-lease-status", "unlocked");
response->AddHeader("x-ms-lease-state", "available");
response->AddHeader("x-ms-blob-type", "BlockBlob");
response->AddHeader("x-ms-server-encrypted", "true");
response->AddHeader(
response->SetHeader("content-length", std::to_string(bodyLength));
response->SetHeader("etag", m_secondaryETag.ToString());
response->SetHeader("last-modified", "Thu, 23 Aug 2001 07:00:00 GMT");
response->SetHeader("x-ms-request-id", Core::Uuid::CreateUuid().ToString());
response->SetHeader("x-ms-version", Blobs::Details::ApiVersion);
response->SetHeader("x-ms-creation-time", "Thu, 22 Aug 2002 07:00:00 GMT");
response->SetHeader("x-ms-lease-status", "unlocked");
response->SetHeader("x-ms-lease-state", "available");
response->SetHeader("x-ms-blob-type", "BlockBlob");
response->SetHeader("x-ms-server-encrypted", "true");
response->SetHeader(
"date",
Azure::Core::DateTime(std::chrono::system_clock::now())
.ToString(Azure::Core::DateTime::DateFormat::Rfc1123));

2
sdk/storage/azure-storage-common/inc/azure/storage/common/shared_key_policy.hpp
View File

@ -31,7 +31,7 @@ namespace Azure { namespace Storage { namespace Details {
Core::Http::Request& request,
Core::Http::NextHttpPolicy nextHttpPolicy) const override
{
request.AddHeader(
request.SetHeader(
"Authorization", "SharedKey " + m_credential->AccountName + ":" + GetSignature(request));
return nextHttpPolicy.Send(ctx, request);
}

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

@ -22,7 +22,7 @@ namespace Azure { namespace Storage { namespace Details {
if (headers.find(HttpHeaderDate) == headers.end())
{
// add x-ms-date header in RFC1123 format
request.AddHeader(
request.SetHeader(
HttpHeaderXMsDate,
Core::DateTime(std::chrono::system_clock::now())
.ToString(Azure::Core::DateTime::DateFormat::Rfc1123));

128
sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/protocol/datalake_rest_client.hpp
View File

@ -426,7 +426,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
Storage::Details::UrlEncodeQueryParameter(
std::to_string(listPathsOptions.Timeout.GetValue())));
}
request.AddHeader(Details::HeaderVersion, listPathsOptions.ApiVersionParameter);
request.SetHeader(Details::HeaderVersion, listPathsOptions.ApiVersionParameter);
if (listPathsOptions.ContinuationToken.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -568,7 +568,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
const CreateOptions& createOptions)
{
Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Put, url);
request.AddHeader(Details::HeaderContentLength, "0");
request.SetHeader(Details::HeaderContentLength, "0");
if (createOptions.Timeout.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -576,7 +576,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
Storage::Details::UrlEncodeQueryParameter(
std::to_string(createOptions.Timeout.GetValue())));
}
request.AddHeader(Details::HeaderVersion, createOptions.ApiVersionParameter);
request.SetHeader(Details::HeaderVersion, createOptions.ApiVersionParameter);
if (createOptions.Resource.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -600,92 +600,92 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
if (createOptions.CacheControl.HasValue())
{
request.AddHeader(Details::HeaderCacheControl, createOptions.CacheControl.GetValue());
request.SetHeader(Details::HeaderCacheControl, createOptions.CacheControl.GetValue());
}
if (createOptions.ContentEncoding.HasValue())
{
request.AddHeader(
request.SetHeader(
Details::HeaderContentEncoding, createOptions.ContentEncoding.GetValue());
}
if (createOptions.ContentLanguage.HasValue())
{
request.AddHeader(
request.SetHeader(
Details::HeaderContentLanguage, createOptions.ContentLanguage.GetValue());
}
if (createOptions.ContentDisposition.HasValue())
{
request.AddHeader(
request.SetHeader(
Details::HeaderContentDisposition, createOptions.ContentDisposition.GetValue());
}
if (createOptions.ContentType.HasValue())
{
request.AddHeader(Details::HeaderContentType, createOptions.ContentType.GetValue());
request.SetHeader(Details::HeaderContentType, createOptions.ContentType.GetValue());
}
if (createOptions.RenameSource.HasValue())
{
request.AddHeader(Details::HeaderRenameSource, createOptions.RenameSource.GetValue());
request.SetHeader(Details::HeaderRenameSource, createOptions.RenameSource.GetValue());
}
if (createOptions.LeaseIdOptional.HasValue())
{
request.AddHeader(Details::HeaderLeaseId, createOptions.LeaseIdOptional.GetValue());
request.SetHeader(Details::HeaderLeaseId, createOptions.LeaseIdOptional.GetValue());
}
if (createOptions.SourceLeaseId.HasValue())
{
request.AddHeader(Details::HeaderSourceLeaseId, createOptions.SourceLeaseId.GetValue());
request.SetHeader(Details::HeaderSourceLeaseId, createOptions.SourceLeaseId.GetValue());
}
if (createOptions.Properties.HasValue())
{
request.AddHeader(Details::HeaderProperties, createOptions.Properties.GetValue());
request.SetHeader(Details::HeaderProperties, createOptions.Properties.GetValue());
}
if (createOptions.Permissions.HasValue())
{
request.AddHeader(Details::HeaderPermissions, createOptions.Permissions.GetValue());
request.SetHeader(Details::HeaderPermissions, createOptions.Permissions.GetValue());
}
if (createOptions.Umask.HasValue())
{
request.AddHeader(Details::HeaderUmask, createOptions.Umask.GetValue());
request.SetHeader(Details::HeaderUmask, createOptions.Umask.GetValue());
}
if (createOptions.IfMatch.HasValue())
{
request.AddHeader(Details::HeaderIfMatch, createOptions.IfMatch.ToString());
request.SetHeader(Details::HeaderIfMatch, createOptions.IfMatch.ToString());
}
if (createOptions.IfNoneMatch.HasValue())
{
request.AddHeader(Details::HeaderIfNoneMatch, createOptions.IfNoneMatch.ToString());
request.SetHeader(Details::HeaderIfNoneMatch, createOptions.IfNoneMatch.ToString());
}
if (createOptions.IfModifiedSince.HasValue())
{
request.AddHeader(
request.SetHeader(
Details::HeaderIfModifiedSince,
createOptions.IfModifiedSince.GetValue().ToString(
Core::DateTime::DateFormat::Rfc1123));
}
if (createOptions.IfUnmodifiedSince.HasValue())
{
request.AddHeader(
request.SetHeader(
Details::HeaderIfUnmodifiedSince,
createOptions.IfUnmodifiedSince.GetValue().ToString(
Core::DateTime::DateFormat::Rfc1123));
}
if (createOptions.SourceIfMatch.HasValue())
{
request.AddHeader(Details::HeaderSourceIfMatch, createOptions.SourceIfMatch.ToString());
request.SetHeader(Details::HeaderSourceIfMatch, createOptions.SourceIfMatch.ToString());
}
if (createOptions.SourceIfNoneMatch.HasValue())
{
request.AddHeader(
request.SetHeader(
Details::HeaderSourceIfNoneMatch, createOptions.SourceIfNoneMatch.ToString());
}
if (createOptions.SourceIfModifiedSince.HasValue())
{
request.AddHeader(
request.SetHeader(
Details::HeaderSourceIfModifiedSince,
createOptions.SourceIfModifiedSince.GetValue().ToString(
Core::DateTime::DateFormat::Rfc1123));
}
if (createOptions.SourceIfUnmodifiedSince.HasValue())
{
request.AddHeader(
request.SetHeader(
Details::HeaderSourceIfUnmodifiedSince,
createOptions.SourceIfUnmodifiedSince.GetValue().ToString(
Core::DateTime::DateFormat::Rfc1123));
@ -720,7 +720,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
Storage::Details::UrlEncodeQueryParameter(
std::to_string(getPropertiesOptions.Timeout.GetValue())));
}
request.AddHeader(Details::HeaderVersion, getPropertiesOptions.ApiVersionParameter);
request.SetHeader(Details::HeaderVersion, getPropertiesOptions.ApiVersionParameter);
if (getPropertiesOptions.Action.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -737,28 +737,28 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
if (getPropertiesOptions.LeaseIdOptional.HasValue())
{
request.AddHeader(
request.SetHeader(
Details::HeaderLeaseId, getPropertiesOptions.LeaseIdOptional.GetValue());
}
if (getPropertiesOptions.IfMatch.HasValue())
{
request.AddHeader(Details::HeaderIfMatch, getPropertiesOptions.IfMatch.ToString());
request.SetHeader(Details::HeaderIfMatch, getPropertiesOptions.IfMatch.ToString());
}
if (getPropertiesOptions.IfNoneMatch.HasValue())
{
request.AddHeader(
request.SetHeader(
Details::HeaderIfNoneMatch, getPropertiesOptions.IfNoneMatch.ToString());
}
if (getPropertiesOptions.IfModifiedSince.HasValue())
{
request.AddHeader(
request.SetHeader(
Details::HeaderIfModifiedSince,
getPropertiesOptions.IfModifiedSince.GetValue().ToString(
Core::DateTime::DateFormat::Rfc1123));
}
if (getPropertiesOptions.IfUnmodifiedSince.HasValue())
{
request.AddHeader(
request.SetHeader(
Details::HeaderIfUnmodifiedSince,
getPropertiesOptions.IfUnmodifiedSince.GetValue().ToString(
Core::DateTime::DateFormat::Rfc1123));
@ -793,7 +793,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
Storage::Details::UrlEncodeQueryParameter(
std::to_string(deleteOptions.Timeout.GetValue())));
}
request.AddHeader(Details::HeaderVersion, deleteOptions.ApiVersionParameter);
request.SetHeader(Details::HeaderVersion, deleteOptions.ApiVersionParameter);
if (deleteOptions.RecursiveOptional.HasValue())
{
request.GetUrl().AppendQueryParameter(
@ -810,26 +810,26 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
if (deleteOptions.LeaseIdOptional.HasValue())
{
request.AddHeader(Details::HeaderLeaseId, deleteOptions.LeaseIdOptional.GetValue());
request.SetHeader(Details::HeaderLeaseId, deleteOptions.LeaseIdOptional.GetValue());
}
if (deleteOptions.IfMatch.HasValue())
{
request.AddHeader(Details::HeaderIfMatch, deleteOptions.IfMatch.ToString());
request.SetHeader(Details::HeaderIfMatch, deleteOptions.IfMatch.ToString());
}
if (deleteOptions.IfNoneMatch.HasValue())
{
request.AddHeader(Details::HeaderIfNoneMatch, deleteOptions.IfNoneMatch.ToString());
request.SetHeader(Details::HeaderIfNoneMatch, deleteOptions.IfNoneMatch.ToString());
}
if (deleteOptions.IfModifiedSince.HasValue())
{
request.AddHeader(
request.SetHeader(
Details::HeaderIfModifiedSince,
deleteOptions.IfModifiedSince.GetValue().ToString(
Core::DateTime::DateFormat::Rfc1123));
}
if (deleteOptions.IfUnmodifiedSince.HasValue())
{
request.AddHeader(
request.SetHeader(
Details::HeaderIfUnmodifiedSince,
deleteOptions.IfUnmodifiedSince.GetValue().ToString(
Core::DateTime::DateFormat::Rfc1123));
@ -869,50 +869,50 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
if (setAccessControlOptions.LeaseIdOptional.HasValue())
{
request.AddHeader(
request.SetHeader(
Details::HeaderLeaseId, setAccessControlOptions.LeaseIdOptional.GetValue());
}
if (setAccessControlOptions.Owner.HasValue())
{
request.AddHeader(Details::HeaderOwner, setAccessControlOptions.Owner.GetValue());
request.SetHeader(Details::HeaderOwner, setAccessControlOptions.Owner.GetValue());
}
if (setAccessControlOptions.Group.HasValue())
{
request.AddHeader(Details::HeaderGroup, setAccessControlOptions.Group.GetValue());
request.SetHeader(Details::HeaderGroup, setAccessControlOptions.Group.GetValue());
}
if (setAccessControlOptions.Permissions.HasValue())
{
request.AddHeader(
request.SetHeader(
Details::HeaderPermissions, setAccessControlOptions.Permissions.GetValue());
}
if (setAccessControlOptions.Acl.HasValue())
{
request.AddHeader(Details::HeaderAcl, setAccessControlOptions.Acl.GetValue());
request.SetHeader(Details::HeaderAcl, setAccessControlOptions.Acl.GetValue());
}
if (setAccessControlOptions.IfMatch.HasValue())
{
request.AddHeader(Details::HeaderIfMatch, setAccessControlOptions.IfMatch.ToString());
request.SetHeader(Details::HeaderIfMatch, setAccessControlOptions.IfMatch.ToString());
}
if (setAccessControlOptions.IfNoneMatch.HasValue())
{
request.AddHeader(
request.SetHeader(
Details::HeaderIfNoneMatch, setAccessControlOptions.IfNoneMatch.ToString());
}
if (setAccessControlOptions.IfModifiedSince.HasValue())
{
request.AddHeader(
request.SetHeader(
Details::HeaderIfModifiedSince,
setAccessControlOptions.IfModifiedSince.GetValue().ToString(
Core::DateTime::DateFormat::Rfc1123));
}
if (setAccessControlOptions.IfUnmodifiedSince.HasValue())
{
request.AddHeader(
request.SetHeader(
Details::HeaderIfUnmodifiedSince,
setAccessControlOptions.IfUnmodifiedSince.GetValue().ToString(
Core::DateTime::DateFormat::Rfc1123));
}
request.AddHeader(Details::HeaderVersion, setAccessControlOptions.ApiVersionParameter);
request.SetHeader(Details::HeaderVersion, setAccessControlOptions.ApiVersionParameter);
return SetAccessControlParseResult(context, pipeline.Send(context, request));
}
@ -969,9 +969,9 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
if (setAccessControlRecursiveOptions.Acl.HasValue())
{
request.AddHeader(Details::HeaderAcl, setAccessControlRecursiveOptions.Acl.GetValue());
request.SetHeader(Details::HeaderAcl, setAccessControlRecursiveOptions.Acl.GetValue());
}
request.AddHeader(
request.SetHeader(
Details::HeaderVersion, setAccessControlRecursiveOptions.ApiVersionParameter);
return SetAccessControlRecursiveParseResult(context, pipeline.Send(context, request));
}
@ -1035,67 +1035,67 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
if (flushDataOptions.ContentLength.HasValue())
{
request.AddHeader(
request.SetHeader(
Details::HeaderContentLength,
std::to_string(flushDataOptions.ContentLength.GetValue()));
}
if (flushDataOptions.ContentMd5.HasValue())
{
request.AddHeader(
request.SetHeader(
Details::HeaderContentHashMd5,
Storage::Details::ToBase64String(flushDataOptions.ContentMd5.GetValue()));
}
if (flushDataOptions.LeaseIdOptional.HasValue())
{
request.AddHeader(Details::HeaderLeaseId, flushDataOptions.LeaseIdOptional.GetValue());
request.SetHeader(Details::HeaderLeaseId, flushDataOptions.LeaseIdOptional.GetValue());
}
if (flushDataOptions.CacheControl.HasValue())
{
request.AddHeader(
request.SetHeader(
Details::HeaderCacheControl, flushDataOptions.CacheControl.GetValue());
}
if (flushDataOptions.ContentType.HasValue())
{
request.AddHeader(Details::HeaderContentType, flushDataOptions.ContentType.GetValue());
request.SetHeader(Details::HeaderContentType, flushDataOptions.ContentType.GetValue());
}
if (flushDataOptions.ContentDisposition.HasValue())
{
request.AddHeader(
request.SetHeader(
Details::HeaderContentDisposition, flushDataOptions.ContentDisposition.GetValue());
}
if (flushDataOptions.ContentEncoding.HasValue())
{
request.AddHeader(
request.SetHeader(
Details::HeaderContentEncoding, flushDataOptions.ContentEncoding.GetValue());
}
if (flushDataOptions.ContentLanguage.HasValue())
{
request.AddHeader(
request.SetHeader(
Details::HeaderContentLanguage, flushDataOptions.ContentLanguage.GetValue());
}
if (flushDataOptions.IfMatch.HasValue())
{
request.AddHeader(Details::HeaderIfMatch, flushDataOptions.IfMatch.ToString());
request.SetHeader(Details::HeaderIfMatch, flushDataOptions.IfMatch.ToString());
}
if (flushDataOptions.IfNoneMatch.HasValue())
{
request.AddHeader(Details::HeaderIfNoneMatch, flushDataOptions.IfNoneMatch.ToString());
request.SetHeader(Details::HeaderIfNoneMatch, flushDataOptions.IfNoneMatch.ToString());
}
if (flushDataOptions.IfModifiedSince.HasValue())
{
request.AddHeader(
request.SetHeader(
Details::HeaderIfModifiedSince,
flushDataOptions.IfModifiedSince.GetValue().ToString(
Core::DateTime::DateFormat::Rfc1123));
}
if (flushDataOptions.IfUnmodifiedSince.HasValue())
{
request.AddHeader(
request.SetHeader(
Details::HeaderIfUnmodifiedSince,
flushDataOptions.IfUnmodifiedSince.GetValue().ToString(
Core::DateTime::DateFormat::Rfc1123));
}
request.AddHeader(Details::HeaderVersion, flushDataOptions.ApiVersionParameter);
request.SetHeader(Details::HeaderVersion, flushDataOptions.ApiVersionParameter);
return FlushDataParseResult(context, pipeline.Send(context, request));
}
@ -1136,29 +1136,29 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
if (appendDataOptions.ContentLength.HasValue())
{
request.AddHeader(
request.SetHeader(
Details::HeaderContentLength,
std::to_string(appendDataOptions.ContentLength.GetValue()));
}
if (appendDataOptions.TransactionalContentMd5.HasValue())
{
request.AddHeader(
request.SetHeader(
Details::HeaderTransactionalContentHashMd5,
Storage::Details::ToBase64String(
appendDataOptions.TransactionalContentMd5.GetValue()));
}
if (appendDataOptions.TransactionalContentCrc64.HasValue())
{
request.AddHeader(
request.SetHeader(
Details::HeaderTransactionalContentHashCrc64,
Storage::Details::ToBase64String(
appendDataOptions.TransactionalContentCrc64.GetValue()));
}
if (appendDataOptions.LeaseIdOptional.HasValue())
{
request.AddHeader(Details::HeaderLeaseId, appendDataOptions.LeaseIdOptional.GetValue());
request.SetHeader(Details::HeaderLeaseId, appendDataOptions.LeaseIdOptional.GetValue());
}
request.AddHeader(Details::HeaderVersion, appendDataOptions.ApiVersionParameter);
request.SetHeader(Details::HeaderVersion, appendDataOptions.ApiVersionParameter);
return AppendDataParseResult(context, pipeline.Send(context, request));
}

388
sdk/storage/azure-storage-files-shares/inc/azure/storage/files/shares/protocol/share_rest_client.hpp
View File

File diff suppressed because it is too large Load Diff