AWSClient.h

 
#pragma once
#if !defined(AWS_CLIENT_H)
#define AWS_CLIENT_H
 
#include <aws/core/Core_EXPORTS.h>
#include <aws/core/client/CoreErrors.h>
#include <aws/core/client/AWSUrlPresigner.h>
#include <aws/core/http/HttpTypes.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/AmazonWebServiceResult.h>
#include <aws/core/utils/crypto/Hash.h>
#include <aws/core/auth/AWSAuthSignerProvider.h>
#include <aws/core/endpoint/AWSEndpoint.h>
#include <smithy/client/features/UserAgentInterceptor.h>
#include <smithy/interceptor/Interceptor.h>
#include <memory>
#include <atomic>
 
namespace Aws
{
    namespace Utils
    {
        template<typename R, typename E>
        class Outcome;
 
        namespace RateLimits
        {
            class RateLimiterInterface;
        } // namespace RateLimits
 
        namespace Crypto
        {
            class MD5;
        } // namespace Crypto
    } // namespace Utils
 
    namespace Http
    {
        class HttpClient;
 
        class HttpClientFactory;
 
        class HttpRequest;
 
        class HttpResponse;
 
        class URI;
    } // namespace Http
 
    namespace Auth
    {
        AWS_CORE_API extern const char SIGV4_SIGNER[];
        AWS_CORE_API extern const char NULL_SIGNER[];
    }
 
    class AmazonWebServiceRequest;
 
    namespace Client
    {
        template<typename ERROR_TYPE>
        class AWSError;
        class AWSErrorMarshaller;
        class AWSAuthSigner;
        struct ClientConfiguration;
        class RetryStrategy;
 
        typedef Utils::Outcome<std::shared_ptr<Aws::Http::HttpResponse>, AWSError<CoreErrors>> HttpResponseOutcome;
        typedef Utils::Outcome<AmazonWebServiceResult<Utils::Stream::ResponseStream>, AWSError<CoreErrors>> StreamOutcome;
 
        class AWS_CORE_API AWSClient
        { 
        public:
            AWSClient(const Aws::Client::ClientConfiguration& configuration,
                      const std::shared_ptr<Aws::Client::AWSAuthSigner>& signer,
                      const std::shared_ptr<AWSErrorMarshaller>& errorMarshaller);
 
            AWSClient(const Aws::Client::ClientConfiguration& configuration,
                      const std::shared_ptr<Aws::Auth::AWSAuthSignerProvider>& signerProvider,
                      const std::shared_ptr<AWSErrorMarshaller>& errorMarshaller);
 
            virtual ~AWSClient() { };
 
            Aws::String GeneratePresignedUrl(const Aws::Http::URI& uri, Aws::Http::HttpMethod method, long long expirationInSeconds = 0, const std::shared_ptr<Aws::Http::ServiceSpecificParameters> serviceSpecificParameter = {});
 
            Aws::String GeneratePresignedUrl(const Aws::Http::URI& uri, Aws::Http::HttpMethod method, const Aws::Http::HeaderValueCollection& customizedHeaders, long long expirationInSeconds = 0, const std::shared_ptr<Aws::Http::ServiceSpecificParameters> serviceSpecificParameter = {});
 
            Aws::String GeneratePresignedUrl(const Aws::Http::URI& uri, Aws::Http::HttpMethod method, const char* region, long long expirationInSeconds = 0, const std::shared_ptr<Aws::Http::ServiceSpecificParameters> serviceSpecificParameter = {}) const;
 
            Aws::String GeneratePresignedUrl(const Aws::Http::URI& uri, Aws::Http::HttpMethod method, const char* region, const Aws::Http::HeaderValueCollection& customizedHeaders, long long expirationInSeconds = 0, const std::shared_ptr<Aws::Http::ServiceSpecificParameters> serviceSpecificParameter = {});
 
