OnDemandHttpClient.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Async/RecursiveMutex.h"
#include "Containers/AnsiString.h"
#include "Containers/StringView.h"
#include "Containers/UnrealString.h"
#include "IO/Http/Client.h"
#include "IO/IoBuffer.h"
#include "IO/IoOffsetLength.h"
#include "IO/IoStatus.h"
#include "IO/OnDemandHostGroup.h"
#include "Misc/EnumClassFlags.h"
#include "Templates/Function.h"
#include "Templates/UniquePtr.h"
 
// When NO_LOGGING is enabled, then log categories will change type to 'FNoLoggingCategory' which does
// not inherit from 'FLogCategoryBase' so in order to keep code compiling we need to be able to switch
// types as well.
#if !NO_LOGGING
    #define UE_LOG_CATEGORY_TYPE FLogCategoryBase
#else
    #define UE_LOG_CATEGORY_TYPE FNoLoggingCategory
#endif 
 
namespace UE::IoStore
{
 
namespace HTTP { class FTicketStatus; }
 
FIoBuffer JoinIoBuffers(const FIoBuffer& LHS, const FIoBuffer& RHS);
 
FIoStatus LoadDefaultHttpCertificates(bool& bWasLoaded);
 
inline bool IsHttpStatusOk(uint32 StatusCode)
{
    return StatusCode >= 200 && StatusCode < 300;
}
 
inline bool IsHttpServerError(uint32 StatusCode)
{
    return StatusCode >= 500 && StatusCode < 600;
}
 
enum class EHttpRedirects
{
    Disabled,
    Follow
};
 
struct FMultiEndpointHttpClientConfig
{
    int32                       MaxConnectionCount = 4;
    int32                       ReceiveBufferSize = -1;
    int32                       SendBufferSize = -1;
    int32                       MaxRetryCount = -1; // Positive: The number of times to retry a failed request
                                                    // Zero: Failed requests will not be retried
                                                    // Negative: A failed request will retry once per provided host url
    int32                       TimeoutMs = 0;
    EHttpRedirects              Redirects = EHttpRedirects::Follow;
    bool                        bEnableThreadSafetyChecks = false;
    bool                        bAllowChunkedTransfer = true;
    bool                        bResponseBodyOnError = false;
    const UE_LOG_CATEGORY_TYPE* LogCategory = nullptr;
    ELogVerbosity::Type         LogVerbosity = ELogVerbosity::Log;
};
 
enum class EMultiEndpointRequestFlags : uint8
{
    None,
    ResponseHeaders
};
ENUM_CLASS_FLAGS(EMultiEndpointRequestFlags);
 
struct FMultiEndpointHttpClientResponse
{
    bool IsOk() const
    {
        return IsHttpStatusOk(StatusCode);
    }
 
    bool IsCanceled() const
    {
        return bCanceled;
    }
 
    FIoBuffer                   Body;
    TArray<FAnsiString>         Headers;
    FString                     Reason;
    HTTP::FTicketPerf::FSample  Sample;
    uint64                      DurationMilliseconds = 0;
    uint32                      StatusCode = 0;
    uint32                      RetryCount = 0;
    int32                       HostIndex = INDEX_NONE;
    bool                        bCanceled = false;
    int8                        CDNCacheStatus = -1;
};
 
class FMultiEndpointHttpClient
{
public:
    UE_NONCOPYABLE(FMultiEndpointHttpClient);
 
    using FHttpTicketId = uint32;
    using FOnHttpResponse = TFunction<void(FMultiEndpointHttpClientResponse&&)>;
 
    ~FMultiEndpointHttpClient();
 
    [[nodiscard]] static TUniquePtr<FMultiEndpointHttpClient> Create(const FMultiEndpointHttpClientConfig& Config);
 
    [[nodiscard]] static TIoStatusOr<FMultiEndpointHttpClientResponse> Get(FAnsiStringView Url, const FMultiEndpointHttpClientConfig& Config);
 
