ExternalRpcRegistry.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/UnrealString.h"
#include "CoreTypes.h"
#include "HttpPath.h"
#include "HttpRequestHandler.h"
#include "HttpResultCallback.h"
#include "HttpRouteHandle.h"
#include "HttpServerRequest.h"
#include "IHttpRouter.h"
#include "Logging/LogMacros.h"
#include "UObject/NameTypes.h"
#include "UObject/Object.h"
#include "UObject/ObjectMacros.h"
#include "UObject/UObjectGlobals.h"
 
#include "ExternalRpcRegistry.generated.h"
 
DECLARE_LOG_CATEGORY_EXTERN(LogExternalRpcRegistry, Log, All);
 
USTRUCT()
struct FExternalRpcArgumentDesc
{
    GENERATED_BODY()
public:
    FString Name;
    FString Type;
    FString Desc;
    bool bIsOptional = false;
 
    FExternalRpcArgumentDesc() = default;
    FExternalRpcArgumentDesc(FString InName, FString InType, FString InDesc, bool bInIsOptional = false)
    {
        Name = InName;
        Type = InType;
        Desc = InDesc;
        bIsOptional = bInIsOptional;
    }
 
    bool operator==(const FExternalRpcArgumentDesc& Other) const
    {
        return
            Name == Other.Name &&
            Type == Other.Type &&
            Desc == Other.Desc &&
            bIsOptional == Other.bIsOptional;
    }
 
    bool operator!=(const FExternalRpcArgumentDesc& Other) const
    {
        return !(*this == Other);
    }
};
 
USTRUCT()
struct FExternalRouteInfo
{
    GENERATED_BODY()
public:
    FName RouteName;
    FHttpPath RoutePath;
    EHttpServerRequestVerbs RequestVerbs = EHttpServerRequestVerbs::VERB_NONE;
    FString InputContentType;
    TArray<FExternalRpcArgumentDesc> ExpectedArguments;
    FString RpcCategory = TEXT("Unknown");
    bool bAlwaysOn = false;
 
    FExternalRouteInfo() = default;
 
    FExternalRouteInfo(FName InRouteName, FHttpPath InRoutePath, EHttpServerRequestVerbs InRequestVerbs, FString InCategory = TEXT("Unknown"), bool bInAlwaysOn = false, FString InContentType = {}, TArray<FExternalRpcArgumentDesc> InArguments = TArray<FExternalRpcArgumentDesc>())
    {
        RouteName = InRouteName;
        RoutePath = InRoutePath;
        RequestVerbs = InRequestVerbs;
        InputContentType = InContentType;
        ExpectedArguments = InArguments;
        RpcCategory = InCategory;
        bAlwaysOn = false;
    }
 
    bool operator==(const FExternalRouteInfo& Other) const
    {
        return
            RouteName == Other.RouteName &&
            RoutePath == Other.RoutePath &&
            RequestVerbs == Other.RequestVerbs &&
            InputContentType == Other.InputContentType &&
            ExpectedArguments == Other.ExpectedArguments &&
            RpcCategory == Other.RpcCategory &&
            bAlwaysOn == Other.bAlwaysOn;
    }
 
    bool operator!=(const FExternalRouteInfo& Other) const
    {
        return !(*this == Other);
    }
};
 
USTRUCT()
struct FExternalRouteDesc
{
    GENERATED_BODY()
public:
    FHttpRouteHandle Handle;
    FString InputContentType;
    FString RpcCategory;
    TArray<FExternalRpcArgumentDesc> ExpectedArguments;
    FExternalRouteDesc() = default;
    FExternalRouteDesc(FHttpRouteHandle InHandle, FString InContentType, TArray<FExternalRpcArgumentDesc> InArguments, FString InCategory = "")
    {
        Handle = InHandle;
        InputContentType = InContentType;
        ExpectedArguments = InArguments;
        RpcCategory = InCategory;
    }
};
 
