HttpManager.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/Map.h"
#include "Containers/Queue.h"
#include "Containers/Ticker.h"
#include "Containers/Ticker.h"
#include "Containers/UnrealString.h"
#include "Containers/Utf8String.h"
#include "CoreMinimal.h"
#include "CoreTypes.h"
#include "HAL/CriticalSection.h"
#include "HttpPackage.h"
#include "Interfaces/IHttpRequest.h"
#include "Misc/EnumRange.h"
#include "Misc/URLRequestFilter.h"
#include "Templates/Function.h"
#include "Templates/SharedPointer.h"
 
class FHttpThreadBase;
class FHttpRequestCommon;
class FOutputDevice;
class IHttpTaskTimerHandle;
 
enum class EHttpFlushReason : uint8
{
    Default,
    Shutdown,
    FullFlush,
    Count
};
ENUM_RANGE_BY_COUNT(EHttpFlushReason, EHttpFlushReason::Count)
const TCHAR* LexToString(const EHttpFlushReason& FlushReason);
 
DECLARE_DELEGATE_OneParam(FHttpManagerRequestAddedDelegate, const FHttpRequestRef& /*Request*/);
 
DECLARE_DELEGATE_OneParam(FHttpManagerRequestCompletedDelegate, const FHttpRequestRef& /*Request*/);
 
struct FHttpStatsPlatformMemoryPool
{
    uint64 PoolSize = 0;
    uint64 MaxInUseSize = 0;
    uint64 CurrentInUseSize = 0;
};
 
struct FHttpStatsPlatform
{
    FHttpStatsPlatformMemoryPool MemoryPoolConnection;
    FHttpStatsPlatformMemoryPool MemoryPoolSsl;
    FHttpStatsPlatformMemoryPool MemoryPoolNet;
};
 
struct FHttpStats
{
    // Use atomic for the following fields because csv profiler reads them from game thread while 
    // http thread record them from http thread
 
    std::atomic<int32> RequestsInQueue = 0;
    std::atomic<int32> RequestsInFlight = 0;
    std::atomic<float> MaxTimeToConnect = -1.0f;
    std::atomic<uint32> MaxRequestsInQueue = 0;
    std::atomic<uint32> MaxRequestsInFlight = 0;
    std::atomic<float> MaxTimeToWaitInQueue = 0.0f;
    std::atomic<int64> TotalDownloadedBytes = 0;
    std::atomic<int64> BandwidthMbps = 0;
    std::atomic<int64> HttpDurationMsAvg = 0;
    TOptional<FHttpStatsPlatform> PlatformStats;
 
    FHttpStats()
    {
    }
 
    FHttpStats(const FHttpStats& Other)
        : RequestsInQueue(Other.RequestsInQueue.load())
        , RequestsInFlight(Other.RequestsInFlight.load())
        , MaxTimeToConnect(Other.MaxTimeToConnect.load())
        , MaxRequestsInQueue(Other.MaxRequestsInQueue.load())
        , MaxRequestsInFlight(Other.MaxRequestsInFlight.load())
        , MaxTimeToWaitInQueue(Other.MaxTimeToWaitInQueue.load())
        , TotalDownloadedBytes(Other.TotalDownloadedBytes.load())
        , BandwidthMbps(Other.BandwidthMbps.load())
        , HttpDurationMsAvg(Other.HttpDurationMsAvg.load())
        , PlatformStats(Other.PlatformStats)
    {
    }
};
 