            Aws::String GeneratePresignedUrl(const Aws::Http::URI& uri, Aws::Http::HttpMethod method, const char* region, const char* serviceName, long long expirationInSeconds = 0, const std::shared_ptr<Aws::Http::ServiceSpecificParameters> serviceSpecificParameter = {}) const;
 
            Aws::String GeneratePresignedUrl(const Aws::Http::URI& uri, Aws::Http::HttpMethod method, const char* region, const char* serviceName, const Aws::Http::HeaderValueCollection& customizedHeaders, long long expirationInSeconds = 0, const std::shared_ptr<Aws::Http::ServiceSpecificParameters> serviceSpecificParameter = {});
 
            Aws::String GeneratePresignedUrl(const Aws::Http::URI& uri, Aws::Http::HttpMethod method, const char* region, const char* serviceName, const char* signerName, long long expirationInSeconds = 0, const std::shared_ptr<Aws::Http::ServiceSpecificParameters> serviceSpecificParameter = {}) const;
 
            Aws::String GeneratePresignedUrl(const Aws::Http::URI& uri, Aws::Http::HttpMethod method, const char* region, const char* serviceName, const char* signerName, const Aws::Http::HeaderValueCollection& customizedHeaders, long long expirationInSeconds = 0, const std::shared_ptr<Aws::Http::ServiceSpecificParameters> serviceSpecificParameter = {});
 
            Aws::String GeneratePresignedUrl(const Aws::Endpoint::AWSEndpoint& endpoint,
                                             Aws::Http::HttpMethod method = Http::HttpMethod::HTTP_POST,
                                             const Aws::Http::HeaderValueCollection& customizedHeaders = {},
                                             uint64_t expirationInSeconds = 0,
                                             const char* signerName = Aws::Auth::SIGV4_SIGNER,
                                             const char* signerRegionOverride = nullptr,
                                             const char* signerServiceNameOverride = nullptr,
                                             const std::shared_ptr<Aws::Http::ServiceSpecificParameters> serviceSpecificParameter = {});
 
            Aws::String GeneratePresignedUrl(const Aws::AmazonWebServiceRequest& request, const Aws::Http::URI& uri, Aws::Http::HttpMethod method,
                                             const Aws::Http::QueryStringParameterCollection& extraParams = Aws::Http::QueryStringParameterCollection(), long long expirationInSeconds = 0,
                                             const std::shared_ptr<Aws::Http::ServiceSpecificParameters> serviceSpecificParameter = {}) const;
 
            Aws::String GeneratePresignedUrl(const Aws::AmazonWebServiceRequest& request, const Aws::Http::URI& uri, Aws::Http::HttpMethod method, const char* region, const char* serviceName,
                                             const char* signerName, const Aws::Http::QueryStringParameterCollection& extraParams = Aws::Http::QueryStringParameterCollection(), long long expirationInSeconds = 0,
                                             const std::shared_ptr<Aws::Http::ServiceSpecificParameters> serviceSpecificParameter = {}) const;
 
            Aws::String GeneratePresignedUrl(const Aws::AmazonWebServiceRequest& request, const Aws::Http::URI& uri, Aws::Http::HttpMethod method, const char* region, const char* serviceName,
                                             const Aws::Http::QueryStringParameterCollection& extraParams = Aws::Http::QueryStringParameterCollection(), long long expirationInSeconds = 0,
                                             const std::shared_ptr<Aws::Http::ServiceSpecificParameters> serviceSpecificParameter = {}) const;
 
            Aws::String GeneratePresignedUrl(const Aws::AmazonWebServiceRequest& request, const Aws::Http::URI& uri, Aws::Http::HttpMethod method, const char* region,
                                             const Aws::Http::QueryStringParameterCollection& extraParams = Aws::Http::QueryStringParameterCollection(), long long expirationInSeconds = 0,
                                             const std::shared_ptr<Aws::Http::ServiceSpecificParameters> serviceSpecificParameter = {}) const;
 
