CloudChunkSource.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "Installer/ChunkSource.h"
#include "Installer/DownloadConnectionCount.h"
#include "Installer/Controllable.h"
#include "BuildPatchManifest.h"
#include "Interfaces/IBuildInstaller.h"
 
enum class EBuildPatchDownloadHealth;
class IBuildInstallerSharedContext;
 
namespace BuildPatchServices
{
    class IPlatform;
    class IChunkStore;
    class IDownloadService;
    class IChunkReferenceTracker;
    class IChunkDataSerialization;
    class IMessagePump;
    class IInstallerError;
    class ICloudChunkSourceStat;
    class IDownloadServiceStatistics;
    class IBuildManifestSet;
 
    struct FConstructorCloudChunkSourceConfig
    {
        // An array of cloud root paths, supporting HTTP(s) and file access. HTTP(s) roots must begin with the protocol.
        TArray<FString> CloudRoots;
        // The maximum number of times that a single chunk should retry, before registering a fatal error.
        // Infinite can be specified as < 0.
        int32 MaxRetryCount = 6;
        // Array of times in seconds, representing the time between each retry upon failure. The last entry will be used
        // indefinitely once it is reached.
        TArray<float> RetryDelayTimes;
        // Configures what success rate values apply to which EBuildPatchDownloadHealth value, there should be
        // EBuildPatchDownloadHealth::NUM_Values entries in this array.
        TArray<float> HealthPercentages;
        // When all requests are failing, how many seconds before a success until we determine the state as disconnected.
        float DisconnectedDelay = 5.0f;
 
        FConstructorCloudChunkSourceConfig(const TArray<FString>& InCloudRoots)
        : CloudRoots(InCloudRoots)
        {
            const float RetryFloats[] = {0.5f, 1.0f, 1.0f, 3.0f, 3.0f, 10.0f, 10.0f, 20.0f, 20.0f, 30.0f};
            RetryDelayTimes.Empty(UE_ARRAY_COUNT(RetryFloats));
            RetryDelayTimes.Append(RetryFloats, UE_ARRAY_COUNT(RetryFloats));
            const float HealthFloats[] = {0.0f, 0.0f, 0.9f, 0.99f, 1.0f};
            check((int32)EBuildPatchDownloadHealth::NUM_Values == UE_ARRAY_COUNT(HealthFloats));
            HealthPercentages.Empty(UE_ARRAY_COUNT(HealthFloats));
            HealthPercentages.Append(HealthFloats, UE_ARRAY_COUNT(HealthFloats));
        }
    };
 
    class IConstructorCloudChunkSource : public IConstructorChunkSource
    {
    public:
        virtual ~IConstructorCloudChunkSource() {}
 
 
        virtual void Abort() = 0;
 
        virtual void Tick(bool bStartNewDownloads, uint32& OutTimeToNextTickMs, uint32 InMaxDownloads) = 0;
 
        // When downloads are complete we need a way to alert the main thread.
        virtual void SetWakeupFunction(TUniqueFunction<void()>&& WakeupMainThreadFn) = 0;
 
        // Pass in total download requirements for the install (including already completed downloads)
        virtual void PostRequiredByteCount(uint64 InDownloadExpected) = 0;
 
        static IConstructorCloudChunkSource* CreateCloudSource(FConstructorCloudChunkSourceConfig&& Configuration, IDownloadService* InDownloadService, 
            IChunkDataSerialization* InChunkDataSerialization, IDownloadConnectionCount* InDownloadCount, IMessagePump* InMessagePump, ICloudChunkSourceStat* InCloudChunkSourceStat, 
            IBuildManifestSet* InManifestSet);
    };
 
    class ICloudChunkSource
        : public IChunkSource
        , public IControllable
    {
    public:
        virtual ~ICloudChunkSource() {}
 
        virtual void ThreadRun() = 0;
    };
 
