HttpRetrySystem.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/Set.h"
#include "Containers/UnrealString.h"
#include "CoreMinimal.h"
#include "HAL/PlatformCrt.h"
#include "HAL/PlatformMath.h"
#include "HttpRequestAdapter.h"
#include "Interfaces/IHttpRequest.h"
#include "Logging/LogVerbosity.h"
#include "Misc/Optional.h"
#include "Templates/Atomic.h"
#include "Templates/SharedPointer.h"
#include "Templates/UnrealTemplate.h"
#include "UObject/NameTypes.h"
 
namespace FHttpRetrySystem
{
    class FManager;
 
    typedef uint32 RetryLimitCountType;
    typedef double RetryTimeoutRelativeSecondsType;
 
    inline RetryLimitCountType             RetryLimitCount(uint32 Value) { return Value; }
    inline RetryTimeoutRelativeSecondsType RetryTimeoutRelativeSeconds(double Value) { return Value; }
 
    template <typename  IntrinsicType>
    IntrinsicType TZero();
 
    template <> inline float                           TZero<float>() { return 0.0f; }
    template <> inline RetryLimitCountType             TZero<RetryLimitCountType>() { return RetryLimitCount(0); }
    template <> inline RetryTimeoutRelativeSecondsType TZero<RetryTimeoutRelativeSecondsType>() { return RetryTimeoutRelativeSeconds(0.0); }
 
    typedef TOptional<float>                           FRandomFailureRateSetting;
    typedef TOptional<RetryLimitCountType>             FRetryLimitCountSetting;
    typedef TOptional<RetryTimeoutRelativeSecondsType> FRetryTimeoutRelativeSecondsSetting;
    typedef TSet<int32> FRetryResponseCodes;
    typedef TSet<FName> FRetryVerbs;
 
    struct FRetryDomains
    {
        FRetryDomains(TArray<FString>&& InDomains)
            : Domains(MoveTemp(InDomains))
            , ActiveIndex(0)
        {}
 
        TArray<FString> Domains;
        TAtomic<int32> ActiveIndex;
    };
    typedef TSharedPtr<FRetryDomains, ESPMode::ThreadSafe> FRetryDomainsPtr;
 
    struct FExponentialBackoffCurve
    {
        float Base = 2.0f;
        float ExponentBias = 1.0f;
        float MinCoefficient = 0.5f;
        float MaxCoefficient = 1.0f;
        float MaxBackoffSeconds = 60.0f;
 
        HTTP_API bool IsValid() const;
        HTTP_API float Compute(uint32 RetryNumber) const;
    };
 
    TOptional<double> HTTP_API ReadThrottledTimeFromResponseInSeconds(FHttpResponsePtr Response);
};
 
 
namespace FHttpRetrySystem
{
    class FRequest
        : public FHttpRequestAdapterBase
    {
    public:
        struct EStatus
        {
            enum Type
            {
                NotStarted = 0,
                Processing,
                ProcessingLockout,
                Cancelled,
                FailedRetry,
                FailedTimeout,
                Succeeded
            };
        };
 
    public:
        // IHttpRequest interface
        HTTP_API virtual bool ProcessRequest() override;
        HTTP_API virtual void CancelRequest() override;
 
        // FRequest
        EStatus::Type GetRetryStatus() const { return RetryStatus; }
 
    protected:
        friend class FManager;
 
        HTTP_API FRequest(
            TSharedRef<FManager> InManager,
            const TSharedRef<IHttpRequest>& HttpRequest,
            const FRetryLimitCountSetting& InRetryLimitCountOverride = FRetryLimitCountSetting(),
            const FRetryTimeoutRelativeSecondsSetting& InRetryTimeoutRelativeSecondsOverride = FRetryTimeoutRelativeSecondsSetting(),
            const FRetryResponseCodes& InRetryResponseCodes = FRetryResponseCodes(),
            const FRetryVerbs& InRetryVerbs = FRetryVerbs(),
            const FRetryDomainsPtr& InRetryDomains = FRetryDomainsPtr(),
            const FRetryLimitCountSetting& InRetryLimitCountForConnectionErrorOverride = FRetryLimitCountSetting(),
            const FExponentialBackoffCurve& InExponentialBackoffCurve = FExponentialBackoffCurve()
        );
 
        void HttpOnRequestProgress(FHttpRequestPtr InHttpRequest, uint64 BytesSent, uint64 BytesRcv);
        void HttpOnProcessRequestComplete(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded);
        void HttpOnStatusCodeReceived(FHttpRequestPtr Request, int32 StatusCode);
        void HttpOnHeaderReceived(FHttpRequestPtr Request, const FString& HeaderName, const FString& NewHeaderValue);
 
        void SetUrlFromRetryDomains();
        void MoveToNextRetryDomain();
 
        void BindAdaptorDelegates();
 
        EStatus::Type RetryStatus;
 
        FRetryLimitCountSetting RetryLimitCountOverride;
        FRetryLimitCountSetting RetryLimitCountForConnectionErrorOverride;
        FRetryTimeoutRelativeSecondsSetting  RetryTimeoutRelativeSecondsOverride;
        FRetryResponseCodes RetryResponseCodes;
        FRetryVerbs RetryVerbs;
        FRetryDomainsPtr RetryDomains;
        int32 RetryDomainsIndex = 0;
        FString OriginalUrl;
 
        TWeakPtr<FManager> RetryManager;
        FHttpResponsePtr LastResponse;
        bool bLastSucceeded = false;
 
        FExponentialBackoffCurve RetryExponentialBackoffCurve;
 
        bool bBoundAdaptorDelegates = false;
    };
}
 
