HttpRequest.h

 
#pragma once
 
#include <aws/core/Core_EXPORTS.h>
 
#include <aws/core/http/URI.h>
#include <aws/core/http/HttpTypes.h>
#include <aws/core/utils/memory/AWSMemory.h>
#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
#include <aws/core/utils/stream/ResponseStream.h>
#include <aws/core/utils/UUID.h>
#include <aws/core/utils/DateTime.h>
#include <aws/crt/Optional.h>
#include <aws/core/monitoring/HttpClientMetrics.h>
#include <memory>
#include <functional>
 
namespace Aws
{
    namespace Crt
    {
        namespace Http
        {
            class HttpRequest;
        }
    }
    namespace Utils
    {
        namespace Crypto
        {
            class Hash;
        }
    }
    namespace Http
    {
        extern AWS_CORE_API const char DATE_HEADER[];
        extern AWS_CORE_API const char AWS_DATE_HEADER[];
        extern AWS_CORE_API const char AWS_SECURITY_TOKEN[];
        extern AWS_CORE_API const char ACCEPT_HEADER[];
        extern AWS_CORE_API const char ACCEPT_CHAR_SET_HEADER[];
        extern AWS_CORE_API const char ACCEPT_ENCODING_HEADER[];
        extern AWS_CORE_API const char AUTHORIZATION_HEADER[];
        extern AWS_CORE_API const char AWS_AUTHORIZATION_HEADER[];
        extern AWS_CORE_API const char COOKIE_HEADER[];
        extern AWS_CORE_API const char DECODED_CONTENT_LENGTH_HEADER[];
        extern AWS_CORE_API const char CONTENT_LENGTH_HEADER[];
        extern AWS_CORE_API const char CONTENT_TYPE_HEADER[];
        extern AWS_CORE_API const char CONTENT_ENCODING_HEADER[];
        extern AWS_CORE_API const char TRANSFER_ENCODING_HEADER[];
        extern AWS_CORE_API const char USER_AGENT_HEADER[];
        extern AWS_CORE_API const char VIA_HEADER[];
        extern AWS_CORE_API const char HOST_HEADER[];
        extern AWS_CORE_API const char AMZ_TARGET_HEADER[];
        extern AWS_CORE_API const char X_AMZ_EXPIRES_HEADER[];
        extern AWS_CORE_API const char CONTENT_MD5_HEADER[];
        extern AWS_CORE_API const char API_VERSION_HEADER[];
        extern AWS_CORE_API const char AWS_TRAILER_HEADER[];
        extern AWS_CORE_API const char SDK_INVOCATION_ID_HEADER[];
        extern AWS_CORE_API const char SDK_REQUEST_HEADER[];
        extern AWS_CORE_API const char SMITHY_PROTOCOL_HEADER[];
        extern AWS_CORE_API const char X_AMZN_TRACE_ID_HEADER[];
        extern AWS_CORE_API const char CHUNKED_VALUE[];
        extern AWS_CORE_API const char AWS_CHUNKED_VALUE[];
        extern AWS_CORE_API const char EXPECT_HEADER[];
        extern AWS_CORE_API const char EXPECT_100_CONTINUE_VALUE[];
        extern AWS_CORE_API const char X_AMZN_ERROR_TYPE[];
        extern AWS_CORE_API const char X_AMZN_QUERY_MODE[];
 
        class HttpRequest;
        class HttpResponse;
 
        typedef std::function<void(const HttpRequest*, HttpResponse*)> HeadersReceivedEventHandler;
        typedef std::function<void(const HttpRequest*, HttpResponse*, long long)> DataReceivedEventHandler;
        typedef std::function<void(const HttpRequest*, long long)> DataSentEventHandler;
        typedef std::function<bool(const HttpRequest*)> ContinueRequestHandler;
 
        struct ServiceSpecificParameters {
            Aws::Map<Aws::String, Aws::String> parameterMap;
        };
 
        class AWS_CORE_API HttpRequest
        {
        public:
            HttpRequest(const URI& uri, HttpMethod method) :
                m_uri(uri), m_method(method), m_isEvenStreamRequest(false)
            {}
 
            virtual ~HttpRequest() {}
 
            virtual HeaderValueCollection GetHeaders() const = 0;
            virtual const Aws::String& GetHeaderValue(const char* headerName) const = 0;
 