    [[nodiscard]] FHttpTicketId Get(const FOnDemandHostGroup& HostGroup, FAnsiStringView RelativeUrl, FOnHttpResponse&& OnResponse);
    [[nodiscard]] FHttpTicketId Get(const FOnDemandHostGroup& HostGroup, FAnsiStringView RelativeUrl, const FIoOffsetAndLength& ChunkRange, FOnHttpResponse&& OnResponse);
    [[nodiscard]] FHttpTicketId Get(const FOnDemandHostGroup& HostGroup, FAnsiStringView RelativeUrl, const FIoOffsetAndLength& ChunkRange, TArray<FAnsiString>&& Headers, EMultiEndpointRequestFlags Flags, FOnHttpResponse&& OnResponse);
 
    bool Tick(int32 WaitTimeMs, uint32 MaxKiBPerSecond);
    bool Tick()
    {
        return Tick(-1, 0);
    }
 
    void CancelRequest(FHttpTicketId TicketId);
 
    void UpdateConnections();
 
private:
    using FHttpConnectionPools = TArray<TUniquePtr<HTTP::FConnectionPool>, TInlineAllocator<4>>;
 
    struct FConnection
    {
        FOnDemandHostGroup      HostGroup;
        FHttpConnectionPools    Pools;
        int32                   CurrentHost = INDEX_NONE;
    };
 
    struct FRequest
    {
        FOnHttpResponse             OnResponse;
        TArray<FAnsiString>         RequestHeaders;
        TArray<FAnsiString>         ResponseHeaders;
        FAnsiString                 RelativeUrl;
        FIoOffsetAndLength          Range;
        FHttpTicketId               TicketId = 0;
        FConnection&                Connection;
        FIoBuffer                   Body;
        FIoBuffer                   Chunk;
        FString                     ResponseMessage;
        uint64                      StartTime = 0;
        uint32                      RetryCount = 0;
        uint32                      StatusCode = 0;
        int32                       Host = INDEX_NONE;
        EMultiEndpointRequestFlags  Flags = EMultiEndpointRequestFlags::None;
        bool                        bIsChunkedTransfer = false;
        int8                        CDNCacheStatus = -1;
 
#if DO_CHECK
        int32               SinkCounter = 0;
#endif // DO_CHECK
    };
 
                                        FMultiEndpointHttpClient(const FMultiEndpointHttpClientConfig& Config);
 
    FHttpTicketId                       IssueRequest(FRequest&& Request);
    void                                CompleteRequest(FRequest&& Request, const UE::IoStore::HTTP::FTicketStatus& TicketStatus);
    void                                RetryRequest(FRequest&& Request);
 
    void                                ProcessRetryAttempts(uint32 TicketCount);
 
    TUniquePtr<HTTP::FConnectionPool>   CreateConnection(FAnsiStringView HostUrl) const;
    FConnection&                        GetConnection(const FOnDemandHostGroup& HostGroup);
    FConnection*                        FindConnection(const FOnDemandHostGroup& HostGroup);
 
    uint32                              GetRetryLimitForRequest(const FRequest& Request) const;
 
    void                                Log(const FRequest& Request, const HTTP::FTicketStatus& TicketStatus) const;
 
    FMultiEndpointHttpClientConfig      Config;
    TArray<TUniquePtr<FConnection>>     Connections;
    HTTP::FEventLoop                    EventLoop;
    TArray<FRequest>                    Retries;
    struct FTicketInfo
    {
        HTTP::FTicket HttpTicket;
        bool bCancelRequested = false;
    };
 
    UE::FRecursiveMutex                 TicketLookupMutex;
    TMap<FHttpTicketId, FTicketInfo>    TicketLookupMap;
 
};
 
} // namespace UE::IoStore
 
#undef UE_LOG_CATEGORY_TYPE