Restoring authorship annotation for <orivej@yandex-team.ru>. Commit 2 of 2.

1 files changed, 359 insertions, 359 deletions

diff --git a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/client/AWSClient.cpp b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/client/AWSClient.cpp
index 8fa8421b49..e1ff064840 100644
--- a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/client/AWSClient.cpp
+++ b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/client/AWSClient.cpp
@@ -1,6 +1,6 @@
-/** 
- * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. 
- * SPDX-License-Identifier: Apache-2.0. 
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
  */
 
 #include <aws/core/client/AWSClient.h>
@@ -16,7 +16,7 @@
 #include <aws/core/http/HttpClientFactory.h>
 #include <aws/core/http/HttpResponse.h>
 #include <aws/core/http/standard/StandardHttpResponse.h>
-#include <aws/core/http/URI.h> 
+#include <aws/core/http/URI.h>
 #include <aws/core/utils/stream/ResponseStream.h>
 #include <aws/core/utils/json/JsonSerializer.h>
 #include <aws/core/utils/Outcome.h>
@@ -29,13 +29,13 @@
 #include <aws/core/utils/crypto/MD5.h>
 #include <aws/core/utils/HashingUtils.h>
 #include <aws/core/utils/crypto/Factories.h>
-#include <aws/core/utils/event/EventStream.h> 
-#include <aws/core/utils/UUID.h> 
+#include <aws/core/utils/event/EventStream.h>
+#include <aws/core/utils/UUID.h>
 #include <aws/core/monitoring/MonitoringManager.h>
-#include <aws/core/Region.h> 
-#include <aws/core/utils/DNS.h> 
-#include <aws/core/Version.h> 
-#include <aws/core/platform/OSVersionInfo.h> 
+#include <aws/core/Region.h>
+#include <aws/core/utils/DNS.h>
+#include <aws/core/Version.h>
+#include <aws/core/platform/OSVersionInfo.h>
 
 #include <cstring>
 #include <cassert>
@@ -52,7 +52,7 @@ static const int SUCCESS_RESPONSE_MAX = 299;
 
 static const char AWS_CLIENT_LOG_TAG[] = "AWSClient";
 //4 Minutes
-static const std::chrono::milliseconds TIME_DIFF_MAX = std::chrono::minutes(4); 
+static const std::chrono::milliseconds TIME_DIFF_MAX = std::chrono::minutes(4);
 //-4 Minutes
 static const std::chrono::milliseconds TIME_DIFF_MIN = std::chrono::minutes(-4);
 
@@ -67,36 +67,36 @@ static CoreErrors GuessBodylessErrorType(Aws::Http::HttpResponseCode responseCod
         return CoreErrors::RESOURCE_NOT_FOUND;
     default:
         return CoreErrors::UNKNOWN;
-    } 
+    }
 }
 
-struct RequestInfo 
-{ 
-    Aws::Utils::DateTime ttl; 
-    long attempt; 
-    long maxAttempts; 
- 
-    operator String() 
-    { 
-        Aws::StringStream ss; 
-        if (ttl.WasParseSuccessful() && ttl != DateTime()) 
-        { 
-            assert(attempt > 1); 
-            ss << "ttl=" << ttl.ToGmtString(DateFormat::ISO_8601_BASIC) << "; "; 
-        } 
-        ss << "attempt=" << attempt; 
-        if (maxAttempts > 0) 
-        { 
-            ss << "; max=" << maxAttempts; 
-        } 
-        return ss.str(); 
-    } 
-}; 
- 
+struct RequestInfo
+{
+    Aws::Utils::DateTime ttl;
+    long attempt;
+    long maxAttempts;
+
+    operator String()
+    {
+        Aws::StringStream ss;
+        if (ttl.WasParseSuccessful() && ttl != DateTime())
+        {
+            assert(attempt > 1);
+            ss << "ttl=" << ttl.ToGmtString(DateFormat::ISO_8601_BASIC) << "; ";
+        }
+        ss << "attempt=" << attempt;
+        if (maxAttempts > 0)
+        {
+            ss << "; max=" << maxAttempts;
+        }
+        return ss.str();
+    }
+};
+
 AWSClient::AWSClient(const Aws::Client::ClientConfiguration& configuration,
     const std::shared_ptr<Aws::Client::AWSAuthSigner>& signer,
     const std::shared_ptr<AWSErrorMarshaller>& errorMarshaller) :
-    m_region(configuration.region), 
+    m_region(configuration.region),
     m_httpClient(CreateHttpClient(configuration)),
     m_signerProvider(Aws::MakeUnique<Aws::Auth::DefaultAuthSignerProvider>(AWS_CLIENT_LOG_TAG, signer)),
     m_errorMarshaller(errorMarshaller),