            virtual void SetHeaderValue(const char* headerName, const Aws::String& headerValue) = 0;
            virtual void SetHeaderValue(const Aws::String& headerName, const Aws::String& headerValue) = 0;
 
            virtual void DeleteHeader(const char* headerName) = 0;
            virtual void AddContentBody(const std::shared_ptr<Aws::IOStream>& strContent) = 0;
            virtual const std::shared_ptr<Aws::IOStream>& GetContentBody() const = 0;
            virtual bool HasHeader(const char* name) const = 0;
            virtual int64_t GetSize() const = 0;
            virtual const Aws::IOStreamFactory& GetResponseStreamFactory() const = 0;
            virtual void SetResponseStreamFactory(const Aws::IOStreamFactory& factory) = 0;
            inline URI& GetUri()
            {
                return m_uri;
            }
            const URI& GetUri() const { return m_uri; }
            inline Aws::String GetURIString(bool includeQueryString = true) const
            {
                return m_uri.GetURIString(includeQueryString);
            }
            inline HttpMethod GetMethod() const
            {
                return m_method;
            }
            inline const Aws::String& GetQueryString() const
            {
                return m_uri.GetQueryString();
            }
            inline void CanonicalizeRequest()
            {
                m_uri.CanonicalizeQueryString();
            }
            inline QueryStringParameterCollection GetQueryStringParameters() const
            {
                return m_uri.GetQueryStringParameters();
            }
            inline void AddQueryStringParameter(const char* key, const Aws::String& value)
            {
                m_uri.AddQueryStringParameter(key, value);
            }
 
            inline bool HasDate() const
            {
                return HasHeader(DATE_HEADER);
            }
            inline const Aws::String& GetDate() const
            {
                return GetHeaderValue(DATE_HEADER);
            }
            inline void SetDate(const Aws::String& value)
            {
                SetHeaderValue(DATE_HEADER, value);
            }
 
            inline bool HasAccept() const
            {
                return HasHeader(ACCEPT_HEADER);
            }
            inline const Aws::String& GetAccept() const
            {
                return GetHeaderValue(ACCEPT_HEADER);
            }
            inline void SetAccept(const Aws::String& value)
            {
                SetHeaderValue(ACCEPT_HEADER, value);
            }
 
            inline bool HasAcceptCharSet() const
            {
                return HasHeader(ACCEPT_CHAR_SET_HEADER);
            }
            inline const Aws::String& GetAcceptCharSet() const
            {
                return GetHeaderValue(ACCEPT_CHAR_SET_HEADER);
            }
            inline void SetAcceptCharSet(const Aws::String& value)
            {
                SetHeaderValue(ACCEPT_CHAR_SET_HEADER, value);
            }
 
            inline bool HasAcceptEncoding() const
            {
                return HasHeader(ACCEPT_ENCODING_HEADER);
            }
            inline const Aws::String& GetAcceptEncoding() const
            {
                return GetHeaderValue(ACCEPT_ENCODING_HEADER);
            }
            inline void SetAcceptEncoding(const Aws::String& value)
            {
                SetHeaderValue(ACCEPT_ENCODING_HEADER, value);
            }
 
            inline bool HasAuthorization() const
            {
                return HasHeader(AUTHORIZATION_HEADER);
            }
            inline const Aws::String& GetAuthorization() const
            {
                return GetHeaderValue(AUTHORIZATION_HEADER);
            }
            inline void SetAuthorization(const Aws::String& value)
            {
                SetHeaderValue(AUTHORIZATION_HEADER, value);
            }
 
            inline bool HasAwsAuthorization() const
            {
                return HasHeader(AWS_AUTHORIZATION_HEADER);
            }
            inline const Aws::String& GetAwsAuthorization() const
            {
                return GetHeaderValue(AWS_AUTHORIZATION_HEADER);
            }
            inline void SetAwsAuthorization(const Aws::String& value)
            {
                SetHeaderValue(AWS_AUTHORIZATION_HEADER, value);
            }
 
            inline bool HasAwsSessionToken() const
            {
                return HasHeader(AWS_SECURITY_TOKEN);
            }
            inline const Aws::String& GetAwsSessionToken() const
            {
                return GetHeaderValue(AWS_SECURITY_TOKEN);
            }
            inline void SetAwsSessionToken(const Aws::String& value)
            {
                SetHeaderValue(AWS_SECURITY_TOKEN, value);
            }
 