USTRUCT()
struct FRpcLedgerEntry
{
    GENERATED_BODY()
public:
    FString RpcName;
    FString RequestBody;
    FDateTime RequestTime;
    FRpcLedgerEntry() = default;
    FRpcLedgerEntry(FString InName, FString InBody)
    {
        RpcName = InName;
        RequestBody = InBody;
        RequestTime = FDateTime::UtcNow();
    }
};
 
 
USTRUCT()
struct FRpcConfig
{
    GENERATED_BODY()
    FRpcConfig() = default;
 
    TMap<FString, int> PortMapping;
 
    // it is valid to have mappings, but no active port, in the case of a client with multiple endpoint hosts
    int ActiveHostPort = 0;
};
 
 
UCLASS(MinimalAPI)
class UExternalRpcRegistry : public UObject
{
    GENERATED_BODY()
protected:
    static EXTERNALRPCREGISTRY_API UExternalRpcRegistry * ObjectInstance;
    TMap<FName, FExternalRouteDesc> RegisteredRoutes;
    TArray<FString> ActiveRpcCategories;
    TArray<FRpcLedgerEntry> RequestLedger;
 
public:
    static EXTERNALRPCREGISTRY_API UExternalRpcRegistry * GetInstance();
    static EXTERNALRPCREGISTRY_API bool IsEnabled();
    static EXTERNALRPCREGISTRY_API const FRpcConfig& GetRpcConfig();
    EXTERNALRPCREGISTRY_API ~UExternalRpcRegistry();
 
    int PortToUse = 0;
    int RequestLedgerCapacity = 10;
 
    EXTERNALRPCREGISTRY_API bool IsActiveRpcCategory(FString InCategory);
 
    EXTERNALRPCREGISTRY_API bool GetRegisteredRoute(FName RouteName, FExternalRouteInfo& OutRouteInfo);
 
    EXTERNALRPCREGISTRY_API void RegisterNewRoute(FExternalRouteInfo InRouteInfo, const FHttpRequestHandler& Handler, bool bOverrideIfBound = false);
 
    EXTERNALRPCREGISTRY_API void RegisterNewRouteWithArguments(FName RouteName, const FHttpPath& HttpPath, const EHttpServerRequestVerbs& RequestVerbs, const FHttpRequestHandler& Handler, TArray<FExternalRpcArgumentDesc> InArguments, bool bOverrideIfBound = false, bool bIsAlwaysOn = false, FString OptionalCategory = TEXT("Unknown"), FString OptionalContentType = {});
 
    EXTERNALRPCREGISTRY_API void RegisterNewRoute(FName RouteName, const FHttpPath& HttpPath, const EHttpServerRequestVerbs& RequestVerbs, const FHttpRequestHandler& Handler, bool bOverrideIfBound = false, bool bIsAlwaysOn = false, FString OptionalCategory = TEXT("Unknown"), FString OptionalContentType = {}, FString OptionalExpectedFormat = {});
 
    EXTERNALRPCREGISTRY_API void CleanUpAllRoutes();
 
    EXTERNALRPCREGISTRY_API void CleanUpRoute(FName RouteName, bool bFailIfUnbound = false);
 
    EXTERNALRPCREGISTRY_API bool HttpListOpenRoutes(const FHttpServerRequest& Request, const FHttpResultCallback& OnComplete);
    EXTERNALRPCREGISTRY_API void AddRequestToLedger(const FHttpServerRequest& Request);
 
    EXTERNALRPCREGISTRY_API bool HttpPrintRequestLedger(const FHttpServerRequest& Request, const FHttpResultCallback& OnComplete);
 
    EXTERNALRPCREGISTRY_API bool HttpListOASv3JSONRoutes(const FHttpServerRequest& Request, const FHttpResultCallback& OnComplete);
 
 
    EXTERNALRPCREGISTRY_API bool HttpSwaggerUI(const FHttpServerRequest& Request, const FHttpResultCallback& OnComplete);
 
};