HttpClient.h

 
#pragma once
 
#include <aws/core/Core_EXPORTS.h>
#include <aws/core/http/HttpConnection.h>
#include <aws/core/utils/Outcome.h>
#include <aws/core/client/AWSError.h>
 
#include <atomic>
#include <condition_variable>
#include <functional>
#include <memory>
#include <mutex>
 
namespace Aws
{
    namespace Utils
    {
        namespace RateLimits
        {
            class RateLimiterInterface;
        } // namespace RateLimits
 
        namespace Threading
        {
            class Executor;
        } // namespace Threading
    } // namespace Utils
 
    namespace Http
    {
        class HttpRequest;
        class HttpResponse;
 
        class AWS_CORE_API HttpClient
        {
        public:
            HttpClient();
            virtual ~HttpClient() {}
 
            virtual std::shared_ptr<HttpResponse> MakeRequest(const std::shared_ptr<HttpRequest>& request,
                Aws::Utils::RateLimits::RateLimiterInterface* readLimiter = nullptr,
                Aws::Utils::RateLimits::RateLimiterInterface* writeLimiter = nullptr) const = 0;
 
            virtual bool SupportsChunkedTransferEncoding() const { return true; }
 
            virtual bool IsDefaultAwsHttpClient() const { return false; }
 
            void DisableRequestProcessing();
            void EnableRequestProcessing();
            bool IsRequestProcessingEnabled() const;
            void RetryRequestSleep(std::chrono::milliseconds sleepTime);
 
            bool ContinueRequest(const Aws::Http::HttpRequest&) const;
 
            explicit operator bool() const
            {
               return !m_bad;
            }
 
            virtual Aws::Crt::Optional<Aws::Client::AWSError<Aws::Client::CoreErrors>> AcquireConnection(
                const std::shared_ptr<HttpRequest>& request,
                const std::function<void(std::shared_ptr<Aws::Http::Connection>, int)>& onClientConnectionAvailable) {
              AWS_UNREFERENCED_PARAM(request);
              AWS_UNREFERENCED_PARAM(onClientConnectionAvailable);
              return Aws::Client::AWSError<Aws::Client::CoreErrors>{Aws::Client::CoreErrors::NOT_IMPLEMENTED,
                "NotImplemented",
                "creating a connection is not supported on this http client",
                false};
            }
 
            struct AttemptOutcome
            {
                bool shouldRetry;
                std::chrono::milliseconds backoff;
            };
 
            using PrepareAttempt = std::function<std::shared_ptr<HttpRequest>()>;
            using EvaluateAttempt = std::function<AttemptOutcome(std::shared_ptr<HttpResponse>)>;
            using OnRetryableRequestComplete = std::function<void()>;
 
            virtual Aws::Crt::Optional<Aws::Client::AWSError<Aws::Client::CoreErrors>> MakeRequestAsync(
                const PrepareAttempt& prepareAttempt,
                const EvaluateAttempt& evaluateAttempt,
                const OnRetryableRequestComplete& onComplete,
                std::shared_ptr<Aws::Utils::Threading::Executor> executor) const {
              AWS_UNREFERENCED_PARAM(prepareAttempt);
              AWS_UNREFERENCED_PARAM(evaluateAttempt);
              AWS_UNREFERENCED_PARAM(onComplete);
              AWS_UNREFERENCED_PARAM(executor);
              return Aws::Client::AWSError<Aws::Client::CoreErrors>{Aws::Client::CoreErrors::NOT_IMPLEMENTED,
                "NotImplemented",
                "async requests are not supported on this http client",
                false};
            }
 
        protected:
            bool m_bad;
 
        private:
 
            std::atomic< bool > m_disableRequestProcessing;
            std::mutex m_requestProcessingSignalLock;
            std::condition_variable m_requestProcessingSignal;
        };
 
    } // namespace Http
} // namespace Aws