aboutsummaryrefslogtreecommitdiffstats
path: root/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/client
diff options
context:
space:
mode:
authorDevtools Arcadia <arcadia-devtools@yandex-team.ru>2022-02-07 18:08:42 +0300
committerDevtools Arcadia <arcadia-devtools@mous.vla.yp-c.yandex.net>2022-02-07 18:08:42 +0300
commit1110808a9d39d4b808aef724c861a2e1a38d2a69 (patch)
treee26c9fed0de5d9873cce7e00bc214573dc2195b7 /contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/client
downloadydb-1110808a9d39d4b808aef724c861a2e1a38d2a69.tar.gz
intermediate changes
ref:cde9a383711a11544ce7e107a78147fb96cc4029
Diffstat (limited to 'contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/client')
-rw-r--r--contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/client/AWSClient.cpp1098
-rw-r--r--contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/client/AWSErrorMarshaller.cpp180
-rw-r--r--contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/client/AsyncCallerContext.cpp16
-rw-r--r--contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/client/ClientConfiguration.cpp160
-rw-r--r--contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/client/CoreErrors.cpp151
-rw-r--r--contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/client/DefaultRetryStrategy.cpp32
-rw-r--r--contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/client/RetryStrategy.cpp102
-rw-r--r--contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/client/SpecifiedRetryableErrorsRetryStrategy.cpp28
8 files changed, 1767 insertions, 0 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
new file mode 100644
index 0000000000..e1ff064840
--- /dev/null
+++ b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/client/AWSClient.cpp
@@ -0,0 +1,1098 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/core/client/AWSClient.h>
+#include <aws/core/AmazonWebServiceRequest.h>
+#include <aws/core/auth/AWSAuthSigner.h>
+#include <aws/core/auth/AWSAuthSignerProvider.h>
+#include <aws/core/client/AWSError.h>
+#include <aws/core/client/AWSErrorMarshaller.h>
+#include <aws/core/client/ClientConfiguration.h>
+#include <aws/core/client/CoreErrors.h>
+#include <aws/core/client/RetryStrategy.h>
+#include <aws/core/http/HttpClient.h>
+#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/utils/stream/ResponseStream.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/core/utils/Outcome.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+#include <aws/core/utils/logging/LogMacros.h>
+#include <aws/core/Globals.h>
+#include <aws/core/utils/EnumParseOverflowContainer.h>
+#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/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 <cstring>
+#include <cassert>
+
+using namespace Aws;
+using namespace Aws::Client;
+using namespace Aws::Http;
+using namespace Aws::Utils;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils::Xml;
+
+static const int SUCCESS_RESPONSE_MIN = 200;
+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);
+//-4 Minutes
+static const std::chrono::milliseconds TIME_DIFF_MIN = std::chrono::minutes(-4);
+
+static CoreErrors GuessBodylessErrorType(Aws::Http::HttpResponseCode responseCode)
+{
+ switch (responseCode)
+ {
+ case HttpResponseCode::FORBIDDEN:
+ case HttpResponseCode::UNAUTHORIZED:
+ return CoreErrors::ACCESS_DENIED;
+ case HttpResponseCode::NOT_FOUND:
+ 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();
+ }
+};
+
+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_httpClient(CreateHttpClient(configuration)),
+ m_signerProvider(Aws::MakeUnique<Aws::Auth::DefaultAuthSignerProvider>(AWS_CLIENT_LOG_TAG, signer)),
+ m_errorMarshaller(errorMarshaller),
+ m_retryStrategy(configuration.retryStrategy),
+ m_writeRateLimiter(configuration.writeRateLimiter),
+ m_readRateLimiter(configuration.readRateLimiter),
+ m_userAgent(configuration.userAgent),
+ m_customizedUserAgent(!m_userAgent.empty()),
+ m_hash(Aws::Utils::Crypto::CreateMD5Implementation()),
+ m_requestTimeoutMs(configuration.requestTimeoutMs),
+ m_enableClockSkewAdjustment(configuration.enableClockSkewAdjustment)
+{
+ 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_httpClient(CreateHttpClient(configuration)),
+ m_signerProvider(signerProvider),
+ m_errorMarshaller(errorMarshaller),
+ m_retryStrategy(configuration.retryStrategy),
+ m_writeRateLimiter(configuration.writeRateLimiter),
+ m_readRateLimiter(configuration.readRateLimiter),
+ m_userAgent(configuration.userAgent),
+ m_customizedUserAgent(!m_userAgent.empty()),
+ m_hash(Aws::Utils::Crypto::CreateMD5Implementation()),
+ m_requestTimeoutMs(configuration.requestTimeoutMs),
+ m_enableClockSkewAdjustment(configuration.enableClockSkewAdjustment)
+{
+ 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::DisableRequestProcessing()
+{
+ m_httpClient->DisableRequestProcessing();
+}
+
+void AWSClient::EnableRequestProcessing()
+{
+ m_httpClient->EnableRequestProcessing();
+}
+
+Aws::Client::AWSAuthSigner* AWSClient::GetSignerByName(const char* name) const
+{
+ const auto& signer = m_signerProvider->GetSigner(name);
+ 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();
+ }
+}
+
+bool AWSClient::AdjustClockSkew(HttpResponseOutcome& outcome, const char* signerName) const
+{
+ if (m_enableClockSkewAdjustment)
+ {
+ auto signer = GetSignerByName(signerName);
+ //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());
+ const auto signingTimestamp = signer->GetSigningTimestamp();
+ if (!serverTime.WasParseSuccessful() || serverTime == DateTime())
+ {
+ AWS_LOGSTREAM_DEBUG(AWS_CLIENT_LOG_TAG, "Date header was not found in the response, can't attempt to detect clock skew");
+ return false;
+ }
+
+ AWS_LOGSTREAM_DEBUG(AWS_CLIENT_LOG_TAG, "Server time is " << serverTime.ToGmtString(DateFormat::RFC822) << ", while client time is " << DateTime::Now().ToGmtString(DateFormat::RFC822));
+ auto diff = DateTime::Diff(serverTime, signingTimestamp);
+ //only try again if clock skew was the cause of the error.
+ if (diff >= TIME_DIFF_MAX || diff <= TIME_DIFF_MIN)
+ {
+ 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(
+ outcome.GetError().GetErrorType(), outcome.GetError().GetExceptionName(), outcome.GetError().GetMessage(), true);
+ newError.SetResponseHeaders(outcome.GetError().GetResponseHeaders());
+ newError.SetResponseCode(outcome.GetError().GetResponseCode());
+ outcome = std::move(newError);
+ return true;
+ }
+ }
+ return false;
+}
+
+HttpResponseOutcome AWSClient::AttemptExhaustively(const Aws::Http::URI& uri,
+ const Aws::AmazonWebServiceRequest& request,
+ HttpMethod method,
+ 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*/));
+ }
+ std::shared_ptr<HttpRequest> httpRequest(CreateHttpRequest(uri, method, request.GetResponseStreamFactory()));
+ HttpResponseOutcome outcome;
+ 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);
+
+ 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);
+ }
+ coreMetrics.httpClientMetrics = httpRequest->GetRequestMetrics();
+ if (outcome.IsSuccess())
+ {
+ Aws::Monitoring::OnRequestSucceeded(this->GetServiceClientName(), request.GetServiceRequestName(), httpRequest, outcome, coreMetrics, contexts);
+ AWS_LOGSTREAM_TRACE(AWS_CLIENT_LOG_TAG, "Request successful returning.");
+ break;
+ }
+ lastError = outcome.GetError();
+
+ 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())
+ {
+ AWS_LOGSTREAM_TRACE(AWS_CLIENT_LOG_TAG, "Request was cancelled externally.");
+ 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;
+ }
+ }
+
+ 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;
+
+ if (!retryWithCorrectRegion && !m_retryStrategy->ShouldRetry(outcome.GetError(), retries))
+ {
+ break;
+ }
+
+ AWS_LOGSTREAM_WARN(AWS_CLIENT_LOG_TAG, "Request failed, now waiting " << sleepMillis << " ms before attempting again.");
+ if(request.GetBody())
+ {
+ request.GetBody()->clear();
+ request.GetBody()->seekg(0);
+ }
+
+ if (request.GetRequestRetryHandler())
+ {
+ request.GetRequestRetryHandler()(request);
+ }
+
+ if (shouldSleep)
+ {
+ 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::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
+{
+ 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;
+ 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);
+
+ 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);
+ }
+ coreMetrics.httpClientMetrics = httpRequest->GetRequestMetrics();
+ if (outcome.IsSuccess())
+ {
+ Aws::Monitoring::OnRequestSucceeded(this->GetServiceClientName(), requestName, httpRequest, outcome, coreMetrics, contexts);
+ AWS_LOGSTREAM_TRACE(AWS_CLIENT_LOG_TAG, "Request successful returning.");
+ break;
+ }
+ lastError = outcome.GetError();
+
+ 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())
+ {
+ AWS_LOGSTREAM_TRACE(AWS_CLIENT_LOG_TAG, "Request was cancelled externally.");
+ 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;
+ }
+ }
+
+ 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;
+
+ if (!retryWithCorrectRegion && !m_retryStrategy->ShouldRetry(outcome.GetError(), retries))
+ {
+ break;
+ }
+
+ AWS_LOGSTREAM_WARN(AWS_CLIENT_LOG_TAG, "Request failed, now waiting " << sleepMillis << " ms before attempting again.");
+
+ if (shouldSleep)
+ {
+ 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::Monitoring::OnRequestRetry(this->GetServiceClientName(), requestName, httpRequest, contexts);
+ }
+ Aws::Monitoring::OnFinish(this->GetServiceClientName(), requestName, httpRequest, contexts);
+ return outcome;
+}
+
+static bool DoesResponseGenerateError(const std::shared_ptr<HttpResponse>& response)
+{
+ 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
+{
+ BuildHttpRequest(request, httpRequest);
+ auto signer = GetSignerByName(signerName);
+ 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);
+ }
+
+ 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()));
+
+ 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));
+ }
+
+ AWS_LOGSTREAM_DEBUG(AWS_CLIENT_LOG_TAG, "Request returned successful response.");
+
+ 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
+{
+ AWS_UNREFERENCED_PARAM(requestName);
+
+ auto signer = GetSignerByName(signerName);
+ 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*/));
+ }
+
+ //user agent and headers like that shouldn't be signed for the sake of compatibility with proxies which MAY mutate that header.
+ AddCommonHeaders(*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()));
+
+ 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));
+ }
+
+ AWS_LOGSTREAM_DEBUG(AWS_CLIENT_LOG_TAG, "Request returned successful response.");
+
+ 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
+{
+ HttpResponseOutcome httpResponseOutcome = AttemptExhaustively(uri, request, method, signerName, signerRegionOverride, signerServiceNameOverride);
+ if (httpResponseOutcome.IsSuccess())
+ {
+ return StreamOutcome(AmazonWebServiceResult<Stream::ResponseStream>(
+ httpResponseOutcome.GetResult()->SwapResponseStreamOwnership(),
+ httpResponseOutcome.GetResult()->GetHeaders(), httpResponseOutcome.GetResult()->GetResponseCode()));
+ }
+
+ 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
+{
+ HttpResponseOutcome httpResponseOutcome = AttemptExhaustively(uri, method, signerName, requestName, signerRegionOverride, signerServiceNameOverride);
+ if (httpResponseOutcome.IsSuccess())
+ {
+ return StreamOutcome(AmazonWebServiceResult<Stream::ResponseStream>(
+ httpResponseOutcome.GetResult()->SwapResponseStreamOwnership(),
+ httpResponseOutcome.GetResult()->GetHeaders(), httpResponseOutcome.GetResult()->GetResponseCode()));
+ }
+
+ 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
+{
+ 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));
+}
+
+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);
+ if (httpOutcome.IsSuccess())
+ {
+ return XmlOutcome(AmazonWebServiceResult<XmlDocument>(XmlDocument(), httpOutcome.GetResult()->GetHeaders()));
+ }
+
+ return XmlOutcome(std::move(httpOutcome));
+}
+
+void AWSClient::AddHeadersToRequest(const std::shared_ptr<Aws::Http::HttpRequest>& httpRequest,
+ const Http::HeaderValueCollection& headerValues) const
+{
+ for (auto const& headerValue : headerValues)
+ {
+ httpRequest->SetHeaderValue(headerValue.first, headerValue.second);
+ }
+
+ AddCommonHeaders(*httpRequest);
+}
+
+void AWSClient::AddContentBodyToRequest(const std::shared_ptr<Aws::Http::HttpRequest>& httpRequest,
+ const std::shared_ptr<Aws::IOStream>& body, bool needsContentMd5, bool isChunked) const
+{
+ httpRequest->AddContentBody(body);
+
+ //If there is no body, we have a content length of 0
+ //note: we also used to remove content-type, but S3 actually needs content-type on InitiateMultipartUpload and it isn't
+ //forbiden by the spec. If we start getting weird errors related to this, make sure it isn't caused by this removal.
+ if (!body)
+ {
+ 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");
+ }
+ else
+ {
+ httpRequest->DeleteHeader(Http::CONTENT_LENGTH_HEADER);
+ }
+ }
+
+ //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))
+ {
+ 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();
+ body->seekg(0, body->beg);
+ Aws::StringStream ss;
+ ss << streamSize;
+ httpRequest->SetContentLength(ss.str());
+ }
+
+ if (needsContentMd5 && body && !httpRequest->HasHeader(Http::CONTENT_MD5_HEADER))
+ {
+ AWS_LOGSTREAM_TRACE(AWS_CLIENT_LOG_TAG, "Found body, and content-md5 needs to be set" <<
+ ", attempting to compute content-md5");
+
+ //changing the internal state of the hash computation is not a logical state
+ //change as far as constness goes for this class. Due to the platform specificness
+ //of hash computations, we can't control the fact that computing a hash mutates
+ //state on some platforms such as windows (but that isn't a concern of this class.
+ auto md5HashResult = const_cast<AWSClient*>(this)->m_hash->Calculate(*body);
+ body->clear();
+ if (md5HashResult.IsSuccess())
+ {
+ httpRequest->SetHeaderValue(Http::CONTENT_MD5_HEADER, HashingUtils::Base64Encode(md5HashResult.GetResult()));
+ }
+ }
+}
+
+Aws::String Aws::Client::GetAuthorizationHeader(const Aws::Http::HttpRequest& httpRequest)
+{
+ // Extract the hex-encoded signature from the authorization header rather than recalculating it.
+ assert(httpRequest.HasAwsAuthorization());
+ const auto& authHeader = httpRequest.GetAwsAuthorization();
+ auto signaturePosition = authHeader.rfind(Aws::Auth::SIGNATURE);
+ // The auth header should end with 'Signature=<64 chars>'
+ // Make sure we found the word 'Signature' in the header and make sure it's the last item followed by its 64 hex chars
+ if (signaturePosition == Aws::String::npos || (signaturePosition + strlen(Aws::Auth::SIGNATURE) + 1/*'=' character*/ + 64/*hex chars*/) != authHeader.length())
+ {
+ AWS_LOGSTREAM_ERROR(AWS_CLIENT_LOG_TAG, "Failed to extract signature from authorization header.");
+ return {};
+ }
+ return authHeader.substr(signaturePosition + strlen(Aws::Auth::SIGNATURE) + 1);
+}
+
+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.
+ AddHeadersToRequest(httpRequest, request.GetHeaders());
+
+ if (request.IsEventStreamRequest())
+ {
+ httpRequest->AddContentBody(request.GetBody());
+ }
+ 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());
+ httpRequest->SetDataSentEventHandler(request.GetDataSentEventHandler());
+ httpRequest->SetContinueRequestHandle(request.GetContinueRequestHandler());
+
+ request.AddQueryStringParameters(httpRequest->GetUri());
+}
+
+void AWSClient::AddCommonHeaders(HttpRequest& httpRequest) const
+{
+ httpRequest.SetUserAgent(m_userAgent);
+}
+
+Aws::String AWSClient::GeneratePresignedUrl(URI& uri, HttpMethod method, long long expirationInSeconds)
+{
+ std::shared_ptr<HttpRequest> request = CreateHttpRequest(uri, method, Aws::Utils::Stream::DefaultResponseStreamFactoryMethod);
+ auto signer = GetSignerByName(Aws::Auth::SIGV4_SIGNER);
+ if (signer->PresignRequest(*request, expirationInSeconds))
+ {
+ return request->GetURIString();
+ }
+
+ return {};
+}
+
+Aws::String AWSClient::GeneratePresignedUrl(URI& uri, HttpMethod method, 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, 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);
+ auto signer = GetSignerByName(Aws::Auth::SIGV4_SIGNER);
+ if (signer->PresignRequest(*request, region, serviceName, expirationInSeconds))
+ {
+ return request->GetURIString();
+ }
+
+ 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)
+{
+ 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, serviceName, expirationInSeconds))
+ {
+ return request->GetURIString();
+ }
+
+ return {};
+}
+
+Aws::String AWSClient::GeneratePresignedUrl(const Aws::AmazonWebServiceRequest& request, Aws::Http::URI& uri, Aws::Http::HttpMethod method, const char* region,
+ const Aws::Http::QueryStringParameterCollection& extraParams, long long expirationInSeconds) const
+{
+ std::shared_ptr<HttpRequest> httpRequest =
+ ConvertToRequestForPresigning(request, uri, method, extraParams);
+ auto signer = GetSignerByName(Aws::Auth::SIGV4_SIGNER);
+ if (signer->PresignRequest(*httpRequest, region, expirationInSeconds))
+ {
+ return httpRequest->GetURIString();
+ }
+
+ return {};
+}
+
+Aws::String AWSClient::GeneratePresignedUrl(const Aws::AmazonWebServiceRequest& request, Aws::Http::URI& uri, Aws::Http::HttpMethod method, const char* region, const char* serviceName,
+const Aws::Http::QueryStringParameterCollection& extraParams, long long expirationInSeconds) const
+{
+ std::shared_ptr<HttpRequest> httpRequest =
+ ConvertToRequestForPresigning(request, uri, method, extraParams);
+ auto signer = GetSignerByName(Aws::Auth::SIGV4_SIGNER);
+ if (signer->PresignRequest(*httpRequest, region, serviceName, expirationInSeconds))
+ {
+ return httpRequest->GetURIString();
+ }
+
+ return {};
+}
+
+Aws::String AWSClient::GeneratePresignedUrl(const Aws::AmazonWebServiceRequest& request, Aws::Http::URI& uri, Aws::Http::HttpMethod method,
+ const Aws::Http::QueryStringParameterCollection& extraParams, long long expirationInSeconds) const
+{
+ std::shared_ptr<HttpRequest> httpRequest =
+ ConvertToRequestForPresigning(request, uri, method, extraParams);
+ auto signer = GetSignerByName(Aws::Auth::SIGV4_SIGNER);
+ if (signer->PresignRequest(*httpRequest, expirationInSeconds))
+ {
+ return httpRequest->GetURIString();
+ }
+
+ return {};
+}
+
+std::shared_ptr<Aws::Http::HttpRequest> AWSClient::ConvertToRequestForPresigning(const Aws::AmazonWebServiceRequest& request, Aws::Http::URI& uri,
+ Aws::Http::HttpMethod method, const Aws::Http::QueryStringParameterCollection& extraParams) const
+{
+ 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);
+ }
+
+ return httpRequest;
+}
+
+std::shared_ptr<Aws::Http::HttpResponse> AWSClient::MakeHttpRequest(std::shared_ptr<Aws::Http::HttpRequest>& request) const
+{
+ return m_httpClient->MakeRequest(request, m_readRateLimiter.get(), m_writeRateLimiter.get());
+}
+
+
+////////////////////////////////////////////////////////////////////////////
+AWSJsonClient::AWSJsonClient(const Aws::Client::ClientConfiguration& configuration,
+ const std::shared_ptr<Aws::Client::AWSAuthSigner>& signer,
+ const std::shared_ptr<AWSErrorMarshaller>& errorMarshaller) :
+ BASECLASS(configuration, signer, errorMarshaller)
+{
+}
+
+AWSJsonClient::AWSJsonClient(const Aws::Client::ClientConfiguration& configuration,
+ const std::shared_ptr<Aws::Auth::AWSAuthSignerProvider>& signerProvider,
+ const std::shared_ptr<AWSErrorMarshaller>& errorMarshaller) :
+ BASECLASS(configuration, signerProvider, errorMarshaller)
+{
+}
+
+
+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
+{
+ HttpResponseOutcome httpOutcome(BASECLASS::AttemptExhaustively(uri, request, method, signerName, signerRegionOverride, signerServiceNameOverride));
+ if (!httpOutcome.IsSuccess())
+ {
+ return JsonOutcome(std::move(httpOutcome));
+ }
+
+ if (httpOutcome.GetResult()->GetResponseBody().tellp() > 0)
+ //this is stupid, but gcc doesn't pick up the covariant on the dereference so we have to give it a little hint.
+ return JsonOutcome(AmazonWebServiceResult<JsonValue>(JsonValue(httpOutcome.GetResult()->GetResponseBody()),
+ httpOutcome.GetResult()->GetHeaders(),
+ httpOutcome.GetResult()->GetResponseCode()));
+
+ else
+ return JsonOutcome(AmazonWebServiceResult<JsonValue>(JsonValue(), httpOutcome.GetResult()->GetHeaders()));
+}
+
+JsonOutcome AWSJsonClient::MakeRequest(const Aws::Http::URI& uri,
+ Http::HttpMethod method,
+ const char* signerName,
+ const char* requestName,
+ const char* signerRegionOverride,
+ const char* signerServiceNameOverride) const
+{
+ HttpResponseOutcome httpOutcome(BASECLASS::AttemptExhaustively(uri, method, signerName, requestName, signerRegionOverride, signerServiceNameOverride));
+ if (!httpOutcome.IsSuccess())
+ {
+ return JsonOutcome(std::move(httpOutcome));
+ }
+
+ if (httpOutcome.GetResult()->GetResponseBody().tellp() > 0)
+ {
+ JsonValue jsonValue(httpOutcome.GetResult()->GetResponseBody());
+ if (!jsonValue.WasParseSuccessful())
+ {
+ return JsonOutcome(AWSError<CoreErrors>(CoreErrors::UNKNOWN, "Json Parser Error", jsonValue.GetErrorMessage(), false));
+ }
+
+ //this is stupid, but gcc doesn't pick up the covariant on the dereference so we have to give it a little hint.
+ return JsonOutcome(AmazonWebServiceResult<JsonValue>(std::move(jsonValue),
+ httpOutcome.GetResult()->GetHeaders(),
+ httpOutcome.GetResult()->GetResponseCode()));
+ }
+
+ return JsonOutcome(AmazonWebServiceResult<JsonValue>(JsonValue(), httpOutcome.GetResult()->GetHeaders()));
+}
+
+JsonOutcome AWSJsonClient::MakeEventStreamRequest(std::shared_ptr<Aws::Http::HttpRequest>& request) const
+{
+ // request is assumed to be signed
+ std::shared_ptr<HttpResponse> httpResponse = MakeHttpRequest(request);
+
+ 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));
+ }
+
+ AWS_LOGSTREAM_DEBUG(AWS_CLIENT_LOG_TAG, "Request returned successful response.");
+
+ HttpResponseOutcome httpOutcome(std::move(httpResponse));
+
+ if (httpOutcome.GetResult()->GetResponseBody().tellp() > 0)
+ {
+ JsonValue jsonValue(httpOutcome.GetResult()->GetResponseBody());
+ if (!jsonValue.WasParseSuccessful())
+ {
+ return JsonOutcome(AWSError<CoreErrors>(CoreErrors::UNKNOWN, "Json Parser Error", jsonValue.GetErrorMessage(), false));
+ }
+
+ //this is stupid, but gcc doesn't pick up the covariant on the dereference so we have to give it a little hint.
+ return JsonOutcome(AmazonWebServiceResult<JsonValue>(std::move(jsonValue),
+ httpOutcome.GetResult()->GetHeaders(),
+ httpOutcome.GetResult()->GetResponseCode()));
+ }
+
+ return JsonOutcome(AmazonWebServiceResult<JsonValue>(JsonValue(), httpOutcome.GetResult()->GetHeaders()));
+}
+
+AWSError<CoreErrors> AWSJsonClient::BuildAWSError(
+ const std::shared_ptr<Aws::Http::HttpResponse>& httpResponse) const
+{
+ AWSError<CoreErrors> error;
+ if (httpResponse->HasClientError())
+ {
+ 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)
+ {
+ auto responseCode = httpResponse->GetResponseCode();
+ auto errorCode = GuessBodylessErrorType(responseCode);
+
+ Aws::StringStream ss;
+ ss << "No response body.";
+ error = AWSError<CoreErrors>(errorCode, "", ss.str(),
+ IsRetryableHttpResponseCode(responseCode));
+ }
+ else
+ {
+ assert(httpResponse->GetResponseCode() != HttpResponseCode::OK);
+ error = GetErrorMarshaller()->Marshall(*httpResponse);
+ }
+
+ error.SetResponseHeaders(httpResponse->GetHeaders());
+ error.SetResponseCode(httpResponse->GetResponseCode());
+ error.SetRemoteHostIpAddress(httpResponse->GetOriginatingRequest().GetResolvedRemoteHost());
+ AWS_LOGSTREAM_ERROR(AWS_CLIENT_LOG_TAG, error);
+ return error;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+AWSXMLClient::AWSXMLClient(const Aws::Client::ClientConfiguration& configuration,
+ const std::shared_ptr<Aws::Client::AWSAuthSigner>& signer,
+ const std::shared_ptr<AWSErrorMarshaller>& errorMarshaller) :
+ BASECLASS(configuration, signer, errorMarshaller)
+{
+}
+
+AWSXMLClient::AWSXMLClient(const Aws::Client::ClientConfiguration& configuration,
+ const std::shared_ptr<Aws::Auth::AWSAuthSignerProvider>& signerProvider,
+ const std::shared_ptr<AWSErrorMarshaller>& errorMarshaller) :
+ BASECLASS(configuration, signerProvider, errorMarshaller)
+{
+}
+
+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
+{
+ HttpResponseOutcome httpOutcome(BASECLASS::AttemptExhaustively(uri, request, method, signerName, signerRegionOverride, signerServiceNameOverride));
+ if (!httpOutcome.IsSuccess())
+ {
+ return XmlOutcome(std::move(httpOutcome));
+ }
+
+ if (httpOutcome.GetResult()->GetResponseBody().tellp() > 0)
+ {
+ XmlDocument xmlDoc = XmlDocument::CreateFromXmlStream(httpOutcome.GetResult()->GetResponseBody());
+
+ if (!xmlDoc.WasParseSuccessful())
+ {
+ AWS_LOGSTREAM_ERROR(AWS_CLIENT_LOG_TAG, "Xml parsing for error failed with message " << xmlDoc.GetErrorMessage().c_str());
+ return AWSError<CoreErrors>(CoreErrors::UNKNOWN, "Xml Parse Error", xmlDoc.GetErrorMessage(), false);
+ }
+
+ return XmlOutcome(AmazonWebServiceResult<XmlDocument>(std::move(xmlDoc),
+ httpOutcome.GetResult()->GetHeaders(), httpOutcome.GetResult()->GetResponseCode()));
+ }
+
+ return XmlOutcome(AmazonWebServiceResult<XmlDocument>(XmlDocument(), httpOutcome.GetResult()->GetHeaders()));
+}
+
+XmlOutcome AWSXMLClient::MakeRequest(const Aws::Http::URI& uri,
+ Http::HttpMethod method,
+ const char* signerName,
+ const char* requestName,
+ const char* signerRegionOverride,
+ const char* signerServiceNameOverride) const
+{
+ HttpResponseOutcome httpOutcome(BASECLASS::AttemptExhaustively(uri, method, signerName, requestName, signerRegionOverride, signerServiceNameOverride));
+ if (!httpOutcome.IsSuccess())
+ {
+ return XmlOutcome(std::move(httpOutcome));
+ }
+
+ if (httpOutcome.GetResult()->GetResponseBody().tellp() > 0)
+ {
+ return XmlOutcome(AmazonWebServiceResult<XmlDocument>(
+ XmlDocument::CreateFromXmlStream(httpOutcome.GetResult()->GetResponseBody()),
+ httpOutcome.GetResult()->GetHeaders(), httpOutcome.GetResult()->GetResponseCode()));
+ }
+
+ return XmlOutcome(AmazonWebServiceResult<XmlDocument>(XmlDocument(), httpOutcome.GetResult()->GetHeaders()));
+}
+
+AWSError<CoreErrors> AWSXMLClient::BuildAWSError(const std::shared_ptr<Http::HttpResponse>& httpResponse) const
+{
+ AWSError<CoreErrors> error;
+ if (httpResponse->HasClientError())
+ {
+ 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)
+ {
+ auto responseCode = httpResponse->GetResponseCode();
+ auto errorCode = GuessBodylessErrorType(responseCode);
+
+ Aws::StringStream ss;
+ ss << "No response body.";
+ error = AWSError<CoreErrors>(errorCode, "", ss.str(), IsRetryableHttpResponseCode(responseCode));
+ }
+ else
+ {
+ assert(httpResponse->GetResponseCode() != HttpResponseCode::OK);
+
+ // When trying to build an AWS Error from a response which is an FStream, we need to rewind the
+ // file pointer back to the beginning in order to correctly read the input using the XML string iterator
+ if ((httpResponse->GetResponseBody().tellp() > 0)
+ && (httpResponse->GetResponseBody().tellg() > 0))
+ {
+ httpResponse->GetResponseBody().seekg(0);
+ }
+
+ error = GetErrorMarshaller()->Marshall(*httpResponse);
+ }
+
+ error.SetResponseHeaders(httpResponse->GetHeaders());
+ error.SetResponseCode(httpResponse->GetResponseCode());
+ error.SetRemoteHostIpAddress(httpResponse->GetOriginatingRequest().GetResolvedRemoteHost());
+ AWS_LOGSTREAM_ERROR(AWS_CLIENT_LOG_TAG, error);
+ return error;
+}
diff --git a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/client/AWSErrorMarshaller.cpp b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/client/AWSErrorMarshaller.cpp
new file mode 100644
index 0000000000..f5fa676f98
--- /dev/null
+++ b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/client/AWSErrorMarshaller.cpp
@@ -0,0 +1,180 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/core/client/AWSErrorMarshaller.h>
+#include <aws/core/utils/logging/LogMacros.h>
+#include <aws/core/utils/json/JsonSerializer.h>
+#include <aws/core/utils/xml/XmlSerializer.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/client/AWSError.h>
+#include <aws/core/client/CoreErrors.h>
+
+using namespace Aws::Utils::Logging;
+using namespace Aws::Utils::Json;
+using namespace Aws::Utils::Xml;
+using namespace Aws::Http;
+using namespace Aws::Utils;
+using namespace Aws::Client;
+
+static const char AWS_ERROR_MARSHALLER_LOG_TAG[] = "AWSErrorMarshaller";
+AWS_CORE_API extern const char MESSAGE_LOWER_CASE[] = "message";
+AWS_CORE_API extern const char MESSAGE_CAMEL_CASE[] = "Message";
+AWS_CORE_API extern const char ERROR_TYPE_HEADER[] = "x-amzn-ErrorType";
+AWS_CORE_API extern const char REQUEST_ID_HEADER[] = "x-amzn-RequestId";
+AWS_CORE_API extern const char TYPE[] = "__type";
+
+AWSError<CoreErrors> JsonErrorMarshaller::Marshall(const Aws::Http::HttpResponse& httpResponse) const
+{
+ JsonValue exceptionPayload(httpResponse.GetResponseBody());
+ JsonView payloadView(exceptionPayload);
+ AWSError<CoreErrors> error;
+ if (exceptionPayload.WasParseSuccessful())
+ {
+ AWS_LOGSTREAM_TRACE(AWS_ERROR_MARSHALLER_LOG_TAG, "Error response is " << payloadView.WriteReadable());
+
+ Aws::String message(payloadView.ValueExists(MESSAGE_CAMEL_CASE) ? payloadView.GetString(MESSAGE_CAMEL_CASE) :
+ payloadView.ValueExists(MESSAGE_LOWER_CASE) ? payloadView.GetString(MESSAGE_LOWER_CASE) : "");
+
+ if (httpResponse.HasHeader(ERROR_TYPE_HEADER))
+ {
+ error = Marshall(httpResponse.GetHeader(ERROR_TYPE_HEADER), message);
+ }
+ else if (payloadView.ValueExists(TYPE))
+ {
+ error = Marshall(payloadView.GetString(TYPE), message);
+ }
+ else
+ {
+ error = FindErrorByHttpResponseCode(httpResponse.GetResponseCode());
+ error.SetMessage(message);
+ }
+ }
+ else
+ {
+ error = AWSError<CoreErrors>(CoreErrors::UNKNOWN, "", "Failed to parse error payload", false);
+ }
+
+ error.SetRequestId(httpResponse.HasHeader(REQUEST_ID_HEADER) ? httpResponse.GetHeader(REQUEST_ID_HEADER) : "");
+ error.SetJsonPayload(std::move(exceptionPayload));
+ return error;
+}
+
+const JsonValue& JsonErrorMarshaller::GetJsonPayloadFromError(const AWSError<CoreErrors>& error) const
+{
+ return error.GetJsonPayload();
+}
+
+AWSError<CoreErrors> XmlErrorMarshaller::Marshall(const Aws::Http::HttpResponse& httpResponse) const
+{
+ XmlDocument doc = XmlDocument::CreateFromXmlStream(httpResponse.GetResponseBody());
+ AWS_LOGSTREAM_TRACE(AWS_ERROR_MARSHALLER_LOG_TAG, "Error response is " << doc.ConvertToString());
+ bool errorParsed = false;
+ AWSError<CoreErrors> error;
+ if (doc.WasParseSuccessful() && !doc.GetRootElement().IsNull())
+ {
+ XmlNode errorNode = doc.GetRootElement();
+
+ Aws::String requestId(!errorNode.FirstChild("RequestId").IsNull() ? errorNode.FirstChild("RequestId").GetText() :
+ !errorNode.FirstChild("RequestID").IsNull() ? errorNode.FirstChild("RequestID").GetText() : "");
+
+ if (errorNode.GetName() != "Error")
+ {
+ errorNode = doc.GetRootElement().FirstChild("Error");
+ }
+ if (errorNode.IsNull())
+ {
+ errorNode = doc.GetRootElement().FirstChild("Errors");
+ if(!errorNode.IsNull())
+ {
+ errorNode = errorNode.FirstChild("Error");
+ }
+ }
+
+ if (!errorNode.IsNull())
+ {
+ requestId = !requestId.empty() ? requestId : !errorNode.FirstChild("RequestId").IsNull() ? errorNode.FirstChild("RequestId").GetText() :
+ !errorNode.FirstChild("RequestID").IsNull() ? errorNode.FirstChild("RequestID").GetText() : "";
+
+ XmlNode codeNode = errorNode.FirstChild("Code");
+ XmlNode messageNode = errorNode.FirstChild("Message");
+
+ if (!codeNode.IsNull())
+ {
+ error = Marshall(StringUtils::Trim(codeNode.GetText().c_str()),
+ StringUtils::Trim(messageNode.GetText().c_str()));
+ errorParsed = true;
+ }
+ }
+
+ error.SetRequestId(requestId);
+ }
+
+ if(!errorParsed)
+ {
+ // An error occurred attempting to parse the httpResponse as an XML stream, so we're just
+ // going to dump the XML parsing error and the http response code as a string
+ AWS_LOGSTREAM_WARN(AWS_ERROR_MARSHALLER_LOG_TAG, "Unable to generate a proper httpResponse from the response "
+ "stream. Response code: " << static_cast< uint32_t >(httpResponse.GetResponseCode()));
+ error = FindErrorByHttpResponseCode(httpResponse.GetResponseCode());
+ }
+
+ error.SetXmlPayload(std::move(doc));
+ return error;
+}
+
+const XmlDocument& XmlErrorMarshaller::GetXmlPayloadFromError(const AWSError<CoreErrors>& error) const
+{
+ return error.GetXmlPayload();
+}
+
+AWSError<CoreErrors> AWSErrorMarshaller::Marshall(const Aws::String& exceptionName, const Aws::String& message) const
+{
+ if(exceptionName.empty())
+ {
+ return AWSError<CoreErrors>(CoreErrors::UNKNOWN, "", message, false);
+ }
+
+ auto locationOfPound = exceptionName.find_first_of('#');
+ auto locationOfColon = exceptionName.find_first_of(':');
+ Aws::String formalExceptionName;
+
+ if (locationOfPound != Aws::String::npos)
+ {
+ formalExceptionName = exceptionName.substr(locationOfPound + 1);
+ }
+ else if (locationOfColon != Aws::String::npos)
+ {
+ formalExceptionName = exceptionName.substr(0, locationOfColon);
+ }
+ else
+ {
+ formalExceptionName = exceptionName;
+ }
+
+ AWSError<CoreErrors> error = FindErrorByName(formalExceptionName.c_str());
+ if (error.GetErrorType() != CoreErrors::UNKNOWN)
+ {
+ AWS_LOGSTREAM_WARN(AWS_ERROR_MARSHALLER_LOG_TAG, "Encountered AWSError '" << formalExceptionName.c_str() <<
+ "': " << message.c_str());
+ error.SetExceptionName(formalExceptionName);
+ error.SetMessage(message);
+ return error;
+ }
+
+ AWS_LOGSTREAM_WARN(AWS_ERROR_MARSHALLER_LOG_TAG, "Encountered Unknown AWSError '" << exceptionName.c_str() <<
+ "': " << message.c_str());
+
+ return AWSError<CoreErrors>(CoreErrors::UNKNOWN, exceptionName, "Unable to parse ExceptionName: " + exceptionName + " Message: " + message, false);
+}
+
+AWSError<CoreErrors> AWSErrorMarshaller::FindErrorByName(const char* errorName) const
+{
+ return CoreErrorsMapper::GetErrorForName(errorName);
+}
+
+AWSError<CoreErrors> AWSErrorMarshaller::FindErrorByHttpResponseCode(Aws::Http::HttpResponseCode code) const
+{
+ return CoreErrorsMapper::GetErrorForHttpResponseCode(code);
+}
diff --git a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/client/AsyncCallerContext.cpp b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/client/AsyncCallerContext.cpp
new file mode 100644
index 0000000000..4f9abdc9e4
--- /dev/null
+++ b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/client/AsyncCallerContext.cpp
@@ -0,0 +1,16 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/core/client/AsyncCallerContext.h>
+#include <aws/core/utils/UUID.h>
+
+namespace Aws
+{
+ namespace Client
+ {
+ AsyncCallerContext::AsyncCallerContext() : m_uuid(Aws::Utils::UUID::RandomUUID())
+ {}
+ }
+} \ No newline at end of file
diff --git a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/client/ClientConfiguration.cpp b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/client/ClientConfiguration.cpp
new file mode 100644
index 0000000000..e517379a77
--- /dev/null
+++ b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/client/ClientConfiguration.cpp
@@ -0,0 +1,160 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/core/client/ClientConfiguration.h>
+#include <aws/core/auth/AWSCredentialsProvider.h>
+#include <aws/core/client/DefaultRetryStrategy.h>
+#include <aws/core/platform/Environment.h>
+#include <aws/core/platform/OSVersionInfo.h>
+#include <aws/core/utils/memory/AWSMemory.h>
+#include <aws/core/utils/StringUtils.h>
+#include <aws/core/utils/threading/Executor.h>
+#include <aws/core/utils/memory/stl/AWSStringStream.h>
+#include <aws/core/Version.h>
+#include <aws/core/config/AWSProfileConfigLoader.h>
+#include <aws/core/utils/logging/LogMacros.h>
+
+namespace Aws
+{
+namespace Auth
+{
+ AWS_CORE_API Aws::String GetConfigProfileFilename();
+}
+namespace Client
+{
+
+static const char* CLIENT_CONFIG_TAG = "ClientConfiguration";
+
+AWS_CORE_API Aws::String ComputeUserAgentString()
+{
+ Aws::StringStream ss;
+ ss << "aws-sdk-cpp/" << Version::GetVersionString() << " " << Aws::OSVersionInfo::ComputeOSVersionString()
+ << " " << Version::GetCompilerVersionString();
+ return ss.str();
+}
+
+ClientConfiguration::ClientConfiguration() :
+ scheme(Aws::Http::Scheme::HTTPS),
+ useDualStack(false),
+ maxConnections(25),
+ httpRequestTimeoutMs(0),
+ requestTimeoutMs(3000),
+ connectTimeoutMs(1000),
+ enableTcpKeepAlive(true),
+ tcpKeepAliveIntervalMs(30000),
+ lowSpeedLimit(1),
+ proxyScheme(Aws::Http::Scheme::HTTP),
+ proxyPort(0),
+ executor(Aws::MakeShared<Aws::Utils::Threading::DefaultExecutor>(CLIENT_CONFIG_TAG)),
+ verifySSL(true),
+ writeRateLimiter(nullptr),
+ readRateLimiter(nullptr),
+ httpLibOverride(Aws::Http::TransferLibType::DEFAULT_CLIENT),
+ followRedirects(FollowRedirectsPolicy::DEFAULT),
+ disableExpectHeader(false),
+ enableClockSkewAdjustment(true),
+ enableHostPrefixInjection(true),
+ enableEndpointDiscovery(false),
+ profileName(Aws::Auth::GetConfigProfileName())
+{
+ AWS_LOGSTREAM_DEBUG(CLIENT_CONFIG_TAG, "ClientConfiguration will use SDK Auto Resolved profile: [" << profileName << "] if not specified by users.");
+
+ // Initialize Retry Strategy
+ int maxAttempts;
+ Aws::String maxAttemptsString = Aws::Environment::GetEnv("AWS_MAX_ATTEMPTS");
+ if (maxAttemptsString.empty())
+ {
+ maxAttemptsString = Aws::Config::GetCachedConfigValue("max_attempts");
+ }
+ // In case users specify 0 explicitly to disable retry.
+ if (maxAttemptsString == "0")
+ {
+ maxAttempts = 0;
+ }
+ else
+ {
+ maxAttempts = static_cast<int>(Aws::Utils::StringUtils::ConvertToInt32(maxAttemptsString.c_str()));
+ if (maxAttempts == 0)
+ {
+ AWS_LOGSTREAM_WARN(CLIENT_CONFIG_TAG, "Retry Strategy will use the default max attempts.");
+ maxAttempts = -1;
+ }
+ }
+
+ Aws::String retryMode = Aws::Environment::GetEnv("AWS_RETRY_MODE");
+ if (retryMode.empty())
+ {
+ retryMode = Aws::Config::GetCachedConfigValue("retry_mode");
+ }
+ if (retryMode == "standard")
+ {
+ if (maxAttempts < 0)
+ {
+ retryStrategy = Aws::MakeShared<StandardRetryStrategy>(CLIENT_CONFIG_TAG);
+ }
+ else
+ {
+ retryStrategy = Aws::MakeShared<StandardRetryStrategy>(CLIENT_CONFIG_TAG, maxAttempts);
+ }
+ }
+ else
+ {
+ retryStrategy = Aws::MakeShared<DefaultRetryStrategy>(CLIENT_CONFIG_TAG);
+ }
+
+ // Automatically determine the AWS region from environment variables, configuration file and EC2 metadata.
+ region = Aws::Environment::GetEnv("AWS_DEFAULT_REGION");
+ if (!region.empty())
+ {
+ return;
+ }
+
+ region = Aws::Environment::GetEnv("AWS_REGION");
+ if (!region.empty())
+ {
+ return;
+ }
+
+ region = Aws::Config::GetCachedConfigValue("region");
+ if (!region.empty())
+ {
+ return;
+ }
+
+ if (Aws::Utils::StringUtils::ToLower(Aws::Environment::GetEnv("AWS_EC2_METADATA_DISABLED").c_str()) != "true")
+ {
+ auto client = Aws::Internal::GetEC2MetadataClient();
+ if (client)
+ {
+ region = client->GetCurrentRegion();
+ }
+ }
+
+ if (!region.empty())
+ {
+ return;
+ }
+
+ region = Aws::String(Aws::Region::US_EAST_1);
+}
+
+ClientConfiguration::ClientConfiguration(const char* profile) : ClientConfiguration()
+{
+ if (profile && Aws::Config::HasCachedConfigProfile(profile))
+ {
+ this->profileName = Aws::String(profile);
+ AWS_LOGSTREAM_DEBUG(CLIENT_CONFIG_TAG, "Use user specified profile: [" << this->profileName << "] for ClientConfiguration.");
+ auto tmpRegion = Aws::Config::GetCachedConfigProfile(this->profileName).GetRegion();
+ if (!tmpRegion.empty())
+ {
+ region = tmpRegion;
+ }
+ return;
+ }
+ AWS_LOGSTREAM_WARN(CLIENT_CONFIG_TAG, "User specified profile: [" << profile << "] is not found, will use the SDK resolved one.");
+}
+
+} // namespace Client
+} // namespace Aws
diff --git a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/client/CoreErrors.cpp b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/client/CoreErrors.cpp
new file mode 100644
index 0000000000..8c2c288dcd
--- /dev/null
+++ b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/client/CoreErrors.cpp
@@ -0,0 +1,151 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/core/client/AWSError.h>
+#include <aws/core/client/CoreErrors.h>
+#include <aws/core/utils/memory/stl/AWSMap.h>
+#include <aws/core/utils/HashingUtils.h>
+
+using namespace Aws::Client;
+using namespace Aws::Utils;
+using namespace Aws::Http;
+
+#ifdef _MSC_VER
+#pragma warning(push)
+// VS2015 compiler's bug, warning s_CoreErrorsMapper: symbol will be dynamically initialized (implementation limitation)
+#pragma warning(disable : 4592)
+#endif
+
+static Aws::UniquePtr<Aws::Map<Aws::String, AWSError<CoreErrors> > > s_CoreErrorsMapper(nullptr);
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+void CoreErrorsMapper::InitCoreErrorsMapper()
+{
+ if (s_CoreErrorsMapper)
+ {
+ return;
+ }
+ s_CoreErrorsMapper = Aws::MakeUnique<Aws::Map<Aws::String, AWSError<CoreErrors> > >("InitCoreErrorsMapper");
+
+ s_CoreErrorsMapper->emplace("IncompleteSignature", AWSError<CoreErrors>(CoreErrors::INCOMPLETE_SIGNATURE, false));
+ s_CoreErrorsMapper->emplace("IncompleteSignatureException", AWSError<CoreErrors>(CoreErrors::INCOMPLETE_SIGNATURE, false));
+ s_CoreErrorsMapper->emplace("InvalidSignatureException", AWSError<CoreErrors>(CoreErrors::INVALID_SIGNATURE, false));
+ s_CoreErrorsMapper->emplace("InvalidSignature", AWSError<CoreErrors>(CoreErrors::INVALID_SIGNATURE, false));
+ s_CoreErrorsMapper->emplace("InternalFailureException", AWSError<CoreErrors>(CoreErrors::INTERNAL_FAILURE, true));
+ s_CoreErrorsMapper->emplace("InternalFailure", AWSError<CoreErrors>(CoreErrors::INTERNAL_FAILURE, true));
+ s_CoreErrorsMapper->emplace("InternalServerError", AWSError<CoreErrors>(CoreErrors::INTERNAL_FAILURE, true));
+ s_CoreErrorsMapper->emplace("InternalError", AWSError<CoreErrors>(CoreErrors::INTERNAL_FAILURE, true));
+ s_CoreErrorsMapper->emplace("InvalidActionException", AWSError<CoreErrors>(CoreErrors::INVALID_ACTION, false));
+ s_CoreErrorsMapper->emplace("InvalidAction", AWSError<CoreErrors>(CoreErrors::INVALID_ACTION, false));
+ s_CoreErrorsMapper->emplace("InvalidClientTokenIdException", AWSError<CoreErrors>(CoreErrors::INVALID_CLIENT_TOKEN_ID, false));
+ s_CoreErrorsMapper->emplace("InvalidClientTokenId", AWSError<CoreErrors>(CoreErrors::INVALID_CLIENT_TOKEN_ID, false));
+ s_CoreErrorsMapper->emplace("InvalidParameterCombinationException", AWSError<CoreErrors>(CoreErrors::INVALID_PARAMETER_COMBINATION, false));
+ s_CoreErrorsMapper->emplace("InvalidParameterCombination", AWSError<CoreErrors>(CoreErrors::INVALID_PARAMETER_COMBINATION, false));
+ s_CoreErrorsMapper->emplace("InvalidParameterValueException", AWSError<CoreErrors>(CoreErrors::INVALID_PARAMETER_VALUE, false));
+ s_CoreErrorsMapper->emplace("InvalidParameterValue", AWSError<CoreErrors>(CoreErrors::INVALID_PARAMETER_VALUE, false));
+ s_CoreErrorsMapper->emplace("InvalidQueryParameterException", AWSError<CoreErrors>(CoreErrors::INVALID_QUERY_PARAMETER, false));
+ s_CoreErrorsMapper->emplace("InvalidQueryParameter", AWSError<CoreErrors>(CoreErrors::INVALID_QUERY_PARAMETER, false));
+ s_CoreErrorsMapper->emplace("MalformedQueryStringException", AWSError<CoreErrors>(CoreErrors::MALFORMED_QUERY_STRING, false));
+ s_CoreErrorsMapper->emplace("MalformedQueryString", AWSError<CoreErrors>(CoreErrors::MALFORMED_QUERY_STRING, false));
+ s_CoreErrorsMapper->emplace("MissingActionException", AWSError<CoreErrors>(CoreErrors::MISSING_ACTION, false));
+ s_CoreErrorsMapper->emplace("MissingAction", AWSError<CoreErrors>(CoreErrors::MISSING_ACTION, false));
+ s_CoreErrorsMapper->emplace("MissingAuthenticationTokenException", AWSError<CoreErrors>(CoreErrors::MISSING_AUTHENTICATION_TOKEN, false));
+ s_CoreErrorsMapper->emplace("MissingAuthenticationToken", AWSError<CoreErrors>(CoreErrors::MISSING_AUTHENTICATION_TOKEN, false));
+ s_CoreErrorsMapper->emplace("MissingParameterException", AWSError<CoreErrors>(CoreErrors::MISSING_PARAMETER, false));
+ s_CoreErrorsMapper->emplace("MissingParameter", AWSError<CoreErrors>(CoreErrors::MISSING_PARAMETER, false));
+ s_CoreErrorsMapper->emplace("OptInRequired", AWSError<CoreErrors>(CoreErrors::OPT_IN_REQUIRED, false));
+ s_CoreErrorsMapper->emplace("RequestExpiredException", AWSError<CoreErrors>(CoreErrors::REQUEST_EXPIRED, true));
+ s_CoreErrorsMapper->emplace("RequestExpired", AWSError<CoreErrors>(CoreErrors::REQUEST_EXPIRED, true));
+ s_CoreErrorsMapper->emplace("ServiceUnavailableException", AWSError<CoreErrors>(CoreErrors::SERVICE_UNAVAILABLE, true));
+ s_CoreErrorsMapper->emplace("ServiceUnavailableError", AWSError<CoreErrors>(CoreErrors::SERVICE_UNAVAILABLE, true));
+ s_CoreErrorsMapper->emplace("ServiceUnavailable", AWSError<CoreErrors>(CoreErrors::SERVICE_UNAVAILABLE, true));
+ s_CoreErrorsMapper->emplace("RequestThrottledException", AWSError<CoreErrors>(CoreErrors::THROTTLING, true));
+ s_CoreErrorsMapper->emplace("RequestThrottled", AWSError<CoreErrors>(CoreErrors::THROTTLING, true));
+ s_CoreErrorsMapper->emplace("ThrottlingException", AWSError<CoreErrors>(CoreErrors::THROTTLING, true));
+ s_CoreErrorsMapper->emplace("ThrottledException", AWSError<CoreErrors>(CoreErrors::THROTTLING, true));
+ s_CoreErrorsMapper->emplace("Throttling", AWSError<CoreErrors>(CoreErrors::THROTTLING, true));
+ s_CoreErrorsMapper->emplace("ValidationErrorException", AWSError<CoreErrors>(CoreErrors::VALIDATION, false));
+ s_CoreErrorsMapper->emplace("ValidationException", AWSError<CoreErrors>(CoreErrors::VALIDATION, false));
+ s_CoreErrorsMapper->emplace("ValidationError", AWSError<CoreErrors>(CoreErrors::VALIDATION, false));
+ s_CoreErrorsMapper->emplace("AccessDeniedException", AWSError<CoreErrors>(CoreErrors::ACCESS_DENIED, false));
+ s_CoreErrorsMapper->emplace("AccessDenied", AWSError<CoreErrors>(CoreErrors::ACCESS_DENIED, false));
+ s_CoreErrorsMapper->emplace("ResourceNotFoundException", AWSError<CoreErrors>(CoreErrors::RESOURCE_NOT_FOUND, false));
+ s_CoreErrorsMapper->emplace("ResourceNotFound", AWSError<CoreErrors>(CoreErrors::RESOURCE_NOT_FOUND, false));
+ s_CoreErrorsMapper->emplace("UnrecognizedClientException", AWSError<CoreErrors>(CoreErrors::UNRECOGNIZED_CLIENT, false));
+ s_CoreErrorsMapper->emplace("UnrecognizedClient", AWSError<CoreErrors>(CoreErrors::UNRECOGNIZED_CLIENT, false));
+ s_CoreErrorsMapper->emplace("SlowDownException", AWSError<CoreErrors>(CoreErrors::SLOW_DOWN, true));
+ s_CoreErrorsMapper->emplace("SlowDown", AWSError<CoreErrors>(CoreErrors::SLOW_DOWN, true));
+ s_CoreErrorsMapper->emplace("SignatureDoesNotMatchException", AWSError<CoreErrors>(CoreErrors::SIGNATURE_DOES_NOT_MATCH, false));
+ s_CoreErrorsMapper->emplace("SignatureDoesNotMatch", AWSError<CoreErrors>(CoreErrors::SIGNATURE_DOES_NOT_MATCH, false));
+ s_CoreErrorsMapper->emplace("InvalidAccessKeyIdException", AWSError<CoreErrors>(CoreErrors::INVALID_ACCESS_KEY_ID, false));
+ s_CoreErrorsMapper->emplace("InvalidAccessKeyId", AWSError<CoreErrors>(CoreErrors::INVALID_ACCESS_KEY_ID, false));
+ s_CoreErrorsMapper->emplace("RequestTimeTooSkewedException", AWSError<CoreErrors>(CoreErrors::REQUEST_TIME_TOO_SKEWED, true));
+ s_CoreErrorsMapper->emplace("RequestTimeTooSkewed", AWSError<CoreErrors>(CoreErrors::REQUEST_TIME_TOO_SKEWED, true));
+ s_CoreErrorsMapper->emplace("RequestTimeoutException", AWSError<CoreErrors>(CoreErrors::REQUEST_TIMEOUT, true));
+ s_CoreErrorsMapper->emplace("RequestTimeout", AWSError<CoreErrors>(CoreErrors::REQUEST_TIMEOUT, true));
+}
+
+void CoreErrorsMapper::CleanupCoreErrorsMapper()
+{
+ if (s_CoreErrorsMapper)
+ {
+ s_CoreErrorsMapper = nullptr;
+ }
+}
+
+AWSError<CoreErrors> CoreErrorsMapper::GetErrorForName(const char* errorName)
+{
+ auto iter = s_CoreErrorsMapper->find(errorName);
+ if (iter != s_CoreErrorsMapper->end())
+ {
+ return iter->second;
+ }
+ return AWSError<CoreErrors>(CoreErrors::UNKNOWN, false);
+}
+
+AWS_CORE_API AWSError<CoreErrors> CoreErrorsMapper::GetErrorForHttpResponseCode(HttpResponseCode code)
+{
+ // best effort attempt to map HTTP response codes to CoreErrors
+ bool retryable = IsRetryableHttpResponseCode(code);
+ AWSError<CoreErrors> error;
+ switch (code)
+ {
+ case HttpResponseCode::UNAUTHORIZED:
+ case HttpResponseCode::FORBIDDEN:
+ error = AWSError<CoreErrors>(CoreErrors::ACCESS_DENIED, retryable);
+ break;
+ case HttpResponseCode::NOT_FOUND:
+ error = AWSError<CoreErrors>(CoreErrors::RESOURCE_NOT_FOUND, retryable);
+ break;
+ case HttpResponseCode::TOO_MANY_REQUESTS:
+ error = AWSError<CoreErrors>(CoreErrors::SLOW_DOWN, retryable);
+ break;
+ case HttpResponseCode::INTERNAL_SERVER_ERROR:
+ error = AWSError<CoreErrors>(CoreErrors::INTERNAL_FAILURE, retryable);
+ break;
+ case HttpResponseCode::BANDWIDTH_LIMIT_EXCEEDED:
+ error = AWSError<CoreErrors>(CoreErrors::THROTTLING, retryable);
+ break;
+ case HttpResponseCode::SERVICE_UNAVAILABLE:
+ error = AWSError<CoreErrors>(CoreErrors::SERVICE_UNAVAILABLE, retryable);
+ break;
+ case HttpResponseCode::REQUEST_TIMEOUT:
+ case HttpResponseCode::AUTHENTICATION_TIMEOUT:
+ case HttpResponseCode::LOGIN_TIMEOUT:
+ case HttpResponseCode::GATEWAY_TIMEOUT:
+ case HttpResponseCode::NETWORK_READ_TIMEOUT:
+ case HttpResponseCode::NETWORK_CONNECT_TIMEOUT:
+ error = AWSError<CoreErrors>(CoreErrors::REQUEST_TIMEOUT, retryable);
+ break;
+ default:
+ int codeValue = static_cast<int>(code);
+ error = AWSError<CoreErrors>(CoreErrors::UNKNOWN, codeValue >= 500 && codeValue < 600);
+ }
+ error.SetResponseCode(code);
+ return error;
+}
diff --git a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/client/DefaultRetryStrategy.cpp b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/client/DefaultRetryStrategy.cpp
new file mode 100644
index 0000000000..7e57c79ffc
--- /dev/null
+++ b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/client/DefaultRetryStrategy.cpp
@@ -0,0 +1,32 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/core/client/DefaultRetryStrategy.h>
+
+#include <aws/core/client/AWSError.h>
+#include <aws/core/utils/UnreferencedParam.h>
+
+using namespace Aws;
+using namespace Aws::Client;
+
+bool DefaultRetryStrategy::ShouldRetry(const AWSError<CoreErrors>& error, long attemptedRetries) const
+{
+ if (attemptedRetries >= m_maxRetries)
+ return false;
+
+ return error.ShouldRetry();
+}
+
+long DefaultRetryStrategy::CalculateDelayBeforeNextRetry(const AWSError<CoreErrors>& error, long attemptedRetries) const
+{
+ AWS_UNREFERENCED_PARAM(error);
+
+ if (attemptedRetries == 0)
+ {
+ return 0;
+ }
+
+ return (1 << attemptedRetries) * m_scaleFactor;
+}
diff --git a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/client/RetryStrategy.cpp b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/client/RetryStrategy.cpp
new file mode 100644
index 0000000000..b439b7ca99
--- /dev/null
+++ b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/client/RetryStrategy.cpp
@@ -0,0 +1,102 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/core/client/RetryStrategy.h>
+
+#include <aws/core/client/AWSError.h>
+#include <aws/core/client/CoreErrors.h>
+#include <aws/core/utils/Outcome.h>
+
+using namespace Aws::Utils::Threading;
+
+namespace Aws
+{
+ namespace Client
+ {
+ static const int INITIAL_RETRY_TOKENS = 500;
+ static const int RETRY_COST = 5;
+ static const int NO_RETRY_INCREMENT = 1;
+ static const int TIMEOUT_RETRY_COST = 10;
+
+ StandardRetryStrategy::StandardRetryStrategy(long maxAttempts) :
+ m_retryQuotaContainer(Aws::MakeShared<DefaultRetryQuotaContainer>("StandardRetryStrategy")),
+ m_maxAttempts(maxAttempts)
+ {}
+
+ StandardRetryStrategy::StandardRetryStrategy(std::shared_ptr<RetryQuotaContainer> retryQuotaContainer, long maxAttempts) :
+ m_retryQuotaContainer(retryQuotaContainer),
+ m_maxAttempts(maxAttempts)
+ {}
+
+ void StandardRetryStrategy::RequestBookkeeping(const HttpResponseOutcome& httpResponseOutcome)
+ {
+ if (httpResponseOutcome.IsSuccess())
+ {
+ m_retryQuotaContainer->ReleaseRetryQuota(NO_RETRY_INCREMENT);
+ }
+ }
+
+ void StandardRetryStrategy::RequestBookkeeping(const HttpResponseOutcome& httpResponseOutcome, const AWSError<CoreErrors>& lastError)
+ {
+ if (httpResponseOutcome.IsSuccess())
+ {
+ m_retryQuotaContainer->ReleaseRetryQuota(lastError);
+ }
+ }
+
+ bool StandardRetryStrategy::ShouldRetry(const AWSError<CoreErrors>& error, long attemptedRetries) const
+ {
+ if (!error.ShouldRetry())
+ return false;
+
+ if (attemptedRetries + 1 >= m_maxAttempts)
+ return false;
+
+ return m_retryQuotaContainer->AcquireRetryQuota(error);
+ }
+
+ long StandardRetryStrategy::CalculateDelayBeforeNextRetry(const AWSError<CoreErrors>& error, long attemptedRetries) const
+ {
+ AWS_UNREFERENCED_PARAM(error);
+ return (std::min)(rand() % 1000 * (1 << attemptedRetries), 20000);
+ }
+
+ DefaultRetryQuotaContainer::DefaultRetryQuotaContainer() : m_retryQuota(INITIAL_RETRY_TOKENS)
+ {}
+
+ bool DefaultRetryQuotaContainer::AcquireRetryQuota(int capacityAmount)
+ {
+ WriterLockGuard guard(m_retryQuotaLock);
+
+ if (capacityAmount > m_retryQuota)
+ {
+ return false;
+ }
+ else
+ {
+ m_retryQuota -= capacityAmount;
+ return true;
+ }
+ }
+
+ bool DefaultRetryQuotaContainer::AcquireRetryQuota(const AWSError<CoreErrors>& error)
+ {
+ int capacityAmount = error.GetErrorType() == CoreErrors::REQUEST_TIMEOUT ? TIMEOUT_RETRY_COST : RETRY_COST;
+ return AcquireRetryQuota(capacityAmount);
+ }
+
+ void DefaultRetryQuotaContainer::ReleaseRetryQuota(int capacityAmount)
+ {
+ WriterLockGuard guard(m_retryQuotaLock);
+ m_retryQuota = (std::min)(m_retryQuota + capacityAmount, INITIAL_RETRY_TOKENS);
+ }
+
+ void DefaultRetryQuotaContainer::ReleaseRetryQuota(const AWSError<CoreErrors>& error)
+ {
+ int capacityAmount = error.GetErrorType() == CoreErrors::REQUEST_TIMEOUT ? TIMEOUT_RETRY_COST : RETRY_COST;
+ ReleaseRetryQuota(capacityAmount);
+ }
+ }
+} \ No newline at end of file
diff --git a/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/client/SpecifiedRetryableErrorsRetryStrategy.cpp b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/client/SpecifiedRetryableErrorsRetryStrategy.cpp
new file mode 100644
index 0000000000..ec4e373304
--- /dev/null
+++ b/contrib/libs/aws-sdk-cpp/aws-cpp-sdk-core/source/client/SpecifiedRetryableErrorsRetryStrategy.cpp
@@ -0,0 +1,28 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/core/client/SpecifiedRetryableErrorsRetryStrategy.h>
+
+#include <aws/core/client/AWSError.h>
+
+using namespace Aws;
+using namespace Aws::Client;
+
+bool SpecifiedRetryableErrorsRetryStrategy::ShouldRetry(const AWSError<CoreErrors>& error, long attemptedRetries) const
+{
+ if (attemptedRetries >= m_maxRetries)
+ {
+ return false;
+ }
+ for (const auto& err: m_specifiedRetryableErrors)
+ {
+ if (error.GetExceptionName() == err)
+ {
+ return true;
+ }
+ }
+
+ return error.ShouldRetry();
+}