RetryStrategy.h

 
#pragma once
 
#include <aws/core/Core_EXPORTS.h>
#include <aws/core/utils/threading/ReaderWriterLock.h>
#include <memory>
 
namespace Aws
{
    namespace Http
    {
        class HttpResponse;
    }
 
    namespace Utils
    {
        template<typename R, typename E>
        class Outcome;
    }
 
    namespace Client
    {
        static const int NO_RETRY_INCREMENT = 1;
 
        enum class CoreErrors;
        template<typename ERROR_TYPE>
        class AWSError;
 
        typedef Utils::Outcome<std::shared_ptr<Aws::Http::HttpResponse>, AWSError<CoreErrors>> HttpResponseOutcome;
 
        class AWS_CORE_API RetryStrategy
        {
        public:
            virtual ~RetryStrategy() = default;
            virtual bool ShouldRetry(const AWSError<CoreErrors>& error, long attemptedRetries) const = 0;
 
            virtual long CalculateDelayBeforeNextRetry(const AWSError<CoreErrors>& error, long attemptedRetries) const = 0;
 
            virtual long GetMaxAttempts() const { return 0; }
 
            virtual void GetSendToken() {}
 
            virtual bool HasSendToken()
            {
                GetSendToken();  // first call old method for backward compatibility
                return true;
            }
 
            virtual void RequestBookkeeping(const HttpResponseOutcome& /* httpResponseOutcome */) {}
            virtual void RequestBookkeeping(const HttpResponseOutcome& /* httpResponseOutcome */, const AWSError<CoreErrors>& /* lastError */) {}
 
            virtual const char* GetStrategyName() const
            {
                // SDK provided strategies will provide actual name
                return "custom";
            }
        };
 
        class AWS_CORE_API RetryQuotaContainer
        {
        public:
            virtual ~RetryQuotaContainer() = default;
            virtual bool AcquireRetryQuota(int capacityAmount) = 0;
            virtual bool AcquireRetryQuota(const AWSError<CoreErrors>& error) = 0;
            virtual void ReleaseRetryQuota(int capacityAmount) = 0;
            virtual void ReleaseRetryQuota(const AWSError<CoreErrors>& lastError) = 0;
            virtual int GetRetryQuota() const = 0;
        };
 
        class AWS_CORE_API DefaultRetryQuotaContainer : public RetryQuotaContainer
        {
        public:
            DefaultRetryQuotaContainer();
            virtual ~DefaultRetryQuotaContainer() = default;
            virtual bool AcquireRetryQuota(int capacityAmount) override;
            virtual bool AcquireRetryQuota(const AWSError<CoreErrors>& error) override;
            virtual void ReleaseRetryQuota(int capacityAmount) override;
            virtual void ReleaseRetryQuota(const AWSError<CoreErrors>& lastError) override;
            virtual int GetRetryQuota() const override { return m_retryQuota; }
 
        protected:
            mutable Aws::Utils::Threading::ReaderWriterLock m_retryQuotaLock;
            int m_retryQuota;
        };
 
        class AWS_CORE_API StandardRetryStrategy : public RetryStrategy
        {
        public:
            StandardRetryStrategy(long maxAttempts = 3);
            StandardRetryStrategy(std::shared_ptr<RetryQuotaContainer> retryQuotaContainer, long maxAttempts = 3);
 
            virtual void RequestBookkeeping(const HttpResponseOutcome& httpResponseOutcome) override;
            virtual void RequestBookkeeping(const HttpResponseOutcome& httpResponseOutcome, const AWSError<CoreErrors>& lastError) override;
 
            virtual bool ShouldRetry(const AWSError<CoreErrors>& error, long attemptedRetries) const override;
 
            virtual long CalculateDelayBeforeNextRetry(const AWSError<CoreErrors>& error, long attemptedRetries) const override;
 
            virtual long GetMaxAttempts() const override { return m_maxAttempts; }
 
            const char* GetStrategyName() const override { return "standard";}
 
        protected:
            std::shared_ptr<RetryQuotaContainer> m_retryQuotaContainer;
            long m_maxAttempts;
        };
    } // namespace Client
} // namespace Aws