namespace FHttpRetrySystem
{
 
class FManager : public TSharedFromThis<FManager>
{
public:
    // FManager
    HTTP_API FManager(
        const FRetryLimitCountSetting& InRetryLimitCountDefault, 
        const FRetryTimeoutRelativeSecondsSetting& InRetryTimeoutRelativeSecondsDefault,
        const FRetryLimitCountSetting& InRetryLimitCountForConnectionErrorDefault = FRetryLimitCountSetting()
    );
 
    HTTP_API TSharedRef<class FHttpRetrySystem::FRequest, ESPMode::ThreadSafe> CreateRequest(
        const FRetryLimitCountSetting& InRetryLimitCountOverride = FRetryLimitCountSetting(),
        const FRetryTimeoutRelativeSecondsSetting& InRetryTimeoutRelativeSecondsOverride = FRetryTimeoutRelativeSecondsSetting(),
        const FRetryResponseCodes& InRetryResponseCodes = FRetryResponseCodes(),
        const FRetryVerbs& InRetryVerbs = FRetryVerbs(),
        const FRetryDomainsPtr& InRetryDomains = FRetryDomainsPtr(),
        const FRetryLimitCountSetting& InRetryLimitCountForConnectionErrorOverride = FRetryLimitCountSetting(),
        const FExponentialBackoffCurve & InExponentialBackoffCurve = FExponentialBackoffCurve()
    );
 
    HTTP_API virtual ~FManager();
 
    void SetRandomFailureRate(float Value) { RandomFailureRate = FRandomFailureRateSetting(Value); }
    void SetDefaultRetryLimit(uint32 Value) { RetryLimitCountDefault = FRetryLimitCountSetting(Value); }
 
    // @return Block the current process until all requests are flushed, or timeout has elapsed
    HTTP_API void BlockUntilFlushed(float TimeoutSec);
 
protected:
    friend class FRequest;
 
    struct FHttpRetryRequestEntry
    {
        FHttpRetryRequestEntry(TSharedRef<FRequest, ESPMode::ThreadSafe>& InRequest);
 
        bool bShouldCancel;
        uint32 CurrentRetryCount;
        uint32 CurrentRetryCountForConnectionError;
        double RequestStartTimeAbsoluteSeconds;
        double LockoutEndTimeAbsoluteSeconds;
 
        TSharedRef<FRequest, ESPMode::ThreadSafe>   Request;
    };
 
    class FHttpLogVerbosityTracker
    {
    public:
        FHttpLogVerbosityTracker();
        ~FHttpLogVerbosityTracker();
 
        void IncrementRetriedRequests();
        void DecrementRetriedRequests();
        static FHttpLogVerbosityTracker& Get();
    protected:
        void UpdateSettingsFromConfig();
        void OnConfigSectionsChanged(const FString& IniFilename, const TSet<FString>& SectionName);
 
        int32 NumRetriedRequests = 0;
        FCriticalSection NumRetriedRequestsLock;
        ELogVerbosity::Type OriginalVerbosity = ELogVerbosity::Error;
        ELogVerbosity::Type TargetVerbosity = ELogVerbosity::NoLogging;
    };
 
    bool ProcessRequest(TSharedRef<FRequest, ESPMode::ThreadSafe>& HttpRequest);
    void CancelRequest(TSharedRef<FRequest, ESPMode::ThreadSafe>& HttpRequest);
 
    // @return true if there is a no formal response to the request
    // @TODO return true if a variety of 5xx errors are the result of a formal response
    bool ShouldRetry(const FHttpRetryRequestEntry& HttpRetryRequestEntry) const;
 
    // @return true if retry chances have not been exhausted
    bool CanRetry(const FHttpRetryRequestEntry& HttpRetryRequestEntry) const;
 
    // @return true if the retry request has timed out
    bool HasTimedOut(const FHttpRetryRequestEntry& HttpRetryRequestEntry, const double NowAbsoluteSeconds);
 
    void RetryHttpRequest(FHttpRetryRequestEntry& RequestEntry);
 
    void RetryHttpRequestWithDelay(FManager::FHttpRetryRequestEntry& RequestEntry, float InDelay, bool bWasSucceeded);
 
    void HttpRequestTimeoutAfterDelay(FManager::FHttpRetryRequestEntry& RequestEntry, bool bWasSucceeded, float Delay);
 
    // @return number of seconds to lockout for
    float GetLockoutPeriodSeconds(const FHttpRetryRequestEntry& HttpRetryRequestEntry);
 
    bool RetryLimitForConnectionErrorIsSet(const FHttpRetryRequestEntry& HttpRetryRequestEntry) const;
    bool CanRetryForConnectionError(const FHttpRetryRequestEntry& HttpRetryRequestEntry) const;
    bool CanRetryInGeneral(const FHttpRetryRequestEntry& HttpRetryRequestEntry) const;
 
    // Default configuration for the retry system
    FRandomFailureRateSetting RandomFailureRate;
    FRetryLimitCountSetting RetryLimitCountDefault;
    FRetryLimitCountSetting RetryLimitCountForConnectionErrorDefault;
    FRetryTimeoutRelativeSecondsSetting RetryTimeoutRelativeSecondsDefault;
 
    TArray<FHttpRetryRequestEntry> RequestList;
    FCriticalSection RequestListLock;
};
 
}