            inline bool HasCookie() const
            {
                return HasHeader(COOKIE_HEADER);
            }
            inline const Aws::String& GetCookie() const
            {
                return GetHeaderValue(COOKIE_HEADER);
            }
            inline void SetCookie(const Aws::String& value)
            {
                SetHeaderValue(COOKIE_HEADER, value);
            }
 
            inline bool HasContentLength() const
            {
                return HasHeader(CONTENT_LENGTH_HEADER);
            }
            inline const Aws::String& GetContentLength() const
            {
                return GetHeaderValue(CONTENT_LENGTH_HEADER);
            }
            inline void SetContentLength(const Aws::String& value)
            {
                SetHeaderValue(CONTENT_LENGTH_HEADER, value);
            }
 
            inline bool HasContentType() const
            {
                return HasHeader(CONTENT_TYPE_HEADER);
            }
            inline const Aws::String& GetContentType() const
            {
                return GetHeaderValue(CONTENT_TYPE_HEADER);
            }
            inline void SetContentType(const Aws::String& value)
            {
                SetHeaderValue(CONTENT_TYPE_HEADER, value);
            }
 
            inline bool HasContentEncoding() const { return HasHeader(CONTENT_ENCODING_HEADER); }
            inline const Aws::String& GetContentEncoding() const { return GetHeaderValue(CONTENT_ENCODING_HEADER); }
            inline void SetContentEncoding(const Aws::String& value) { SetHeaderValue(CONTENT_ENCODING_HEADER, value); }
 
            inline bool HasTransferEncoding() const
            {
                return HasHeader(TRANSFER_ENCODING_HEADER);
            }
            inline const Aws::String& GetTransferEncoding() const
            {
                return GetHeaderValue(TRANSFER_ENCODING_HEADER);
            }
            inline void SetTransferEncoding(const Aws::String& value)
            {
                SetHeaderValue(TRANSFER_ENCODING_HEADER, value);
            }
 
            inline bool HasUserAgent() const
            {
                return HasHeader(USER_AGENT_HEADER);
            }
            inline const Aws::String& GetUserAgent() const
            {
                return GetHeaderValue(USER_AGENT_HEADER);
            }
            inline void SetUserAgent(const Aws::String& value)
            {
                SetHeaderValue(USER_AGENT_HEADER, value);
            }
 
            inline bool HasVia() const
            {
                return HasHeader(VIA_HEADER);
            }
            inline const Aws::String& GetVia() const
            {
                return GetHeaderValue(VIA_HEADER);
            }
            inline void SetVia(const Aws::String& value)
            {
                SetHeaderValue(VIA_HEADER, value);
            }
 
            inline bool HasApiVersion() const
            {
                return HasHeader(API_VERSION_HEADER);
            }
 
            inline const Aws::String& GetApiVersion() const
            {
                return GetHeaderValue(API_VERSION_HEADER);
            }
            inline void SetApiVersion(const Aws::String& value)
            {
                SetHeaderValue(API_VERSION_HEADER, value);
            }
 
 
            inline void SetHeadersReceivedEventHandler(const HeadersReceivedEventHandler& headersReceivedEventHandler) { m_onHeadersReceived = headersReceivedEventHandler; }
            inline void SetHeadersReceivedEventHandler(HeadersReceivedEventHandler&& headersReceivedEventHandler) { m_onHeadersReceived = std::move(headersReceivedEventHandler); }
 
 
            inline void SetDataReceivedEventHandler(const DataReceivedEventHandler& dataReceivedEventHandler) { m_onDataReceived = dataReceivedEventHandler; }
            inline void SetDataReceivedEventHandler(DataReceivedEventHandler&& dataReceivedEventHandler) { m_onDataReceived = std::move(dataReceivedEventHandler); }
 
 
            inline void SetDataSentEventHandler(const DataSentEventHandler& dataSentEventHandler) { m_onDataSent = dataSentEventHandler; }
            inline void SetDataSentEventHandler(DataSentEventHandler&& dataSentEventHandler) { m_onDataSent = std::move(dataSentEventHandler); }
 
 
            inline void SetContinueRequestHandle(const ContinueRequestHandler& continueRequestHandler) { m_continueRequest = continueRequestHandler; }
            inline void SetContinueRequestHandle(ContinueRequestHandler&& continueRequestHandler) { m_continueRequest = std::move(continueRequestHandler); }
 