            const std::shared_ptr<Aws::Http::HttpClient>& GetHttpClient() const { return m_httpClient; }
 
            void DisableRequestProcessing();
 
            void EnableRequestProcessing();
 
            inline virtual const char* GetServiceClientName() const { return m_serviceName.c_str(); }
            virtual void SetServiceClientName(const Aws::String& name);
 
            void AppendToUserAgent(const Aws::String& valueToAppend);
        protected:
            HttpResponseOutcome AttemptExhaustively(const Aws::Http::URI& uri,
                                                    const Aws::AmazonWebServiceRequest& request,
                                                    Http::HttpMethod httpMethod,
                                                    const char* signerName,
                                                    const char* signerRegionOverride = nullptr,
                                                    const char* signerServiceNameOverride = nullptr) const;
 
            HttpResponseOutcome AttemptExhaustively(const Aws::Http::URI& uri,
                                                    Http::HttpMethod httpMethod,
                                                    const char* signerName,
                                                    const char* requestName = "",
                                                    const char* signerRegionOverride = nullptr,
                                                    const char* signerServiceNameOverride = nullptr) const;
 
            HttpResponseOutcome AttemptOneRequest(const std::shared_ptr<Http::HttpRequest>& httpRequest,
                                                  const Aws::AmazonWebServiceRequest& request,
                                                  const char* signerName,
                                                  const char* signerRegionOverride = nullptr,
                                                  const char* signerServiceNameOverride = nullptr) const;
 
            HttpResponseOutcome AttemptOneRequest(const std::shared_ptr<Http::HttpRequest>& httpRequest,
                                                  const char* signerName,
                                                  const char* requestName = "",
                                                  const char* signerRegionOverride = nullptr,
                                                  const char* signerServiceNameOverride = nullptr) const;
 
            StreamOutcome MakeRequestWithUnparsedResponse(const Aws::Http::URI& uri,
                                                          const Aws::AmazonWebServiceRequest& request,
                                                          Http::HttpMethod method = Http::HttpMethod::HTTP_POST,
                                                          const char* signerName = Aws::Auth::SIGV4_SIGNER,
                                                          const char* signerRegionOverride = nullptr,
                                                          const char* signerServiceNameOverride = nullptr) const;
 
            StreamOutcome MakeRequestWithUnparsedResponse(const Aws::Http::URI& uri,
                                                          Http::HttpMethod method = Http::HttpMethod::HTTP_POST,
                                                          const char* signerName = Aws::Auth::SIGV4_SIGNER,
                                                          const char* requestName = "",
                                                          const char* signerRegionOverride = nullptr,
                                                          const char* signerServiceNameOverride = nullptr) const;
 
            StreamOutcome MakeRequestWithUnparsedResponse(const Aws::AmazonWebServiceRequest& request,
                                                          const Aws::Endpoint::AWSEndpoint& endpoint,
                                                          Http::HttpMethod method = Http::HttpMethod::HTTP_POST,
                                                          const char* signerName = Aws::Auth::SIGV4_SIGNER,
                                                          const char* signerRegionOverride = nullptr,
                                                          const char* signerServiceNameOverride = nullptr) const;
 
            virtual AWSError<CoreErrors> BuildAWSError(const std::shared_ptr<Aws::Http::HttpResponse>& response) const = 0;
 
            virtual void BuildHttpRequest(const Aws::AmazonWebServiceRequest& request,
                                          const std::shared_ptr<Aws::Http::HttpRequest>& httpRequest) const;
 
            virtual void AddContentLengthToRequest(const std::shared_ptr<Aws::Http::HttpRequest>& httpRequest,
                                                   const std::shared_ptr<Aws::IOStream>& body,
                                                   bool isChunked) const;
 
            const std::shared_ptr<AWSErrorMarshaller>& GetErrorMarshaller() const
            {
                return m_errorMarshaller;
            }
 
