NetConnectionFaultRecoveryBase.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
 
#include "Containers/Array.h"
#include "Containers/ContainerAllocationPolicies.h"
#include "HAL/PlatformCrt.h"
#include "Math/UnrealMathSSE.h"
#include "Net/Core/Connection/EscalationStates.h"
#include "Net/Core/Connection/NetCloseResult.h"
#include "Net/Core/Connection/NetResultManager.h"
#include "Net/Core/Connection/StateStruct.h"
#include "Templates/PimplPtr.h"
#include "Templates/UniquePtr.h"
#include "Templates/UnrealTemplate.h"
#include "UObject/ObjectMacros.h"
 
#include "NetConnectionFaultRecoveryBase.generated.h"
 
class UClass;
 
// Forward declarations
namespace UE
{
    namespace Net
    {
        class FNetConnectionFaultRecovery;
        struct FNetResult;
    }
}
 
 
USTRUCT()
struct FNetFaultState : public FEscalationState
{
    GENERATED_BODY()
 
    friend UE::Net::FNetConnectionFaultRecovery;
 
public:
    UPROPERTY(config)
    bool bCloseConnection                       = false;
 
 
    UPROPERTY(config)
    int16 EscalateQuotaFaultsPerPeriod          = -1;
 
    UPROPERTY(config)
    int8 EscalateQuotaFaultPercentPerPeriod     = -1;
 
    UPROPERTY(config)
    int16 DescalateQuotaFaultsPerPeriod         = -1;
 
    UPROPERTY(config)
    int8 DescalateQuotaFaultPercentPerPeriod    = -1;
 
    UPROPERTY(config)
    int8 EscalateQuotaTimePeriod                = -1;
 
 
public:
    static NETCORE_API const TCHAR* GetConfigSection();
    static NETCORE_API UClass* GetBaseConfigClass();
 
 
protected:
    NETCORE_API virtual EInitStateDefaultsResult InitConfigDefaultsInternal() override;
    NETCORE_API virtual void ApplyImpliedValuesInternal() override;
    NETCORE_API virtual void ValidateConfigInternal() override;
 
private:
    NETCORE_API virtual bool HasHitAnyQuota(FHasHitAnyQuotaParms Parms) const override;
};
 
 
namespace UE
{
namespace Net
{
 
enum class ENetFaultCounters : uint8
{
    PacketCount,        // Total number of packets received per-period
    NetConnPacketFault, // Faults encountered by low level NetConnection packet processing (signifying packet corruption - excludes PacketHandler)
 
    Max,
 
    NumPrealloc = 6
};
 
 
enum class ENetFaultCounterCategory : uint8
{
    NetworkCorruption,
 
    Max
};
 
inline uint8 ToInt(ENetFaultCounters CounterVal)
{
    return static_cast<uint8>(CounterVal);
}
 
inline uint8 ToInt(ENetFaultCounterCategory CategoryVal)
{
    return static_cast<uint8>(CategoryVal);
}
 
// Hacky base class to avoid 8 bytes of padding after the vtable
class FNetConnectionFaultRecoveryBaseFixLayout
{
public:
    virtual ~FNetConnectionFaultRecoveryBaseFixLayout() = default;
};
 
class FNetConnectionFaultRecoveryBase : public FNetConnectionFaultRecoveryBaseFixLayout
{
public:
    using FNetFaultEscalationHandler = TEscalationManager<ENetFaultCounters, FNetFaultState, ENetFaultCounterCategory>;
 
    NETCORE_API EHandleNetResult NotifyHandledFault(FNetResult&& InResult);
 
 
    FNetResultManager& GetFaultManager()
    {
        return FaultManager;
    }
 
    NETCORE_API EHandleNetResult HandleNetResult(FNetCloseResult&& InResult);
 
    NETCORE_API int32 AddNewCounter(int32 Count=1);
 
    NETCORE_API FEscalationCounter& GetFrameCounter(int32 CounterIndex);
 
    NETCORE_API void RegisterCounterCategory(ENetFaultCounterCategory Category, int32 CounterIndex);
 
 
private:
    virtual void InitEscalationManager()
    {
    }
 
 
protected:
    bool bDisconnected = false;
 
    int32 LastCounterIndex = static_cast<int32>(ENetFaultCounters::Max);
 
    TUniquePtr<FNetFaultEscalationHandler> NetFaultEscalationManager;
 
    struct FPendingCategoryRegister
    {
        int32 CategoryIndex     = 0;
        int32 CounterIndex      = 0;
 
        friend bool operator == (const FPendingCategoryRegister& A, const FPendingCategoryRegister& B)
        {
            return A.CategoryIndex == B.CategoryIndex && A.CounterIndex == B.CounterIndex;
        }
    };
 
    TArray<FPendingCategoryRegister> PendingCategories;
 
    TPimplPtr<FNetResult, EPimplPtrMode::DeepCopy> TrackedFaults;
 
    TArray<uint32, TInlineAllocator<FMath::Max(static_cast<int32>(ENetFaultCounters::Max), 8)>> TrackedFaultEnumHashes;
 
 
    FNetResultManager FaultManager;
};
 
}
}