            inline const HeadersReceivedEventHandler & GetHeadersReceivedEventHandler() const { return m_onHeadersReceived; }
            inline const DataReceivedEventHandler& GetDataReceivedEventHandler() const { return m_onDataReceived; }
            inline const DataSentEventHandler& GetDataSentEventHandler() const { return m_onDataSent; }
 
            inline const ContinueRequestHandler& GetContinueRequestHandler() const { return m_continueRequest; }
 
            inline const Aws::String& GetSigningAccessKey() const { return m_signingAccessKey; }
            inline void SetSigningAccessKey(const Aws::String& accessKey) { m_signingAccessKey = accessKey; }
 
            inline const Aws::String& GetSigningRegion() const { return m_signingRegion; }
            inline void SetSigningRegion(const Aws::String& region) { m_signingRegion = region; }
 
            inline const Aws::Crt::Optional<Aws::Utils::DateTime>& GetSigningTimestampOverride() const { return m_signingTimestampOverride; }
            inline void SetSigningTimestampOverride(const Aws::Utils::DateTime& signingTime) { m_signingTimestampOverride = signingTime; }
 
            virtual void AddRequestMetric(const Aws::String& key, int64_t value) { m_httpRequestMetrics.emplace(key, value); }
 
            virtual void SetRequestMetrics(const Aws::Monitoring::HttpClientMetricsCollection& collection) { m_httpRequestMetrics = collection; }
 
            virtual const Aws::Monitoring::HttpClientMetricsCollection& GetRequestMetrics() const { return m_httpRequestMetrics; }
 
            Aws::String GetResolvedRemoteHost() const { return m_resolvedRemoteHost; }
            void SetResolvedRemoteHost(const Aws::String& ip) { m_resolvedRemoteHost = ip; }
 
            bool IsEventStreamRequest() const { return m_isEvenStreamRequest; }
            void SetEventStreamRequest(bool eventStreamRequest) { m_isEvenStreamRequest = eventStreamRequest; }
            
            bool HasEventStreamResponse() const { return m_hasEvenStreamResponse; }
            void SetHasEventStreamResponse(bool hasEventStreamResponse) { m_hasEvenStreamResponse = hasEventStreamResponse; }
 
            virtual std::shared_ptr<Aws::Crt::Http::HttpRequest> ToCrtHttpRequest();
 
            void SetRequestHash(const Aws::String& algorithmName, const std::shared_ptr<Aws::Utils::Crypto::Hash>& hash)
            {
                m_requestHash = std::make_pair(algorithmName, hash);
            }
            const std::pair<Aws::String, std::shared_ptr<Aws::Utils::Crypto::Hash>>& GetRequestHash() const { return m_requestHash; }
 
            void AddResponseValidationHash(const Aws::String& algorithmName, const std::shared_ptr<Aws::Utils::Crypto::Hash>& hash)
            {
                m_responseValidationHashes.emplace_back(algorithmName, hash);
            }
            const Aws::Vector<std::pair<Aws::String, std::shared_ptr<Aws::Utils::Crypto::Hash>>>& GetResponseValidationHashes() const { return m_responseValidationHashes; }
 
            inline void SetServiceSpecificParameters(const std::shared_ptr<ServiceSpecificParameters> &serviceSpecificParameters) { m_serviceSpecificParameters = serviceSpecificParameters; }
 
            inline std::shared_ptr<ServiceSpecificParameters> GetServiceSpecificParameters() { return m_serviceSpecificParameters; }
 
        private:
            URI m_uri;
            HttpMethod m_method;
            bool m_isEvenStreamRequest = false;
            bool m_hasEvenStreamResponse{false};
            HeadersReceivedEventHandler m_onHeadersReceived;
            DataReceivedEventHandler m_onDataReceived;
            DataSentEventHandler m_onDataSent;
            ContinueRequestHandler m_continueRequest;
            Aws::String m_signingRegion;
            Aws::Crt::Optional<Aws::Utils::DateTime> m_signingTimestampOverride;
            Aws::String m_signingAccessKey;
            Aws::String m_resolvedRemoteHost;
            Aws::Monitoring::HttpClientMetricsCollection m_httpRequestMetrics;
            std::pair<Aws::String, std::shared_ptr<Aws::Utils::Crypto::Hash>> m_requestHash;
            Aws::Vector<std::pair<Aws::String, std::shared_ptr<Aws::Utils::Crypto::Hash>>> m_responseValidationHashes;
            std::shared_ptr<ServiceSpecificParameters> m_serviceSpecificParameters;
        };
 
    } // namespace Http
} // namespace Aws