@@ -104,18 +104,18 @@ AWSClient::AWSClient(const Aws::Client::ClientConfiguration& configuration,
     m_writeRateLimiter(configuration.writeRateLimiter),
     m_readRateLimiter(configuration.readRateLimiter),
     m_userAgent(configuration.userAgent),
-    m_customizedUserAgent(!m_userAgent.empty()), 
+    m_customizedUserAgent(!m_userAgent.empty()),
     m_hash(Aws::Utils::Crypto::CreateMD5Implementation()),
-    m_requestTimeoutMs(configuration.requestTimeoutMs), 
+    m_requestTimeoutMs(configuration.requestTimeoutMs),
     m_enableClockSkewAdjustment(configuration.enableClockSkewAdjustment)
 {
-    SetServiceClientName("AWSBaseClient"); 
+    SetServiceClientName("AWSBaseClient");
 }
 
 AWSClient::AWSClient(const Aws::Client::ClientConfiguration& configuration,
     const std::shared_ptr<Aws::Auth::AWSAuthSignerProvider>& signerProvider,
     const std::shared_ptr<AWSErrorMarshaller>& errorMarshaller) :
-    m_region(configuration.region), 
+    m_region(configuration.region),
     m_httpClient(CreateHttpClient(configuration)),
     m_signerProvider(signerProvider),
     m_errorMarshaller(errorMarshaller),
@@ -123,33 +123,33 @@ AWSClient::AWSClient(const Aws::Client::ClientConfiguration& configuration,
     m_writeRateLimiter(configuration.writeRateLimiter),
     m_readRateLimiter(configuration.readRateLimiter),
     m_userAgent(configuration.userAgent),
-    m_customizedUserAgent(!m_userAgent.empty()), 
+    m_customizedUserAgent(!m_userAgent.empty()),
     m_hash(Aws::Utils::Crypto::CreateMD5Implementation()),
-    m_requestTimeoutMs(configuration.requestTimeoutMs), 
+    m_requestTimeoutMs(configuration.requestTimeoutMs),
     m_enableClockSkewAdjustment(configuration.enableClockSkewAdjustment)
 {
-    SetServiceClientName("AWSBaseClient"); 
+    SetServiceClientName("AWSBaseClient");
+}
+
+void AWSClient::SetServiceClientName(const Aws::String& name)
+{
+    m_serviceName = name;
+    if (!m_customizedUserAgent)
+    {
+        Aws::StringStream ss;
+        ss << "aws-sdk-cpp/" << Version::GetVersionString() << "/" << m_serviceName << "/" <<  Aws::OSVersionInfo::ComputeOSVersionString()
+            << " " << Version::GetCompilerVersionString();
+        m_userAgent = ss.str();
+    }
 }
 
-void AWSClient::SetServiceClientName(const Aws::String& name) 
-{ 
-    m_serviceName = name; 
-    if (!m_customizedUserAgent) 
-    { 
-        Aws::StringStream ss; 
-        ss << "aws-sdk-cpp/" << Version::GetVersionString() << "/" << m_serviceName << "/" <<  Aws::OSVersionInfo::ComputeOSVersionString() 
-            << " " << Version::GetCompilerVersionString(); 
-        m_userAgent = ss.str(); 
-    } 
+void AWSClient::DisableRequestProcessing()
+{
+    m_httpClient->DisableRequestProcessing();
 }
 
-void AWSClient::DisableRequestProcessing() 
-{ 
-    m_httpClient->DisableRequestProcessing(); 
-} 
- 
-void AWSClient::EnableRequestProcessing() 
-{ 
+void AWSClient::EnableRequestProcessing()
+{
     m_httpClient->EnableRequestProcessing();
 }
 
@@ -159,34 +159,34 @@ Aws::Client::AWSAuthSigner* AWSClient::GetSignerByName(const char* name) const
     return signer ? signer.get() : nullptr;
 }
 
-static DateTime GetServerTimeFromError(const AWSError<CoreErrors> error) 
-{ 
-    const Http::HeaderValueCollection& headers = error.GetResponseHeaders(); 
-    auto awsDateHeaderIter = headers.find(StringUtils::ToLower(Http::AWS_DATE_HEADER)); 
-    auto dateHeaderIter = headers.find(StringUtils::ToLower(Http::DATE_HEADER)); 
-    if (awsDateHeaderIter != headers.end()) 
-    { 
-        return DateTime(awsDateHeaderIter->second.c_str(), DateFormat::AutoDetect); 
-    } 
-    else if (dateHeaderIter != headers.end()) 
-    { 
-        return DateTime(dateHeaderIter->second.c_str(), DateFormat::AutoDetect); 
-    } 
-    else 
-    { 
-        return DateTime(); 
-    } 
-} 
- 
+static DateTime GetServerTimeFromError(const AWSError<CoreErrors> error)
+{
+    const Http::HeaderValueCollection& headers = error.GetResponseHeaders();
+    auto awsDateHeaderIter = headers.find(StringUtils::ToLower(Http::AWS_DATE_HEADER));
+    auto dateHeaderIter = headers.find(StringUtils::ToLower(Http::DATE_HEADER));
+    if (awsDateHeaderIter != headers.end())
+    {
+        return DateTime(awsDateHeaderIter->second.c_str(), DateFormat::AutoDetect);
+    }
+    else if (dateHeaderIter != headers.end())
+    {
+        return DateTime(dateHeaderIter->second.c_str(), DateFormat::AutoDetect);
+    }
+    else
+    {
+        return DateTime();
+    }
+}
+
 bool AWSClient::AdjustClockSkew(HttpResponseOutcome& outcome, const char* signerName) const
 {
     if (m_enableClockSkewAdjustment)
     {
         auto signer = GetSignerByName(signerName);
-        //detect clock skew and try to correct. 
+        //detect clock skew and try to correct.
         AWS_LOGSTREAM_WARN(AWS_CLIENT_LOG_TAG, "If the signature check failed. This could be because of a time skew. Attempting to adjust the signer.");
 
-        DateTime serverTime = GetServerTimeFromError(outcome.GetError()); 
+        DateTime serverTime = GetServerTimeFromError(outcome.GetError());
         const auto signingTimestamp = signer->GetSigningTimestamp();
         if (!serverTime.WasParseSuccessful() || serverTime == DateTime())
         {
@@ -202,11 +202,11 @@ bool AWSClient::AdjustClockSkew(HttpResponseOutcome& outcome, const char* signer
             diff = DateTime::Diff(serverTime, DateTime::Now());
             AWS_LOGSTREAM_INFO(AWS_CLIENT_LOG_TAG, "Computed time difference as " << diff.count() << " milliseconds. Adjusting signer with the skew.");
             signer->SetClockSkew(diff);
-            AWSError<CoreErrors> newError( 
+            AWSError<CoreErrors> newError(
                 outcome.GetError().GetErrorType(), outcome.GetError().GetExceptionName(), outcome.GetError().GetMessage(), true);
             newError.SetResponseHeaders(outcome.GetError().GetResponseHeaders());
             newError.SetResponseCode(outcome.GetError().GetResponseCode());
-            outcome = std::move(newError); 
+            outcome = std::move(newError);
             return true;
         }
     }
@@ -216,43 +216,43 @@ bool AWSClient::AdjustClockSkew(HttpResponseOutcome& outcome, const char* signer
 HttpResponseOutcome AWSClient::AttemptExhaustively(const Aws::Http::URI& uri,
     const Aws::AmazonWebServiceRequest& request,
     HttpMethod method,
-    const char* signerName, 
-    const char* signerRegionOverride, 
-    const char* signerServiceNameOverride) const 
+    const char* signerName,
+    const char* signerRegionOverride,
+    const char* signerServiceNameOverride) const
 {
-    if (!Aws::Utils::IsValidHost(uri.GetAuthority())) 
-    { 
-        return HttpResponseOutcome(AWSError<CoreErrors>(CoreErrors::VALIDATION, "", "Invalid DNS Label found in URI host", false/*retryable*/)); 
-    } 
+    if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
+    {
+        return HttpResponseOutcome(AWSError<CoreErrors>(CoreErrors::VALIDATION, "", "Invalid DNS Label found in URI host", false/*retryable*/));
+    }
     std::shared_ptr<HttpRequest> httpRequest(CreateHttpRequest(uri, method, request.GetResponseStreamFactory()));
     HttpResponseOutcome outcome;
-    AWSError<CoreErrors> lastError; 
+    AWSError<CoreErrors> lastError;
     Aws::Monitoring::CoreMetricsCollection coreMetrics;
     auto contexts = Aws::Monitoring::OnRequestStarted(this->GetServiceClientName(), request.GetServiceRequestName(), httpRequest);
-    const char* signerRegion = signerRegionOverride; 
-    Aws::String regionFromResponse; 
-
-    Aws::String invocationId = UUID::RandomUUID(); 
-    RequestInfo requestInfo; 
-    requestInfo.attempt = 1; 
-    requestInfo.maxAttempts = 0; 
-    httpRequest->SetHeaderValue(Http::SDK_INVOCATION_ID_HEADER, invocationId); 
-    httpRequest->SetHeaderValue(Http::SDK_REQUEST_HEADER, requestInfo); 
- 
+    const char* signerRegion = signerRegionOverride;
+    Aws::String regionFromResponse;
+
+    Aws::String invocationId = UUID::RandomUUID();
+    RequestInfo requestInfo;
+    requestInfo.attempt = 1;
+    requestInfo.maxAttempts = 0;
+    httpRequest->SetHeaderValue(Http::SDK_INVOCATION_ID_HEADER, invocationId);
+    httpRequest->SetHeaderValue(Http::SDK_REQUEST_HEADER, requestInfo);
+
     for (long retries = 0;; retries++)
     {
-        m_retryStrategy->GetSendToken(); 
-        httpRequest->SetEventStreamRequest(request.IsEventStreamRequest()); 
- 
-        outcome = AttemptOneRequest(httpRequest, request, signerName, signerRegion, signerServiceNameOverride); 
-        if (retries == 0) 
-        { 
-            m_retryStrategy->RequestBookkeeping(outcome); 
-        } 
-        else 
-        { 
-            m_retryStrategy->RequestBookkeeping(outcome, lastError); 
-        } 
+        m_retryStrategy->GetSendToken();
+        httpRequest->SetEventStreamRequest(request.IsEventStreamRequest());
+
+        outcome = AttemptOneRequest(httpRequest, request, signerName, signerRegion, signerServiceNameOverride);
+        if (retries == 0)
+        {
+            m_retryStrategy->RequestBookkeeping(outcome);
+        }
+        else
+        {
+            m_retryStrategy->RequestBookkeeping(outcome, lastError);
+        }
         coreMetrics.httpClientMetrics = httpRequest->GetRequestMetrics();
         if (outcome.IsSuccess())
         {
@@ -260,11 +260,11 @@ HttpResponseOutcome AWSClient::AttemptExhaustively(const Aws::Http::URI& uri,
             AWS_LOGSTREAM_TRACE(AWS_CLIENT_LOG_TAG, "Request successful returning.");
             break;
         }
-        lastError = outcome.GetError(); 
+        lastError = outcome.GetError();
+
+        DateTime serverTime = GetServerTimeFromError(outcome.GetError());
+        auto clockSkew = DateTime::Diff(serverTime, DateTime::Now());
 
-        DateTime serverTime = GetServerTimeFromError(outcome.GetError()); 
-        auto clockSkew = DateTime::Diff(serverTime, DateTime::Now()); 
- 
         Aws::Monitoring::OnRequestFailed(this->GetServiceClientName(), request.GetServiceRequestName(), httpRequest, outcome, coreMetrics, contexts);
 
         if (!m_httpClient->IsRequestProcessingEnabled())
@@ -273,28 +273,28 @@ HttpResponseOutcome AWSClient::AttemptExhaustively(const Aws::Http::URI& uri,
             break;
         }
 
-        // Adjust region 
-        bool retryWithCorrectRegion = false; 
-        HttpResponseCode httpResponseCode = outcome.GetError().GetResponseCode(); 
-        if (httpResponseCode == HttpResponseCode::MOVED_PERMANENTLY ||  // 301 
-            httpResponseCode == HttpResponseCode::TEMPORARY_REDIRECT || // 307 
-            httpResponseCode == HttpResponseCode::BAD_REQUEST ||        // 400 
-            httpResponseCode == HttpResponseCode::FORBIDDEN)            // 403 
-        { 
-            regionFromResponse = GetErrorMarshaller()->ExtractRegion(outcome.GetError()); 
-            if (m_region == Aws::Region::AWS_GLOBAL && !regionFromResponse.empty() && regionFromResponse != signerRegion) 
-            { 
-                signerRegion = regionFromResponse.c_str(); 
-                retryWithCorrectRegion = true; 
-            } 
-        } 
- 
+        // Adjust region
+        bool retryWithCorrectRegion = false;
+        HttpResponseCode httpResponseCode = outcome.GetError().GetResponseCode();
+        if (httpResponseCode == HttpResponseCode::MOVED_PERMANENTLY ||  // 301
+            httpResponseCode == HttpResponseCode::TEMPORARY_REDIRECT || // 307
+            httpResponseCode == HttpResponseCode::BAD_REQUEST ||        // 400
+            httpResponseCode == HttpResponseCode::FORBIDDEN)            // 403
+        {
+            regionFromResponse = GetErrorMarshaller()->ExtractRegion(outcome.GetError());
+            if (m_region == Aws::Region::AWS_GLOBAL && !regionFromResponse.empty() && regionFromResponse != signerRegion)
+            {
+                signerRegion = regionFromResponse.c_str();
+                retryWithCorrectRegion = true;
+            }
+        }
+
         long sleepMillis = m_retryStrategy->CalculateDelayBeforeNextRetry(outcome.GetError(), retries);
         //AdjustClockSkew returns true means clock skew was the problem and skew was adjusted, false otherwise.
-        //sleep if clock skew and region was NOT the problem. AdjustClockSkew may update error inside outcome. 
-        bool shouldSleep = !AdjustClockSkew(outcome, signerName) && !retryWithCorrectRegion; 
+        //sleep if clock skew and region was NOT the problem. AdjustClockSkew may update error inside outcome.
+        bool shouldSleep = !AdjustClockSkew(outcome, signerName) && !retryWithCorrectRegion;
 
-        if (!retryWithCorrectRegion && !m_retryStrategy->ShouldRetry(outcome.GetError(), retries)) 
+        if (!retryWithCorrectRegion && !m_retryStrategy->ShouldRetry(outcome.GetError(), retries))
         {
             break;
         }
@@ -315,68 +315,68 @@ HttpResponseOutcome AWSClient::AttemptExhaustively(const Aws::Http::URI& uri,
         {
             m_httpClient->RetryRequestSleep(std::chrono::milliseconds(sleepMillis));
         }
- 
-        Aws::Http::URI newUri = uri; 
-        Aws::String newEndpoint = GetErrorMarshaller()->ExtractEndpoint(outcome.GetError()); 
-        if (!newEndpoint.empty()) 
-        { 
-            newUri.SetAuthority(newEndpoint); 
-        } 
-        httpRequest = CreateHttpRequest(newUri, method, request.GetResponseStreamFactory()); 
- 
-        httpRequest->SetHeaderValue(Http::SDK_INVOCATION_ID_HEADER, invocationId); 
-        if (serverTime.WasParseSuccessful() && serverTime != DateTime()) 
-        { 
-            requestInfo.ttl = DateTime::Now() + clockSkew + std::chrono::milliseconds(m_requestTimeoutMs); 
-        } 
-        requestInfo.attempt ++; 
-        requestInfo.maxAttempts = m_retryStrategy->GetMaxAttempts(); 
-        httpRequest->SetHeaderValue(Http::SDK_REQUEST_HEADER, requestInfo); 
+
+        Aws::Http::URI newUri = uri;
+        Aws::String newEndpoint = GetErrorMarshaller()->ExtractEndpoint(outcome.GetError());
+        if (!newEndpoint.empty())
+        {
+            newUri.SetAuthority(newEndpoint);
+        }
+        httpRequest = CreateHttpRequest(newUri, method, request.GetResponseStreamFactory());
+
+        httpRequest->SetHeaderValue(Http::SDK_INVOCATION_ID_HEADER, invocationId);
+        if (serverTime.WasParseSuccessful() && serverTime != DateTime())
+        {
+            requestInfo.ttl = DateTime::Now() + clockSkew + std::chrono::milliseconds(m_requestTimeoutMs);
+        }
+        requestInfo.attempt ++;
+        requestInfo.maxAttempts = m_retryStrategy->GetMaxAttempts();
+        httpRequest->SetHeaderValue(Http::SDK_REQUEST_HEADER, requestInfo);
         Aws::Monitoring::OnRequestRetry(this->GetServiceClientName(), request.GetServiceRequestName(), httpRequest, contexts);
     }
     Aws::Monitoring::OnFinish(this->GetServiceClientName(), request.GetServiceRequestName(), httpRequest, contexts);
     return outcome;
 }
 
-HttpResponseOutcome AWSClient::AttemptExhaustively(const Aws::Http::URI& uri, 
-    HttpMethod method, 
-    const char* signerName, 
-    const char* requestName, 
-    const char* signerRegionOverride, 
-    const char* signerServiceNameOverride) const 
+HttpResponseOutcome AWSClient::AttemptExhaustively(const Aws::Http::URI& uri,
+    HttpMethod method,
+    const char* signerName,
+    const char* requestName,
+    const char* signerRegionOverride,
+    const char* signerServiceNameOverride) const
 {
-    if (!Aws::Utils::IsValidHost(uri.GetAuthority())) 
-    { 
-        return HttpResponseOutcome(AWSError<CoreErrors>(CoreErrors::VALIDATION, "", "Invalid DNS Label found in URI host", false/*retryable*/)); 
-    } 
- 
+    if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
+    {
+        return HttpResponseOutcome(AWSError<CoreErrors>(CoreErrors::VALIDATION, "", "Invalid DNS Label found in URI host", false/*retryable*/));
+    }
+
     std::shared_ptr<HttpRequest> httpRequest(CreateHttpRequest(uri, method, Aws::Utils::Stream::DefaultResponseStreamFactoryMethod));
     HttpResponseOutcome outcome;
-    AWSError<CoreErrors> lastError; 
+    AWSError<CoreErrors> lastError;
     Aws::Monitoring::CoreMetricsCollection coreMetrics;
     auto contexts = Aws::Monitoring::OnRequestStarted(this->GetServiceClientName(), requestName, httpRequest);
-    const char* signerRegion = signerRegionOverride; 
-    Aws::String regionFromResponse; 
-
-    Aws::String invocationId = UUID::RandomUUID(); 
-    RequestInfo requestInfo; 
-    requestInfo.attempt = 1; 
-    requestInfo.maxAttempts = 0; 
-    httpRequest->SetHeaderValue(Http::SDK_INVOCATION_ID_HEADER, invocationId); 
-    httpRequest->SetHeaderValue(Http::SDK_REQUEST_HEADER, requestInfo); 
- 
+    const char* signerRegion = signerRegionOverride;
+    Aws::String regionFromResponse;
+
+    Aws::String invocationId = UUID::RandomUUID();
+    RequestInfo requestInfo;
+    requestInfo.attempt = 1;
+    requestInfo.maxAttempts = 0;
+    httpRequest->SetHeaderValue(Http::SDK_INVOCATION_ID_HEADER, invocationId);
+    httpRequest->SetHeaderValue(Http::SDK_REQUEST_HEADER, requestInfo);
+
     for (long retries = 0;; retries++)
     {
-        m_retryStrategy->GetSendToken(); 
-        outcome = AttemptOneRequest(httpRequest, signerName, requestName, signerRegion, signerServiceNameOverride); 
-        if (retries == 0) 
-        { 
-            m_retryStrategy->RequestBookkeeping(outcome); 
-        } 
-        else 
-        { 
-            m_retryStrategy->RequestBookkeeping(outcome, lastError); 
-        } 
+        m_retryStrategy->GetSendToken();
+        outcome = AttemptOneRequest(httpRequest, signerName, requestName, signerRegion, signerServiceNameOverride);
+        if (retries == 0)
+        {
+            m_retryStrategy->RequestBookkeeping(outcome);
+        }
+        else
+        {
+            m_retryStrategy->RequestBookkeeping(outcome, lastError);
+        }
         coreMetrics.httpClientMetrics = httpRequest->GetRequestMetrics();
         if (outcome.IsSuccess())
         {
@@ -384,11 +384,11 @@ HttpResponseOutcome AWSClient::AttemptExhaustively(const Aws::Http::URI& uri,
             AWS_LOGSTREAM_TRACE(AWS_CLIENT_LOG_TAG, "Request successful returning.");
             break;
         }
-        lastError = outcome.GetError(); 
+        lastError = outcome.GetError();
+
+        DateTime serverTime = GetServerTimeFromError(outcome.GetError());
+        auto clockSkew = DateTime::Diff(serverTime, DateTime::Now());
 
-        DateTime serverTime = GetServerTimeFromError(outcome.GetError()); 
-        auto clockSkew = DateTime::Diff(serverTime, DateTime::Now()); 
- 
         Aws::Monitoring::OnRequestFailed(this->GetServiceClientName(), requestName, httpRequest, outcome, coreMetrics, contexts);
 
         if (!m_httpClient->IsRequestProcessingEnabled())
@@ -397,28 +397,28 @@ HttpResponseOutcome AWSClient::AttemptExhaustively(const Aws::Http::URI& uri,
             break;
         }
 
-        // Adjust region 
-        bool retryWithCorrectRegion = false; 
-        HttpResponseCode httpResponseCode = outcome.GetError().GetResponseCode(); 
-        if (httpResponseCode == HttpResponseCode::MOVED_PERMANENTLY ||  // 301 
-            httpResponseCode == HttpResponseCode::TEMPORARY_REDIRECT || // 307 
-            httpResponseCode == HttpResponseCode::BAD_REQUEST ||        // 400 
-            httpResponseCode == HttpResponseCode::FORBIDDEN)            // 403 
-        { 
-            regionFromResponse = GetErrorMarshaller()->ExtractRegion(outcome.GetError()); 
-            if (m_region == Aws::Region::AWS_GLOBAL && !regionFromResponse.empty() && regionFromResponse != signerRegion) 
-            { 
-                signerRegion = regionFromResponse.c_str(); 
-                retryWithCorrectRegion = true; 
-            } 
-        } 
- 
+        // Adjust region
+        bool retryWithCorrectRegion = false;
+        HttpResponseCode httpResponseCode = outcome.GetError().GetResponseCode();
+        if (httpResponseCode == HttpResponseCode::MOVED_PERMANENTLY ||  // 301
+            httpResponseCode == HttpResponseCode::TEMPORARY_REDIRECT || // 307
+            httpResponseCode == HttpResponseCode::BAD_REQUEST ||        // 400
+            httpResponseCode == HttpResponseCode::FORBIDDEN)            // 403
+        {
+            regionFromResponse = GetErrorMarshaller()->ExtractRegion(outcome.GetError());
+            if (m_region == Aws::Region::AWS_GLOBAL && !regionFromResponse.empty() && regionFromResponse != signerRegion)
+            {
+                signerRegion = regionFromResponse.c_str();
+                retryWithCorrectRegion = true;
+            }
+        }
+
         long sleepMillis = m_retryStrategy->CalculateDelayBeforeNextRetry(outcome.GetError(), retries);
         //AdjustClockSkew returns true means clock skew was the problem and skew was adjusted, false otherwise.
-        //sleep if clock skew and region was NOT the problem. AdjustClockSkew may update error inside outcome. 
-        bool shouldSleep = !AdjustClockSkew(outcome, signerName) && !retryWithCorrectRegion; 
+        //sleep if clock skew and region was NOT the problem. AdjustClockSkew may update error inside outcome.
+        bool shouldSleep = !AdjustClockSkew(outcome, signerName) && !retryWithCorrectRegion;
 
-        if (!retryWithCorrectRegion && !m_retryStrategy->ShouldRetry(outcome.GetError(), retries)) 
+        if (!retryWithCorrectRegion && !m_retryStrategy->ShouldRetry(outcome.GetError(), retries))
         {
             break;
         }
@@ -429,23 +429,23 @@ HttpResponseOutcome AWSClient::AttemptExhaustively(const Aws::Http::URI& uri,
         {
             m_httpClient->RetryRequestSleep(std::chrono::milliseconds(sleepMillis));
         }
- 
-        Aws::Http::URI newUri = uri; 
-        Aws::String newEndpoint = GetErrorMarshaller()->ExtractEndpoint(outcome.GetError()); 
-        if (!newEndpoint.empty()) 
-        { 
-            newUri.SetAuthority(newEndpoint); 
-        } 
-        httpRequest = CreateHttpRequest(newUri, method, Aws::Utils::Stream::DefaultResponseStreamFactoryMethod); 
- 
-        httpRequest->SetHeaderValue(Http::SDK_INVOCATION_ID_HEADER, invocationId); 
-        if (serverTime.WasParseSuccessful() && serverTime != DateTime()) 
-        { 
-            requestInfo.ttl = DateTime::Now() + clockSkew + std::chrono::milliseconds(m_requestTimeoutMs); 
-        } 
-        requestInfo.attempt ++; 
-        requestInfo.maxAttempts = m_retryStrategy->GetMaxAttempts(); 
-        httpRequest->SetHeaderValue(Http::SDK_REQUEST_HEADER, requestInfo); 
+
+        Aws::Http::URI newUri = uri;
+        Aws::String newEndpoint = GetErrorMarshaller()->ExtractEndpoint(outcome.GetError());
+        if (!newEndpoint.empty())
+        {
+            newUri.SetAuthority(newEndpoint);
+        }
+        httpRequest = CreateHttpRequest(newUri, method, Aws::Utils::Stream::DefaultResponseStreamFactoryMethod);
+
+        httpRequest->SetHeaderValue(Http::SDK_INVOCATION_ID_HEADER, invocationId);
+        if (serverTime.WasParseSuccessful() && serverTime != DateTime())
+        {
+            requestInfo.ttl = DateTime::Now() + clockSkew + std::chrono::milliseconds(m_requestTimeoutMs);
+        }
+        requestInfo.attempt ++;
+        requestInfo.maxAttempts = m_retryStrategy->GetMaxAttempts();
+        httpRequest->SetHeaderValue(Http::SDK_REQUEST_HEADER, requestInfo);
         Aws::Monitoring::OnRequestRetry(this->GetServiceClientName(), requestName, httpRequest, contexts);
     }
     Aws::Monitoring::OnFinish(this->GetServiceClientName(), requestName, httpRequest, contexts);
@@ -454,29 +454,29 @@ HttpResponseOutcome AWSClient::AttemptExhaustively(const Aws::Http::URI& uri,
 
 static bool DoesResponseGenerateError(const std::shared_ptr<HttpResponse>& response)
 {
-    if (response->HasClientError()) return true; 
+    if (response->HasClientError()) return true;
 
     int responseCode = static_cast<int>(response->GetResponseCode());
     return responseCode < SUCCESS_RESPONSE_MIN || responseCode > SUCCESS_RESPONSE_MAX;
 
 }
 
-HttpResponseOutcome AWSClient::AttemptOneRequest(const std::shared_ptr<HttpRequest>& httpRequest, const Aws::AmazonWebServiceRequest& request, 
-    const char* signerName, const char* signerRegionOverride, const char* signerServiceNameOverride) const 
+HttpResponseOutcome AWSClient::AttemptOneRequest(const std::shared_ptr<HttpRequest>& httpRequest, const Aws::AmazonWebServiceRequest& request,
+    const char* signerName, const char* signerRegionOverride, const char* signerServiceNameOverride) const
 {
     BuildHttpRequest(request, httpRequest);
     auto signer = GetSignerByName(signerName);
-    if (!signer->SignRequest(*httpRequest, signerRegionOverride, signerServiceNameOverride, request.SignBody())) 
+    if (!signer->SignRequest(*httpRequest, signerRegionOverride, signerServiceNameOverride, request.SignBody()))
     {
         AWS_LOGSTREAM_ERROR(AWS_CLIENT_LOG_TAG, "Request signing failed. Returning error.");
         return HttpResponseOutcome(AWSError<CoreErrors>(CoreErrors::CLIENT_SIGNING_FAILURE, "", "SDK failed to sign the request", false/*retryable*/));
     }
 
-    if (request.GetRequestSignedHandler()) 
-    { 
-        request.GetRequestSignedHandler()(*httpRequest); 
-    } 
- 
+    if (request.GetRequestSignedHandler())
+    {
+        request.GetRequestSignedHandler()(*httpRequest);
+    }
+
     AWS_LOGSTREAM_DEBUG(AWS_CLIENT_LOG_TAG, "Request Successfully signed");
     std::shared_ptr<HttpResponse> httpResponse(
         m_httpClient->MakeRequest(httpRequest, m_readRateLimiter.get(), m_writeRateLimiter.get()));
@@ -484,22 +484,22 @@ HttpResponseOutcome AWSClient::AttemptOneRequest(const std::shared_ptr<HttpReque
     if (DoesResponseGenerateError(httpResponse))
     {
         AWS_LOGSTREAM_DEBUG(AWS_CLIENT_LOG_TAG, "Request returned error. Attempting to generate appropriate error codes from response");
-        auto error = BuildAWSError(httpResponse); 
-        return HttpResponseOutcome(std::move(error)); 
+        auto error = BuildAWSError(httpResponse);
+        return HttpResponseOutcome(std::move(error));
     }
 
     AWS_LOGSTREAM_DEBUG(AWS_CLIENT_LOG_TAG, "Request returned successful response.");
 
-    return HttpResponseOutcome(std::move(httpResponse)); 
+    return HttpResponseOutcome(std::move(httpResponse));
 }
 
-HttpResponseOutcome AWSClient::AttemptOneRequest(const std::shared_ptr<HttpRequest>& httpRequest, 
-    const char* signerName, const char* requestName, const char* signerRegionOverride, const char* signerServiceNameOverride) const 
+HttpResponseOutcome AWSClient::AttemptOneRequest(const std::shared_ptr<HttpRequest>& httpRequest,
+    const char* signerName, const char* requestName, const char* signerRegionOverride, const char* signerServiceNameOverride) const
 {
     AWS_UNREFERENCED_PARAM(requestName);
 
     auto signer = GetSignerByName(signerName);
-    if (!signer->SignRequest(*httpRequest, signerRegionOverride, signerServiceNameOverride, true)) 
+    if (!signer->SignRequest(*httpRequest, signerRegionOverride, signerServiceNameOverride, true))
     {
         AWS_LOGSTREAM_ERROR(AWS_CLIENT_LOG_TAG, "Request signing failed. Returning error.");
         return HttpResponseOutcome(AWSError<CoreErrors>(CoreErrors::CLIENT_SIGNING_FAILURE, "", "SDK failed to sign the request", false/*retryable*/));
@@ -515,23 +515,23 @@ HttpResponseOutcome AWSClient::AttemptOneRequest(const std::shared_ptr<HttpReque
     if (DoesResponseGenerateError(httpResponse))
     {
         AWS_LOGSTREAM_DEBUG(AWS_CLIENT_LOG_TAG, "Request returned error. Attempting to generate appropriate error codes from response");
-        auto error = BuildAWSError(httpResponse); 
-        return HttpResponseOutcome(std::move(error)); 
+        auto error = BuildAWSError(httpResponse);
+        return HttpResponseOutcome(std::move(error));
     }
 
     AWS_LOGSTREAM_DEBUG(AWS_CLIENT_LOG_TAG, "Request returned successful response.");
 
-    return HttpResponseOutcome(std::move(httpResponse)); 
+    return HttpResponseOutcome(std::move(httpResponse));
 }
 
 StreamOutcome AWSClient::MakeRequestWithUnparsedResponse(const Aws::Http::URI& uri,
     const Aws::AmazonWebServiceRequest& request,
     Http::HttpMethod method,
-    const char* signerName, 
-    const char* signerRegionOverride, 
-    const char* signerServiceNameOverride) const 
+    const char* signerName,
+    const char* signerRegionOverride,
+    const char* signerServiceNameOverride) const
 {
-    HttpResponseOutcome httpResponseOutcome = AttemptExhaustively(uri, request, method, signerName, signerRegionOverride, signerServiceNameOverride); 
+    HttpResponseOutcome httpResponseOutcome = AttemptExhaustively(uri, request, method, signerName, signerRegionOverride, signerServiceNameOverride);
     if (httpResponseOutcome.IsSuccess())
     {
         return StreamOutcome(AmazonWebServiceResult<Stream::ResponseStream>(
@@ -539,17 +539,17 @@ StreamOutcome AWSClient::MakeRequestWithUnparsedResponse(const Aws::Http::URI& u
             httpResponseOutcome.GetResult()->GetHeaders(), httpResponseOutcome.GetResult()->GetResponseCode()));
     }
 
-    return StreamOutcome(std::move(httpResponseOutcome)); 
+    return StreamOutcome(std::move(httpResponseOutcome));
 }
 
-StreamOutcome AWSClient::MakeRequestWithUnparsedResponse(const Aws::Http::URI& uri, 
-    Http::HttpMethod method, 
-    const char* signerName, 
-    const char* requestName, 
-    const char* signerRegionOverride, 
-    const char* signerServiceNameOverride) const 
+StreamOutcome AWSClient::MakeRequestWithUnparsedResponse(const Aws::Http::URI& uri,
+    Http::HttpMethod method,
+    const char* signerName,
+    const char* requestName,
+    const char* signerRegionOverride,
+    const char* signerServiceNameOverride) const
 {
-    HttpResponseOutcome httpResponseOutcome = AttemptExhaustively(uri, method, signerName, requestName, signerRegionOverride, signerServiceNameOverride); 
+    HttpResponseOutcome httpResponseOutcome = AttemptExhaustively(uri, method, signerName, requestName, signerRegionOverride, signerServiceNameOverride);
     if (httpResponseOutcome.IsSuccess())
     {
         return StreamOutcome(AmazonWebServiceResult<Stream::ResponseStream>(
@@ -557,39 +557,39 @@ StreamOutcome AWSClient::MakeRequestWithUnparsedResponse(const Aws::Http::URI& u
             httpResponseOutcome.GetResult()->GetHeaders(), httpResponseOutcome.GetResult()->GetResponseCode()));
     }
 
-    return StreamOutcome(std::move(httpResponseOutcome)); 
+    return StreamOutcome(std::move(httpResponseOutcome));
 }
 
 XmlOutcome AWSXMLClient::MakeRequestWithEventStream(const Aws::Http::URI& uri,
     const Aws::AmazonWebServiceRequest& request,
     Http::HttpMethod method,
-    const char* signerName, 
-    const char* signerRegionOverride, 
-    const char* signerServiceNameOverride) const 
+    const char* signerName,
+    const char* signerRegionOverride,
+    const char* signerServiceNameOverride) const
 {
-    HttpResponseOutcome httpOutcome = AttemptExhaustively(uri, request, method, signerName, signerRegionOverride, signerServiceNameOverride); 
+    HttpResponseOutcome httpOutcome = AttemptExhaustively(uri, request, method, signerName, signerRegionOverride, signerServiceNameOverride);
     if (httpOutcome.IsSuccess())
     {
         return XmlOutcome(AmazonWebServiceResult<XmlDocument>(XmlDocument(), httpOutcome.GetResult()->GetHeaders()));
     }
 
-    return XmlOutcome(std::move(httpOutcome)); 
+    return XmlOutcome(std::move(httpOutcome));
 }
 
-XmlOutcome AWSXMLClient::MakeRequestWithEventStream(const Aws::Http::URI& uri, 
-    Http::HttpMethod method, 
-    const char* signerName, 
-    const char* requestName, 
-    const char* signerRegionOverride, 
-    const char* signerServiceNameOverride) const 
+XmlOutcome AWSXMLClient::MakeRequestWithEventStream(const Aws::Http::URI& uri,
+    Http::HttpMethod method,
+    const char* signerName,
+    const char* requestName,
+    const char* signerRegionOverride,
+    const char* signerServiceNameOverride) const
 {
-    HttpResponseOutcome httpOutcome = AttemptExhaustively(uri, method, signerName, requestName, signerRegionOverride, signerServiceNameOverride); 
+    HttpResponseOutcome httpOutcome = AttemptExhaustively(uri, method, signerName, requestName, signerRegionOverride, signerServiceNameOverride);
     if (httpOutcome.IsSuccess())
     {
         return XmlOutcome(AmazonWebServiceResult<XmlDocument>(XmlDocument(), httpOutcome.GetResult()->GetHeaders()));
     }
 
-    return XmlOutcome(std::move(httpOutcome)); 
+    return XmlOutcome(std::move(httpOutcome));
 }
 
 void AWSClient::AddHeadersToRequest(const std::shared_ptr<Aws::Http::HttpRequest>& httpRequest,
@@ -604,7 +604,7 @@ void AWSClient::AddHeadersToRequest(const std::shared_ptr<Aws::Http::HttpRequest
 }
 
 void AWSClient::AddContentBodyToRequest(const std::shared_ptr<Aws::Http::HttpRequest>& httpRequest,
-    const std::shared_ptr<Aws::IOStream>& body, bool needsContentMd5, bool isChunked) const 
+    const std::shared_ptr<Aws::IOStream>& body, bool needsContentMd5, bool isChunked) const
 {
     httpRequest->AddContentBody(body);
 
@@ -616,8 +616,8 @@ void AWSClient::AddContentBodyToRequest(const std::shared_ptr<Aws::Http::HttpReq
         AWS_LOGSTREAM_TRACE(AWS_CLIENT_LOG_TAG, "No content body, content-length headers");
 
         if(httpRequest->GetMethod() == HttpMethod::HTTP_POST || httpRequest->GetMethod() == HttpMethod::HTTP_PUT)
-        { 
-            httpRequest->SetHeaderValue(Http::CONTENT_LENGTH_HEADER, "0"); 
+        {
+            httpRequest->SetHeaderValue(Http::CONTENT_LENGTH_HEADER, "0");
         }
         else
         {
@@ -625,20 +625,20 @@ void AWSClient::AddContentBodyToRequest(const std::shared_ptr<Aws::Http::HttpReq
         }
     }
 
-    //Add transfer-encoding:chunked to header 
-    if (body && isChunked) 
-    { 
-        httpRequest->SetTransferEncoding(CHUNKED_VALUE); 
-    } 
+    //Add transfer-encoding:chunked to header
+    if (body && isChunked)
+    {
+        httpRequest->SetTransferEncoding(CHUNKED_VALUE);
+    }
     //in the scenario where we are adding a content body as a stream, the request object likely already
     //has a content-length header set and we don't want to seek the stream just to find this information.
-    else if (body && !httpRequest->HasHeader(Http::CONTENT_LENGTH_HEADER)) 
+    else if (body && !httpRequest->HasHeader(Http::CONTENT_LENGTH_HEADER))
     {
-        if (!m_httpClient->SupportsChunkedTransferEncoding()) 
-        { 
-            AWS_LOGSTREAM_WARN(AWS_CLIENT_LOG_TAG, "This http client doesn't support transfer-encoding:chunked. " << 
-                                                   "The request may fail if it's not a seekable stream."); 
-        } 
+        if (!m_httpClient->SupportsChunkedTransferEncoding())
+        {
+            AWS_LOGSTREAM_WARN(AWS_CLIENT_LOG_TAG, "This http client doesn't support transfer-encoding:chunked. " <<
+                                                   "The request may fail if it's not a seekable stream.");
+        }
         AWS_LOGSTREAM_TRACE(AWS_CLIENT_LOG_TAG, "Found body, but content-length has not been set, attempting to compute content-length");
         body->seekg(0, body->end);
         auto streamSize = body->tellg();
@@ -682,20 +682,20 @@ Aws::String Aws::Client::GetAuthorizationHeader(const Aws::Http::HttpRequest& ht
     return authHeader.substr(signaturePosition + strlen(Aws::Auth::SIGNATURE) + 1);
 }
 
-void AWSClient::BuildHttpRequest(const Aws::AmazonWebServiceRequest& request, 
-    const std::shared_ptr<HttpRequest>& httpRequest) const 
+void AWSClient::BuildHttpRequest(const Aws::AmazonWebServiceRequest& request,
+    const std::shared_ptr<HttpRequest>& httpRequest) const
 {
-    //do headers first since the request likely will set content-length as it's own header. 
+    //do headers first since the request likely will set content-length as it's own header.
     AddHeadersToRequest(httpRequest, request.GetHeaders());
 
-    if (request.IsEventStreamRequest()) 
+    if (request.IsEventStreamRequest())
     {
-        httpRequest->AddContentBody(request.GetBody()); 
+        httpRequest->AddContentBody(request.GetBody());
+    }
+    else
+    {
+        AddContentBodyToRequest(httpRequest, request.GetBody(), request.ShouldComputeContentMd5(), request.IsStreaming() && request.IsChunked() && m_httpClient->SupportsChunkedTransferEncoding());
     }
-    else 
-    { 
-        AddContentBodyToRequest(httpRequest, request.GetBody(), request.ShouldComputeContentMd5(), request.IsStreaming() && request.IsChunked() && m_httpClient->SupportsChunkedTransferEncoding()); 
-    } 
 
     // Pass along handlers for processing data sent/received in bytes
     httpRequest->SetDataReceivedEventHandler(request.GetDataReceivedEventHandler());
@@ -738,34 +738,34 @@ Aws::String AWSClient::GeneratePresignedUrl(URI& uri, HttpMethod method, const A
     return {};
 }
 
-Aws::String AWSClient::GeneratePresignedUrl(URI& uri, HttpMethod method, const char* region, long long expirationInSeconds) const 
-{ 
-    std::shared_ptr<HttpRequest> request = CreateHttpRequest(uri, method, Aws::Utils::Stream::DefaultResponseStreamFactoryMethod); 
-    auto signer = GetSignerByName(Aws::Auth::SIGV4_SIGNER); 
-    if (signer->PresignRequest(*request, region, expirationInSeconds)) 
-    { 
-        return request->GetURIString(); 
-    } 
- 
-    return {}; 
-} 
- 
-Aws::String AWSClient::GeneratePresignedUrl(URI& uri, HttpMethod method, const char* region, const Aws::Http::HeaderValueCollection& customizedHeaders, long long expirationInSeconds) 
-{ 
-    std::shared_ptr<HttpRequest> request = CreateHttpRequest(uri, method, Aws::Utils::Stream::DefaultResponseStreamFactoryMethod); 
-    for (const auto& it: customizedHeaders) 
-    { 
-        request->SetHeaderValue(it.first.c_str(), it.second); 
-    } 
-    auto signer = GetSignerByName(Aws::Auth::SIGV4_SIGNER); 
-    if (signer->PresignRequest(*request, region, expirationInSeconds)) 
-    { 
-        return request->GetURIString(); 
-    } 
- 
-    return {}; 
-} 
- 
+Aws::String AWSClient::GeneratePresignedUrl(URI& uri, HttpMethod method, const char* region, long long expirationInSeconds) const
+{
+    std::shared_ptr<HttpRequest> request = CreateHttpRequest(uri, method, Aws::Utils::Stream::DefaultResponseStreamFactoryMethod);
+    auto signer = GetSignerByName(Aws::Auth::SIGV4_SIGNER);
+    if (signer->PresignRequest(*request, region, expirationInSeconds))
+    {
+        return request->GetURIString();
+    }
+
+    return {};
+}
+
+Aws::String AWSClient::GeneratePresignedUrl(URI& uri, HttpMethod method, const char* region, const Aws::Http::HeaderValueCollection& customizedHeaders, long long expirationInSeconds)
+{
+    std::shared_ptr<HttpRequest> request = CreateHttpRequest(uri, method, Aws::Utils::Stream::DefaultResponseStreamFactoryMethod);
+    for (const auto& it: customizedHeaders)
+    {
+        request->SetHeaderValue(it.first.c_str(), it.second);
+    }
+    auto signer = GetSignerByName(Aws::Auth::SIGV4_SIGNER);
+    if (signer->PresignRequest(*request, region, expirationInSeconds))
+    {
+        return request->GetURIString();
+    }
+
+    return {};
+}
+
 Aws::String AWSClient::GeneratePresignedUrl(Aws::Http::URI& uri, Aws::Http::HttpMethod method, const char* region, const char* serviceName, long long expirationInSeconds) const
 {
     std::shared_ptr<HttpRequest> request = CreateHttpRequest(uri, method, Aws::Utils::Stream::DefaultResponseStreamFactoryMethod);
@@ -778,15 +778,15 @@ Aws::String AWSClient::GeneratePresignedUrl(Aws::Http::URI& uri, Aws::Http::Http
     return {};
 }
 
-Aws::String AWSClient::GeneratePresignedUrl(Aws::Http::URI& uri, Aws::Http::HttpMethod method, const char* region, const char* serviceName, const Aws::Http::HeaderValueCollection& customizedHeaders, long long expirationInSeconds) 
+Aws::String AWSClient::GeneratePresignedUrl(Aws::Http::URI& uri, Aws::Http::HttpMethod method, const char* region, const char* serviceName, const Aws::Http::HeaderValueCollection& customizedHeaders, long long expirationInSeconds)
 {
     std::shared_ptr<HttpRequest> request = CreateHttpRequest(uri, method, Aws::Utils::Stream::DefaultResponseStreamFactoryMethod);
-    for (const auto& it: customizedHeaders) 
-    { 
-        request->SetHeaderValue(it.first.c_str(), it.second); 
-    } 
+    for (const auto& it: customizedHeaders)
+    {
+        request->SetHeaderValue(it.first.c_str(), it.second);
+    }
     auto signer = GetSignerByName(Aws::Auth::SIGV4_SIGNER);
-    if (signer->PresignRequest(*request, region, serviceName, expirationInSeconds)) 
+    if (signer->PresignRequest(*request, region, serviceName, expirationInSeconds))
     {
         return request->GetURIString();
     }
@@ -841,7 +841,7 @@ std::shared_ptr<Aws::Http::HttpRequest> AWSClient::ConvertToRequestForPresigning
 {
     request.PutToPresignedUrl(uri);
     std::shared_ptr<HttpRequest> httpRequest = CreateHttpRequest(uri, method, Aws::Utils::Stream::DefaultResponseStreamFactoryMethod);
- 
+
     for (auto& param : extraParams)
     {
         httpRequest->AddQueryStringParameter(param.first.c_str(), param.second);
@@ -875,14 +875,14 @@ AWSJsonClient::AWSJsonClient(const Aws::Client::ClientConfiguration& configurati
 JsonOutcome AWSJsonClient::MakeRequest(const Aws::Http::URI& uri,
     const Aws::AmazonWebServiceRequest& request,
     Http::HttpMethod method,
-    const char* signerName, 
-    const char* signerRegionOverride, 
-    const char* signerServiceNameOverride) const 
+    const char* signerName,
+    const char* signerRegionOverride,
+    const char* signerServiceNameOverride) const
 {
-    HttpResponseOutcome httpOutcome(BASECLASS::AttemptExhaustively(uri, request, method, signerName, signerRegionOverride, signerServiceNameOverride)); 
+    HttpResponseOutcome httpOutcome(BASECLASS::AttemptExhaustively(uri, request, method, signerName, signerRegionOverride, signerServiceNameOverride));
     if (!httpOutcome.IsSuccess())
     {
-        return JsonOutcome(std::move(httpOutcome)); 
+        return JsonOutcome(std::move(httpOutcome));
     }
 
     if (httpOutcome.GetResult()->GetResponseBody().tellp() > 0)
@@ -898,14 +898,14 @@ JsonOutcome AWSJsonClient::MakeRequest(const Aws::Http::URI& uri,
 JsonOutcome AWSJsonClient::MakeRequest(const Aws::Http::URI& uri,
     Http::HttpMethod method,
     const char* signerName,
-    const char* requestName, 
-    const char* signerRegionOverride, 
-    const char* signerServiceNameOverride) const 
+    const char* requestName,
+    const char* signerRegionOverride,
+    const char* signerServiceNameOverride) const
 {
-    HttpResponseOutcome httpOutcome(BASECLASS::AttemptExhaustively(uri, method, signerName, requestName, signerRegionOverride, signerServiceNameOverride)); 
+    HttpResponseOutcome httpOutcome(BASECLASS::AttemptExhaustively(uri, method, signerName, requestName, signerRegionOverride, signerServiceNameOverride));
     if (!httpOutcome.IsSuccess())
     {
-        return JsonOutcome(std::move(httpOutcome)); 
+        return JsonOutcome(std::move(httpOutcome));
     }
 
     if (httpOutcome.GetResult()->GetResponseBody().tellp() > 0)
@@ -933,13 +933,13 @@ JsonOutcome AWSJsonClient::MakeEventStreamRequest(std::shared_ptr<Aws::Http::Htt
     if (DoesResponseGenerateError(httpResponse))
     {
         AWS_LOGSTREAM_DEBUG(AWS_CLIENT_LOG_TAG, "Request returned error. Attempting to generate appropriate error codes from response");
-        auto error = BuildAWSError(httpResponse); 
-        return JsonOutcome(std::move(error)); 
+        auto error = BuildAWSError(httpResponse);
+        return JsonOutcome(std::move(error));
     }
 
     AWS_LOGSTREAM_DEBUG(AWS_CLIENT_LOG_TAG, "Request returned successful response.");
 
-    HttpResponseOutcome httpOutcome(std::move(httpResponse)); 
+    HttpResponseOutcome httpOutcome(std::move(httpResponse));
 
     if (httpOutcome.GetResult()->GetResponseBody().tellp() > 0)
     {
@@ -962,10 +962,10 @@ AWSError<CoreErrors> AWSJsonClient::BuildAWSError(
     const std::shared_ptr<Aws::Http::HttpResponse>& httpResponse) const
 {
     AWSError<CoreErrors> error;
-    if (httpResponse->HasClientError()) 
+    if (httpResponse->HasClientError())
     {
-        bool retryable = httpResponse->GetClientErrorType() == CoreErrors::NETWORK_CONNECTION ? true : false; 
-        error = AWSError<CoreErrors>(httpResponse->GetClientErrorType(), "", httpResponse->GetClientErrorMessage(), retryable); 
+        bool retryable = httpResponse->GetClientErrorType() == CoreErrors::NETWORK_CONNECTION ? true : false;
+        error = AWSError<CoreErrors>(httpResponse->GetClientErrorType(), "", httpResponse->GetClientErrorMessage(), retryable);
     }
     else if (!httpResponse->GetResponseBody() || httpResponse->GetResponseBody().tellp() < 1)
     {
@@ -985,7 +985,7 @@ AWSError<CoreErrors> AWSJsonClient::BuildAWSError(
 
     error.SetResponseHeaders(httpResponse->GetHeaders());
     error.SetResponseCode(httpResponse->GetResponseCode());
-    error.SetRemoteHostIpAddress(httpResponse->GetOriginatingRequest().GetResolvedRemoteHost()); 
+    error.SetRemoteHostIpAddress(httpResponse->GetOriginatingRequest().GetResolvedRemoteHost());
     AWS_LOGSTREAM_ERROR(AWS_CLIENT_LOG_TAG, error);
     return error;
 }
@@ -1008,14 +1008,14 @@ AWSXMLClient::AWSXMLClient(const Aws::Client::ClientConfiguration& configuration
 XmlOutcome AWSXMLClient::MakeRequest(const Aws::Http::URI& uri,
     const Aws::AmazonWebServiceRequest& request,
     Http::HttpMethod method,
-    const char* signerName, 
-    const char* signerRegionOverride, 
-    const char* signerServiceNameOverride) const 
+    const char* signerName,
+    const char* signerRegionOverride,
+    const char* signerServiceNameOverride) const
 {
-    HttpResponseOutcome httpOutcome(BASECLASS::AttemptExhaustively(uri, request, method, signerName, signerRegionOverride, signerServiceNameOverride)); 
+    HttpResponseOutcome httpOutcome(BASECLASS::AttemptExhaustively(uri, request, method, signerName, signerRegionOverride, signerServiceNameOverride));
     if (!httpOutcome.IsSuccess())
     {
-        return XmlOutcome(std::move(httpOutcome)); 
+        return XmlOutcome(std::move(httpOutcome));
     }
 
     if (httpOutcome.GetResult()->GetResponseBody().tellp() > 0)
@@ -1038,14 +1038,14 @@ XmlOutcome AWSXMLClient::MakeRequest(const Aws::Http::URI& uri,
 XmlOutcome AWSXMLClient::MakeRequest(const Aws::Http::URI& uri,
     Http::HttpMethod method,
     const char* signerName,
-    const char* requestName, 
-    const char* signerRegionOverride, 
-    const char* signerServiceNameOverride) const 
+    const char* requestName,
+    const char* signerRegionOverride,
+    const char* signerServiceNameOverride) const
 {
-    HttpResponseOutcome httpOutcome(BASECLASS::AttemptExhaustively(uri, method, signerName, requestName, signerRegionOverride, signerServiceNameOverride)); 
+    HttpResponseOutcome httpOutcome(BASECLASS::AttemptExhaustively(uri, method, signerName, requestName, signerRegionOverride, signerServiceNameOverride));
     if (!httpOutcome.IsSuccess())
     {
-        return XmlOutcome(std::move(httpOutcome)); 
+        return XmlOutcome(std::move(httpOutcome));
     }
 
     if (httpOutcome.GetResult()->GetResponseBody().tellp() > 0)
@@ -1061,12 +1061,12 @@ XmlOutcome AWSXMLClient::MakeRequest(const Aws::Http::URI& uri,
 AWSError<CoreErrors> AWSXMLClient::BuildAWSError(const std::shared_ptr<Http::HttpResponse>& httpResponse) const
 {
     AWSError<CoreErrors> error;
-    if (httpResponse->HasClientError()) 
+    if (httpResponse->HasClientError())
     {
-        bool retryable = httpResponse->GetClientErrorType() == CoreErrors::NETWORK_CONNECTION ? true : false; 
-        error = AWSError<CoreErrors>(httpResponse->GetClientErrorType(), "", httpResponse->GetClientErrorMessage(), retryable); 
+        bool retryable = httpResponse->GetClientErrorType() == CoreErrors::NETWORK_CONNECTION ? true : false;
+        error = AWSError<CoreErrors>(httpResponse->GetClientErrorType(), "", httpResponse->GetClientErrorMessage(), retryable);
     }
-    else if (!httpResponse->GetResponseBody() || httpResponse->GetResponseBody().tellp() < 1) 
+    else if (!httpResponse->GetResponseBody() || httpResponse->GetResponseBody().tellp() < 1)
     {
         auto responseCode = httpResponse->GetResponseCode();
         auto errorCode = GuessBodylessErrorType(responseCode);
@@ -1092,7 +1092,7 @@ AWSError<CoreErrors> AWSXMLClient::BuildAWSError(const std::shared_ptr<Http::Htt
 
     error.SetResponseHeaders(httpResponse->GetHeaders());
     error.SetResponseCode(httpResponse->GetResponseCode());
-    error.SetRemoteHostIpAddress(httpResponse->GetOriginatingRequest().GetResolvedRemoteHost()); 
+    error.SetRemoteHostIpAddress(httpResponse->GetOriginatingRequest().GetResolvedRemoteHost());
     AWS_LOGSTREAM_ERROR(AWS_CLIENT_LOG_TAG, error);
     return error;
 }