class FHttpManager
    : public FTSTickerObjectBase
{
public:
 
    // FHttpManager
 
    HTTP_API FHttpManager();
 
    HTTP_API virtual ~FHttpManager();
 
    HTTP_API void Initialize();
 
    HTTP_API void Shutdown();
 
    HTTP_API void SetRequestAddedDelegate(const FHttpManagerRequestAddedDelegate& Delegate);
 
    HTTP_API void SetRequestCompletedDelegate(const FHttpManagerRequestCompletedDelegate& Delegate);
 
    HTTP_API void RemoveRequest(const FHttpRequestRef& Request);
 
    HTTP_API bool IsValidRequest(const IHttpRequest* RequestPtr) const;
 
    HTTP_API void Flush(EHttpFlushReason FlushReason);
 
    HTTP_API bool Tick(float DeltaSeconds) override;
 
    HTTP_API virtual void FlushTick(float DeltaSeconds);
 
    HTTP_API void AddThreadedRequest(const TSharedRef<FHttpRequestCommon, ESPMode::ThreadSafe>& Request);
 
    HTTP_API void CancelThreadedRequest(const TSharedRef<FHttpRequestCommon, ESPMode::ThreadSafe>& Request);
 
    HTTP_API void DumpRequests(FOutputDevice& Ar) const;
 
    HTTP_API virtual bool SupportsDynamicProxy() const;
 
    HTTP_API void SetCorrelationIdMethod(TFunction<FString()> InCorrelationIdMethod);
 
    HTTP_API FString CreateCorrelationId() const;
 
    HTTP_API bool IsDomainAllowed(const FString& Url) const;
 
    static HTTP_API TFunction<FString()> GetDefaultCorrelationIdMethod();
 
    HTTP_API virtual void OnBeforeFork();
 
    HTTP_API virtual void OnAfterFork();
 
    HTTP_API virtual void OnEndFramePostFork();
 
 
    HTTP_API virtual void UpdateConfigs();
 
    HTTP_API void AddGameThreadTask(TFunction<void()>&& Task, float Delay = 0.0f);
 
    HTTP_API TSharedPtr<IHttpTaskTimerHandle> AddHttpThreadTask(TFunction<void()>&& Task, float InDelay = 0.0f);
 
    HTTP_API void RemoveHttpThreadTask(TSharedPtr<IHttpTaskTimerHandle> HttpTaskTimerHandle);
 
    void SetURLRequestFilter(const UE::Core::FURLRequestFilter& InURLRequestFilter) { URLRequestFilter = InURLRequestFilter; }
 
    FHttpStats GetHttpStats() const { return HttpStats; }
 
protected:
    HTTP_API virtual FHttpThreadBase* CreateHttpThread();
 
    HTTP_API void ReloadFlushTimeLimits();
 
    HTTP_API bool HasAnyBoundDelegate() const;
 
    HTTP_API void UpdateUrlPatternsToLogResponse(IConsoleVariable* CVar);
    HTTP_API void UpdateUrlPatternsToDisableFailedLog(IConsoleVariable* CVar);
    HTTP_API void UpdateUrlPatternsToMockResponse(IConsoleVariable* CVar);
 
protected:
    TArray<FHttpRequestRef> Requests;
 
    FHttpThreadBase* Thread;
 
    TFunction<FString()> CorrelationIdMethod;
 
    FTSTicker GameThreadTicker;
    FCriticalSection GameThreadTickerLock;
 
    // This variable is set to true in Flush(EHttpFlushReason), and prevents new Http requests from being launched
    bool bFlushing;
 
    FHttpManagerRequestAddedDelegate RequestAddedDelegate;
 
    FHttpManagerRequestCompletedDelegate RequestCompletedDelegate;
 
    UE::Core::FURLRequestFilter URLRequestFilter;
 
    struct FHttpFlushTimeLimit
    {
        double SoftLimitSeconds;
 
        double HardLimitSeconds;
 
        FHttpFlushTimeLimit(double InSoftLimitSeconds, double InHardLimitSeconds)
            : SoftLimitSeconds(InSoftLimitSeconds), HardLimitSeconds(InHardLimitSeconds)
        {}
    };
 
    TMap<EHttpFlushReason, FHttpFlushTimeLimit> FlushTimeLimitsMap;
 
    FHttpStats HttpStats;
    struct FHttpStatsHistory
    {
        static constexpr int32 HttpHistoryCount = 16;
        int32 HistoryIndex = 0;
 
        int64 DownloadedBytes[HttpHistoryCount] = { 0 };
        int64 DurationMs[HttpHistoryCount] = { 0 };
 
        int64 TotalDownloadedBytes = 0;
        int64 TotalUploadedBytes = 0;
        int64 TotalDuration = 0;
    };
    FHttpStatsHistory HttpStatsHistory;
 
    bool bUseEventLoop = true;
 
    TArray<FString> UrlPatternsToLogResponse;
    mutable FCriticalSection UrlPatternsToLogResponseCriticalSection;
 
    TArray<FString> UrlPatternsToDisableFailedLog;
    mutable FCriticalSection UrlPatternsToDisableFailedLogCriticalSection;
 
#if !UE_BUILD_SHIPPING
    mutable FCriticalSection ThreadsCompletingRequestCriticalSection;
    TMap<uint32, bool> ThreadsCompletingRequest;
#endif
 
PACKAGE_SCOPE:
    struct FMockResponse
    {
        int32 StatusCode = 0;
        FUtf8String ResponsePayload;
        TMap<FString, FString> ResponseHeaders;
    };
 
    struct FUrlToMatch
    {
        FString Str;
        FString Verb;
    };
 
    mutable FCriticalSection RequestLock;
 
    FCriticalSection CompletedRequestLock;
 
    HTTP_API void BroadcastHttpRequestCompleted(const FHttpRequestRef& Request);
 
    HTTP_API FHttpThreadBase* GetThread();
 
    HTTP_API void RecordStatTimeToConnect(float Duration);
 
    HTTP_API void RecordStatRequestsInFlight(uint32 RequestsInFlight);
 
    HTTP_API void RecordStatRequestsInQueue(uint32 RequestsInQueue);
 
    HTTP_API void RecordMaxTimeToWaitInQueue(float Duration);
 
    HTTP_API void RecordPlatformStats(const FHttpStatsPlatform& PlatformStats);
 
    HTTP_API bool ShouldLogResponse(FStringView Url) const;
    HTTP_API bool ShouldDisableFailedLog(FStringView Url) const;
 
    HTTP_API TOptional<FMockResponse> GetMockResponse(FStringView Url, FStringView Verb) const;
 
    HTTP_API void MarkCurrentThreadCompletingRequest(bool bCompleting);
    HTTP_API bool IsCurrentThreadCompletingRequest() const;
 
    HTTP_API void AddRequest(const FHttpRequestRef& Request);
 
protected:
    TArray<TPair<FUrlToMatch, FMockResponse>> UrlPatternsToMockResponse;
    mutable FCriticalSection UrlPatternsToMockResponseCriticalSection;
};