    struct FCloudSourceConfig
    {
        // An array of cloud root paths, supporting HTTP(s) and file access. HTTP(s) roots must begin with the protocol.
        TArray<FString> CloudRoots;
        // The maximum number of times that a single chunk should retry, before registering a fatal error.
        // Infinite can be specified as < 0.
        int32 MaxRetryCount = 6;
        // The minimum number of chunks to request ahead of what is required, depending on store slack.
        int32 PreFetchMinimum  = 16;
        // The maximum number of chunks to request ahead of what is required, depending on store slack.
        // This shouldn't be too much because we'll queue too many on the same CDN which might not be good and we have to chew 
        // though a ton of requests before we swap over, and we only really want there to be one queued + one ready to go per connection anyway.
        int32 PreFetchMaximum = 32;
        // Array of times in seconds, representing the time between each retry upon failure. The last entry will be used
        // indefinitely once it is reached.
        TArray<float> RetryDelayTimes;
        // Configures what success rate values apply to which EBuildPatchDownloadHealth value, there should be
        // EBuildPatchDownloadHealth::NUM_Values entries in this array.
        TArray<float> HealthPercentages;
        // When all requests are failing, how many seconds before a success until we determine the state as disconnected.
        float DisconnectedDelay = 5.0f;
        // If true, the downloads will not begin until the first Get request is made. It is fairly fundamental to stop downloads of chunks until resume
        // data is processed, but can be special case disabled.
        bool bBeginDownloadsOnFirstGet = true;
        // The minimum time to allow a http download before assessing it as affected by TCP zero window issue.
        float TcpZeroWindowMinimumSeconds = 20.0f;
        // The context for allocating shared resources.
        IBuildInstallerSharedContext* SharedContext = nullptr;
        // Whether cloud source should run its own thread. If true, SharedContext is required.
        bool bRunOwnThread = true;
 
        FCloudSourceConfig(const TArray<FString>& InCloudRoots)
            : CloudRoots(InCloudRoots)
        {
            const float RetryFloats[] = {0.5f, 1.0f, 1.0f, 3.0f, 3.0f, 10.0f, 10.0f, 20.0f, 20.0f, 30.0f};
            RetryDelayTimes.Empty(UE_ARRAY_COUNT(RetryFloats));
            RetryDelayTimes.Append(RetryFloats, UE_ARRAY_COUNT(RetryFloats));
            const float HealthFloats[] = {0.0f, 0.0f, 0.9f, 0.99f, 1.0f};
            check((int32)EBuildPatchDownloadHealth::NUM_Values == UE_ARRAY_COUNT(HealthFloats));
            HealthPercentages.Empty(UE_ARRAY_COUNT(HealthFloats));
            HealthPercentages.Append(HealthFloats, UE_ARRAY_COUNT(HealthFloats));
        }
    };
 
    class FCloudChunkSourceFactory
    {
    public:
 
        static ICloudChunkSource* Create(FCloudSourceConfig Configuration, 
            IPlatform* Platform, 
            IChunkStore* ChunkStore, 
            IDownloadService* DownloadService, 
            IChunkReferenceTracker* ChunkReferenceTracker, 
            IChunkDataSerialization* ChunkDataSerialization, 
            IMessagePump* MessagePump, 
            IInstallerError* InstallerError, 
            IDownloadConnectionCount* InConnectionCount, 
            ICloudChunkSourceStat* CloudChunkSourceStat, 
            IBuildManifestSet* ManifestSet, 
            TSet<FGuid> InitialDownloadSet);
    };
 
    class ICloudChunkSourceStat
    {
    public:
        virtual ~ICloudChunkSourceStat() {}
 
        virtual void OnDownloadRequested(const FGuid& ChunkId) = 0;
 
        virtual void OnDownloadSuccess(const FGuid& ChunkId) = 0;
 
        virtual void OnDownloadFailed(const FGuid& ChunkId, const FString& Url) = 0;
 
        virtual void OnDownloadCorrupt(const FGuid& ChunkId, const FString& Url, EChunkLoadResult LoadResult) = 0;
 
        virtual void OnDownloadAborted(const FGuid& ChunkId, const FString& Url, double DownloadTimeMean, double DownloadTimeStd, double DownloadTime, double BreakingPoint) = 0;
 
        virtual void OnReceivedDataUpdated(int64 TotalBytes) = 0;
 
        virtual void OnRequiredDataUpdated(int64 TotalBytes) = 0;
 
        virtual void OnDownloadHealthUpdated(EBuildPatchDownloadHealth DownloadHealth) = 0;
 
        virtual void OnSuccessRateUpdated(float SuccessRate) = 0;
 
        virtual void OnActiveRequestCountUpdated(uint32 RequestCount) = 0;
 
        virtual void OnAcceptedNewRequirements(const TSet<FGuid>& ChunkIds) = 0;
    };
}