HttpConnection.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "CoreMinimal.h"
#include "HttpConnectionTypes.h"
#include "HttpConnectionRequestReadContext.h"
#include "HttpConnectionResponseWriteContext.h"
#include "HttpResultCallback.h"
#include "HttpServerConfig.h"
#include "HttpServerConstants.h"
#include "HttpServerHttpVersion.h"
#include "Misc/Timespan.h"
 
class FSocket;
class ISocketSubsystem;
class FHttpRouter;
struct FHttpServerRequest;
struct FHttpServerResponse;
 
DECLARE_LOG_CATEGORY_EXTERN(LogHttpConnection, Log, All);
 
struct FHttpConnection final : public TSharedFromThis<FHttpConnection>
{
public:
 
    FHttpConnection(FSocket* InSocket, TSharedPtr<FHttpRouter> InRouter, uint32 InOriginPort, uint32 InConnectionId);
    ~FHttpConnection();
 
    void Tick(float DeltaTime);
 
    FORCEINLINE EHttpConnectionState GetState() const
    {
        return State;
    }
 
    void RequestDestroy(bool bGraceful);
 
    FORCEINLINE bool IsHttpKeepAliveEnabled() const 
    { 
        return bKeepAlive;
    }
 
    FORCEINLINE bool operator==(const FHttpConnection& Other) const
    {
        return this->Socket == Other.Socket;
    }
 
    friend uint32 GetTypeHash(const FHttpConnection& Conn)
    {
        return GetTypeHash(Conn.Socket);
    }
 
private:
    enum class EConnectionDestroyReason : uint8
    {
        WriteError,
        AwaitReadTimeout,
        BeginReadTimeout,
        ReadTimeout,
        WriteTimeout,
        WriteComplete,
        DestroyRequest
    };
 
private:
 
    void ChangeState(EHttpConnectionState NewState);
 
    void TransferState(EHttpConnectionState CurrentState, EHttpConnectionState NextState);
 
    void BeginRead(float DeltaTime);
 
    void ContinueRead(float DeltaTime);
 
    void CompleteRead(const TSharedPtr<FHttpServerRequest>& Request);
 
    void ProcessRequest(const TSharedPtr<FHttpServerRequest>& Request, const FHttpResultCallback& OnProcessingComplete);
 
    void BeginWrite(TUniquePtr<FHttpServerResponse>&& Response, uint32 RequestNumber);
 
    void ContinueWrite(float DeltaTime);
 
    void CompleteWrite();
 
    void Destroy(EConnectionDestroyReason DestroyReason);
 
    void HandleReadError(EHttpServerResponseCodes ErrorCode, const TCHAR* ErrorCodeStr);
 
    void HandleWriteError(const TCHAR* ErrorCodeStr);
 
    static bool ResolveKeepAlive(HttpVersion::EHttpServerHttpVersion HttpVersion, const TArray<FString>& ConnectionHeaders);
 
    static const TCHAR* LexToString(EConnectionDestroyReason DestroyReason)
    {
        switch (DestroyReason)
        {
            case EConnectionDestroyReason::WriteError:
                return TEXT("Write error");
            case EConnectionDestroyReason::AwaitReadTimeout:
                return TEXT("Await read timeout");
            case EConnectionDestroyReason::BeginReadTimeout:
                return TEXT("Begin read timeout");
            case EConnectionDestroyReason::ReadTimeout:
                return TEXT("Read timeout");
            case EConnectionDestroyReason::WriteTimeout:
                return TEXT("Write timeout");
            case EConnectionDestroyReason::WriteComplete:
                return TEXT("Write complete");
            case EConnectionDestroyReason::DestroyRequest:
                return TEXT("Destroy connection request");
            default:
            {
                checkNoEntry();
                return TEXT("Unknown");
            }
        }
    }
 
private:
 
    FSocket* Socket;
 
    EHttpConnectionState State = EHttpConnectionState::AwaitingRead;
 
    const TSharedPtr<FHttpRouter> Router;
 
    uint32 OriginPort;
 
    uint32 ConnectionId;
 
    FHttpConnectionRequestReadContext ReadContext;
 
    FHttpConnectionResponseWriteContext WriteContext;
 
    bool bKeepAlive = true;
 
    bool bGracefulDestroyRequested = false;
 
    uint32 LastRequestNumber = 0;
 
    static constexpr float ConnectionTimeout = 5.0f;
 
    static constexpr float ConnectionKeepAliveTimeout = 15.0f;
 
    FHttpServerConnectionConfig Config;
};