            Aws::Client::AWSAuthSigner* GetSignerByName(const char* name) const;
 
            friend Aws::Client::AWSAuthSigner* AWSUrlPresigner::GetSignerByName(const char* name) const;
 
            std::shared_ptr<Auth::AWSCredentialsProvider> GetCredentialsProvider() const {
                 return m_signerProvider->GetCredentialsProvider();
            }
 
            std::shared_ptr<Aws::Http::HttpRequest> BuildAndSignHttpRequest(const Aws::Http::URI& uri,
                                                                            const Aws::AmazonWebServiceRequest& request,
                                                                            Http::HttpMethod method, const char* signerName) const;
 
            std::shared_ptr<Aws::Http::HttpResponse> MakeHttpRequest(std::shared_ptr<Aws::Http::HttpRequest>& request) const;
            Aws::String m_region;
 
            static void AppendRecursionDetectionHeader(std::shared_ptr<Aws::Http::HttpRequest> ioRequest);
 
            static CoreErrors GuessBodylessErrorType(Aws::Http::HttpResponseCode responseCode);
            static bool DoesResponseGenerateError(const std::shared_ptr<Aws::Http::HttpResponse>& response);
            std::shared_ptr<smithy::components::tracing::TelemetryProvider> m_telemetryProvider;
            std::shared_ptr<Aws::Auth::AWSAuthSignerProvider> m_signerProvider;
        private:
            bool AdjustClockSkew(HttpResponseOutcome& outcome, const char* signerName) const;
            void AddHeadersToRequest(const std::shared_ptr<Aws::Http::HttpRequest>& httpRequest, const Http::HeaderValueCollection& headerValues) const;
            void AddContentBodyToRequest(const std::shared_ptr<Aws::Http::HttpRequest>& httpRequest, const std::shared_ptr<Aws::IOStream>& body,
                                         bool needsContentMd5 = false, bool isChunked = false) const;
            void AppendHeaderValueToRequest(const std::shared_ptr<Http::HttpRequest> &request, String header, String value) const;
 
            std::shared_ptr<Aws::Http::HttpClient> m_httpClient;
            std::shared_ptr<AWSErrorMarshaller> m_errorMarshaller;
            std::shared_ptr<RetryStrategy> m_retryStrategy;
            std::shared_ptr<Aws::Utils::RateLimits::RateLimiterInterface> m_writeRateLimiter;
            std::shared_ptr<Aws::Utils::RateLimits::RateLimiterInterface> m_readRateLimiter;
            std::shared_ptr<Aws::Utils::Crypto::Hash> m_hash;
            long m_requestTimeoutMs;
            bool m_enableClockSkewAdjustment;
            Aws::String m_serviceName = "AWSBaseClient";
            Aws::Client::RequestCompressionConfig m_requestCompressionConfig;
            std::shared_ptr<smithy::client::UserAgentInterceptor> m_userAgentInterceptor;
            Aws::Vector<std::shared_ptr<smithy::interceptor::Interceptor>> m_interceptors;
        };
 
        AWS_CORE_API Aws::String GetAuthorizationHeader(const Aws::Http::HttpRequest& httpRequest);
    } // namespace Client
} // namespace Aws
 
#if !defined(AWS_JSON_CLIENT_H) && !defined(AWS_XML_CLIENT_H) && !defined(AWS_CBOR_CLIENT_H)
/* Legacy backward compatibility macros to not break the build for ones including just AWSClient.h */
#include <aws/core/client/AWSJsonClient.h>
#include <aws/core/client/AWSRpcV2CborClient.h>
#include <aws/core/client/AWSXmlClient.h>
#endif // !defined(AWS_JSON_CLIENT_H) && !defined(AWS_XML_CLIENT_H) && !defined(AWS_CBOR_CLIENT_H)
#endif // !defined(AWS_CLIENT_H)