HttpThread.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "EventLoop/EventLoopTimer.h"
#include "HAL/ThreadSafeCounter.h"
#include "HAL/Runnable.h"
#include "HttpPackage.h"
#include "Misc/SingleThreadRunnable.h"
#include "Misc/Timespan.h"
#include "Containers/Queue.h"
#include "Containers/SpscQueue.h"
#include "Containers/Ticker.h"
 
#include <atomic>
 
class FHttpRequestCommon;
class FHttpThreadBase;
 
class IHttpTaskTimerHandle
{
public:
    virtual ~IHttpTaskTimerHandle() {};
 
    virtual void RemoveTaskFrom(FHttpThreadBase* HttpThreadBase) = 0;
};
 
class FHttpThreadBase
    : FRunnable, FSingleThreadRunnable
{
public:
 
    FHttpThreadBase();
    virtual ~FHttpThreadBase();
 
    virtual void StartThread();
 
    virtual void StopThread();
 
    bool IsStopped() const { return bIsStopped; }
 
    virtual void AddRequest(FHttpRequestCommon* Request);
 
    virtual void CancelRequest(FHttpRequestCommon* Request);
 
    virtual void GetCompletedRequests(TArray<FHttpRequestCommon*>& OutCompletedRequests);
 
    //~ Begin FSingleThreadRunnable Interface
    virtual void Tick() override;
    //~ End FSingleThreadRunnable Interface
 
    bool NeedsSingleThreadTick() const;
 
    virtual void UpdateConfigs();
 
    virtual TSharedPtr<IHttpTaskTimerHandle> AddHttpThreadTask(TFunction<void()>&& Task, float InDelay) = 0;
 
    virtual void RemoveTimerHandle(FTSTicker::FDelegateHandle DelegateHandle) = 0;
 
    virtual void RemoveTimerHandle(UE::EventLoop::FTimerHandle EventLoopTimerHandle) = 0;
 
protected:
 
    virtual void HttpThreadTick(float DeltaSeconds);
    
    virtual bool StartThreadedRequest(FHttpRequestCommon* Request);
 
    virtual void CompleteThreadedRequest(FHttpRequestCommon* Request);
 
protected:
 
    // Threading functions
 
    //~ Begin FRunnable Interface
    virtual bool Init() override;
    virtual uint32 Run() override;
    virtual void Stop() override;
    virtual void Exit() override;
    //~ End FRunnable Interface
 
    void Process(TArray<FHttpRequestCommon*>& RequestsToCancel, TArray<FHttpRequestCommon*>& RequestsToComplete);
 
    virtual class FSingleThreadRunnable* GetSingleThreadInterface() override { return this; }
 
private:
    void ConsumeCanceledRequestsAndNewRequests(TArray<FHttpRequestCommon*>& RequestsToCancel, TArray<FHttpRequestCommon*>& RequestsToComplete);
    void InsertToRateLimitedRequestsAccordingToPriority(FHttpRequestCommon* Request);
    void MoveCompletingRequestsToCompletedRequests(TArray<FHttpRequestCommon*>& RequestsToComplete);
    void StartRequestsWaitingInQueue(TArray<FHttpRequestCommon*>& RequestsToComplete);
    void FinishRequestsFromHttpThreadWithCallbacks(TArray<FHttpRequestCommon*>& RequestsToComplete);
    void UpdateThreadPriorityIfNeeded();
 
protected:
    FRunnableThread* Thread;
 
private:
    bool bIsSingleThread;
 
    bool bIsStopped;
 
    double LastTime;
 
    EThreadPriority CurrentThreadPriority;
 
    int32 MaxConcurrentRequests;
 
protected:
    TMpscQueue<FHttpRequestCommon*> NewThreadedRequests;
 
    TMpscQueue<FHttpRequestCommon*> CancelledThreadedRequests;
 
    TArray<FHttpRequestCommon*> RateLimitedThreadedRequests;
 
    TArray<FHttpRequestCommon*> RunningThreadedRequests;
 
    TSpscQueue<FHttpRequestCommon*> CompletedThreadedRequests;
};
 
class FLegacyHttpThread : public FHttpThreadBase
{
public:
 
    FLegacyHttpThread();
    virtual ~FLegacyHttpThread();
 
    virtual void StartThread() override final;
    virtual void StopThread() override final;
    virtual void AddRequest(FHttpRequestCommon* Request) override final;
    virtual void CancelRequest(FHttpRequestCommon* Request) override final;
    virtual void GetCompletedRequests(TArray<FHttpRequestCommon*>& OutCompletedRequests) override final;
 
    //~ Begin FSingleThreadRunnable Interface
    // Cannot be overridden to ensure identical behavior with the threaded tick
    virtual void Tick() override final;
    //~ End FSingleThreadRunnable Interface
 
protected:
    //~ Begin FRunnable Interface
    virtual bool Init() override;
    // Cannot be overridden to ensure identical behavior with the single threaded tick
    virtual uint32 Run() override final;
    virtual void Stop() override;
    //~ End FRunnable Interface
 
    virtual TSharedPtr<IHttpTaskTimerHandle> AddHttpThreadTask(TFunction<void()>&& Task, float InDelay) override;
    virtual void HttpThreadTick(float DeltaSeconds) override;
 
    virtual void RemoveTimerHandle(FTSTicker::FDelegateHandle DelegateHandle) override;
    virtual void RemoveTimerHandle(UE::EventLoop::FTimerHandle EventLoopTimerHandle) override;
 
    FThreadSafeCounter ExitRequest;
 
    double HttpThreadActiveFrameTimeInSeconds;
    double HttpThreadActiveMinimumSleepTimeInSeconds;
    double HttpThreadIdleFrameTimeInSeconds;
    double HttpThreadIdleMinimumSleepTimeInSeconds;
 
    /* Ticker for functions to run in HTTP thread */
    FTSTicker Ticker;
};