Fixing Various Bugs On Delegates
This commit is contained in:
317
Source/DTFluxNetwork/Private/DTFluxAsyncParser.cpp
Normal file
317
Source/DTFluxNetwork/Private/DTFluxAsyncParser.cpp
Normal file
@ -0,0 +1,317 @@
|
||||
#include "DTFluxAsyncParser.h"
|
||||
|
||||
#include "DTFluxNetworkModule.h"
|
||||
#include "Struct/DTFluxServerResponseStruct.h"
|
||||
#include "Async/AsyncWork.h"
|
||||
|
||||
// ================================================================================================
|
||||
// IMPLÉMENTATION DE LA TÂCHE DE PARSING
|
||||
// ================================================================================================
|
||||
|
||||
DECLARE_STATS_GROUP(TEXT("DTFlux"), STATGROUP_DTFlux, STATCAT_Advanced);
|
||||
|
||||
DECLARE_CYCLE_STAT(TEXT("DTFlux Parsing Task"), STAT_FDTFluxParsingTask, STATGROUP_DTFlux);
|
||||
DECLARE_CYCLE_STAT(TEXT("DTFlux Parsing Task DoWork"), STAT_FDTFluxParsingTask_DoWork, STATGROUP_DTFlux);
|
||||
|
||||
FDTFluxParsingTask::FDTFluxParsingTask(
|
||||
const FGuid& InRequestId,
|
||||
const FString& InRawJsonData,
|
||||
FOnParsingCompleted InOnCompleted,
|
||||
FOnParsingFailed InOnFailed
|
||||
)
|
||||
: RequestId(InRequestId)
|
||||
, RawJsonData(InRawJsonData)
|
||||
, OnCompleted(InOnCompleted)
|
||||
, OnFailed(InOnFailed)
|
||||
, StartTime(FPlatformTime::Seconds())
|
||||
{
|
||||
}
|
||||
|
||||
void FDTFluxParsingTask::DoTask(ENamedThreads::Type CurrentThread, const FGraphEventRef& MyCompletionGraphEvent)
|
||||
{
|
||||
SCOPE_CYCLE_COUNTER(STAT_FDTFluxParsingTask_DoWork);
|
||||
|
||||
UE_LOG(logDTFluxNetwork, VeryVerbose, TEXT("Starting async parsing for request %s"), *RequestId.ToString());
|
||||
|
||||
TSharedPtr<FDTFluxServerResponse> ParsedResponse;
|
||||
bool bParsingSuccess = false;
|
||||
FString ErrorMessage;
|
||||
|
||||
try
|
||||
{
|
||||
// === PARSING SUR LE THREAD WORKER ===
|
||||
|
||||
EDTFluxResponseStatus Status;
|
||||
ParsedResponse = MakeShared<FDTFluxServerResponse>(RawJsonData, Status, false); // Pas de logs sur worker thread
|
||||
|
||||
if (Status == EDTFluxResponseStatus::Success)
|
||||
{
|
||||
bParsingSuccess = true;
|
||||
UE_LOG(logDTFluxNetwork, VeryVerbose, TEXT("Async parsing successful for request %s"),
|
||||
*RequestId.ToString());
|
||||
}
|
||||
else
|
||||
{
|
||||
ErrorMessage = FString::Printf(TEXT("Parsing failed with status: %s"),
|
||||
*UEnum::GetValueAsString(Status));
|
||||
UE_LOG(logDTFluxNetwork, Warning, TEXT("Async parsing failed for request %s: %s"),
|
||||
*RequestId.ToString(), *ErrorMessage);
|
||||
}
|
||||
}
|
||||
catch (const std::exception& e)
|
||||
{
|
||||
ErrorMessage = FString::Printf(TEXT("Exception during parsing: %s"), ANSI_TO_TCHAR(e.what()));
|
||||
UE_LOG(logDTFluxNetwork, Error, TEXT("Exception during async parsing for request %s: %s"),
|
||||
*RequestId.ToString(), *ErrorMessage);
|
||||
}
|
||||
catch (...)
|
||||
{
|
||||
ErrorMessage = TEXT("Unknown exception during parsing");
|
||||
UE_LOG(logDTFluxNetwork, Error, TEXT("Unknown exception during async parsing for request %s"),
|
||||
*RequestId.ToString());
|
||||
}
|
||||
|
||||
const float ParsingTime = (FPlatformTime::Seconds() - StartTime) * 1000.0f; // En millisecondes
|
||||
|
||||
// === PROGRAMMER LA CALLBACK SUR LE MAIN THREAD ===
|
||||
|
||||
FFunctionGraphTask::CreateAndDispatchWhenReady(
|
||||
[this, ParsedResponse, bParsingSuccess, ErrorMessage, ParsingTime]()
|
||||
{
|
||||
// Cette lambda s'exécute sur le main thread
|
||||
if (bParsingSuccess && ParsedResponse.IsValid())
|
||||
{
|
||||
OnCompleted.ExecuteIfBound(RequestId, ParsedResponse, true);
|
||||
}
|
||||
else
|
||||
{
|
||||
OnFailed.ExecuteIfBound(RequestId, ErrorMessage);
|
||||
}
|
||||
},
|
||||
TStatId(),
|
||||
nullptr,
|
||||
ENamedThreads::GameThread // Forcer l'exécution sur le main thread
|
||||
);
|
||||
}
|
||||
|
||||
// ================================================================================================
|
||||
// IMPLÉMENTATION DU PARSER ASYNCHRONE
|
||||
// ================================================================================================
|
||||
|
||||
FDTFluxAsyncParser::FDTFluxAsyncParser()
|
||||
{
|
||||
UE_LOG(logDTFluxNetwork, Log, TEXT("AsyncParser initialized"));
|
||||
}
|
||||
|
||||
FDTFluxAsyncParser::~FDTFluxAsyncParser()
|
||||
{
|
||||
CancelAllParsing();
|
||||
UE_LOG(logDTFluxNetwork, Log, TEXT("AsyncParser destroyed"));
|
||||
}
|
||||
|
||||
void FDTFluxAsyncParser::ParseResponseAsync(
|
||||
const FGuid& RequestId,
|
||||
const FString& RawJsonData,
|
||||
FOnParsingCompleted OnCompleted,
|
||||
FOnParsingFailed OnFailed)
|
||||
{
|
||||
if (RawJsonData.IsEmpty())
|
||||
{
|
||||
OnFailed.ExecuteIfBound(RequestId, TEXT("Empty JSON data"));
|
||||
return;
|
||||
}
|
||||
|
||||
// Créer la tâche de parsing
|
||||
FGraphEventRef Task = FFunctionGraphTask::CreateAndDispatchWhenReady(
|
||||
[RequestId, RawJsonData, OnCompleted, OnFailed]()
|
||||
{
|
||||
// Ce code s'exécute sur le worker thread
|
||||
const double StartTime = FPlatformTime::Seconds();
|
||||
|
||||
TSharedPtr<FDTFluxServerResponse> ParsedResponse;
|
||||
bool bParsingSuccess = false;
|
||||
FString ErrorMessage;
|
||||
|
||||
try
|
||||
{
|
||||
EDTFluxResponseStatus Status;
|
||||
ParsedResponse = MakeShared<FDTFluxServerResponse>(RawJsonData, Status, false);
|
||||
|
||||
if (Status == EDTFluxResponseStatus::Success)
|
||||
{
|
||||
bParsingSuccess = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
ErrorMessage = FString::Printf(TEXT("Parsing failed with status: %s"),
|
||||
*UEnum::GetValueAsString(Status));
|
||||
}
|
||||
}
|
||||
catch (const std::exception& e)
|
||||
{
|
||||
ErrorMessage = FString::Printf(TEXT("Exception during parsing: %s"), ANSI_TO_TCHAR(e.what()));
|
||||
}
|
||||
catch (...)
|
||||
{
|
||||
ErrorMessage = TEXT("Unknown exception during parsing");
|
||||
}
|
||||
|
||||
const float ParsingTime = (FPlatformTime::Seconds() - StartTime) * 1000.0f;
|
||||
FFunctionGraphTask::CreateAndDispatchWhenReady(
|
||||
[RequestId, ParsedResponse, bParsingSuccess, ErrorMessage, OnCompleted, OnFailed]()
|
||||
{
|
||||
// Cette lambda s'exécute sur le main thread
|
||||
if (bParsingSuccess && ParsedResponse.IsValid())
|
||||
{
|
||||
OnCompleted.ExecuteIfBound(RequestId, ParsedResponse, true);
|
||||
}
|
||||
else
|
||||
{
|
||||
OnFailed.ExecuteIfBound(RequestId, ErrorMessage);
|
||||
}
|
||||
},
|
||||
TStatId(),
|
||||
nullptr,
|
||||
ENamedThreads::GameThread // Forcer main thread
|
||||
);
|
||||
},
|
||||
TStatId(),
|
||||
nullptr,
|
||||
ENamedThreads::AnyBackgroundThreadNormalTask
|
||||
);
|
||||
|
||||
// Tracker la tâche
|
||||
{
|
||||
FScopeLock Lock(&TasksLock);
|
||||
ActiveTasks.Add(Task);
|
||||
}
|
||||
|
||||
UE_LOG(logDTFluxNetwork, Verbose, TEXT("Queued async parsing task for request %s"), *RequestId.ToString());
|
||||
}
|
||||
|
||||
TSharedPtr<FDTFluxServerResponse> FDTFluxAsyncParser::ParseResponseSync(
|
||||
const FString& RawJsonData,
|
||||
float TimeoutSeconds)
|
||||
{
|
||||
if (RawJsonData.IsEmpty())
|
||||
{
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
// Variables pour la synchronisation
|
||||
TSharedPtr<FDTFluxServerResponse> Result;
|
||||
std::atomic<bool> bCompleted{false};
|
||||
|
||||
// Lancer le parsing async avec callback sync
|
||||
FOnParsingCompleted OnCompleted = FOnParsingCompleted::CreateLambda(
|
||||
[&Result, &bCompleted](const FGuid& RequestId, TSharedPtr<FDTFluxServerResponse> ParsedResponse, bool bSuccess)
|
||||
{
|
||||
if (bSuccess)
|
||||
{
|
||||
Result = ParsedResponse;
|
||||
}
|
||||
bCompleted.store(true);
|
||||
}
|
||||
);
|
||||
|
||||
FOnParsingFailed OnFailed = FOnParsingFailed::CreateLambda(
|
||||
[&bCompleted](const FGuid& RequestId, const FString& ErrorMessage)
|
||||
{
|
||||
UE_LOG(logDTFluxNetwork, Warning, TEXT("Sync parsing failed: %s"), *ErrorMessage);
|
||||
bCompleted.store(true);
|
||||
}
|
||||
);
|
||||
|
||||
FGuid TempId = FGuid::NewGuid();
|
||||
ParseResponseAsync(TempId, RawJsonData, OnCompleted, OnFailed);
|
||||
|
||||
// Attendre avec timeout
|
||||
const double StartTime = FPlatformTime::Seconds();
|
||||
while (!bCompleted.load() && (FPlatformTime::Seconds() - StartTime) < TimeoutSeconds)
|
||||
{
|
||||
FPlatformProcess::Sleep(0.001f); // 1ms
|
||||
}
|
||||
|
||||
return Result;
|
||||
}
|
||||
|
||||
void FDTFluxAsyncParser::CancelAllParsing()
|
||||
{
|
||||
FScopeLock Lock(&TasksLock);
|
||||
|
||||
for (const FGraphEventRef& Task : ActiveTasks)
|
||||
{
|
||||
// Note: On ne peut pas vraiment "cancel" une tâche TaskGraph en cours,
|
||||
// mais on peut marquer qu'on ne veut plus les résultats
|
||||
}
|
||||
|
||||
ActiveTasks.Empty();
|
||||
UE_LOG(logDTFluxNetwork, Log, TEXT("Cancelled all pending parsing tasks"));
|
||||
}
|
||||
|
||||
FDTFluxAsyncParser::FParsingStats FDTFluxAsyncParser::GetStats() const
|
||||
{
|
||||
FScopeLock StatsLock_Local(&StatsLock);
|
||||
FScopeLock TasksLock_Local(&TasksLock);
|
||||
|
||||
FParsingStats Stats;
|
||||
Stats.TasksInProgress = ActiveTasks.Num();
|
||||
Stats.TasksCompleted = TasksCompletedCount;
|
||||
Stats.TasksFailed = TasksFailedCount;
|
||||
|
||||
if (ParsingTimes.Num() > 0)
|
||||
{
|
||||
float Sum = 0.0f;
|
||||
for (float Time : ParsingTimes)
|
||||
{
|
||||
Sum += Time;
|
||||
}
|
||||
Stats.AverageParsingTimeMs = Sum / ParsingTimes.Num();
|
||||
}
|
||||
|
||||
return Stats;
|
||||
}
|
||||
|
||||
void FDTFluxAsyncParser::ResetStats()
|
||||
{
|
||||
FScopeLock Lock(&StatsLock);
|
||||
TasksCompletedCount = 0;
|
||||
TasksFailedCount = 0;
|
||||
ParsingTimes.Empty();
|
||||
}
|
||||
|
||||
void FDTFluxAsyncParser::OnTaskCompleted(bool bSuccess, float ParsingTimeMs)
|
||||
{
|
||||
FScopeLock Lock(&StatsLock);
|
||||
|
||||
if (bSuccess)
|
||||
{
|
||||
TasksCompletedCount++;
|
||||
}
|
||||
else
|
||||
{
|
||||
TasksFailedCount++;
|
||||
}
|
||||
|
||||
ParsingTimes.Add(ParsingTimeMs);
|
||||
|
||||
// Garder seulement les 100 derniers temps pour la moyenne
|
||||
if (ParsingTimes.Num() > 100)
|
||||
{
|
||||
ParsingTimes.RemoveAt(0);
|
||||
}
|
||||
}
|
||||
|
||||
void FDTFluxAsyncParser::CleanupCompletedTasks()
|
||||
{
|
||||
FScopeLock Lock(&TasksLock);
|
||||
|
||||
for (auto It = ActiveTasks.CreateIterator(); It; ++It)
|
||||
{
|
||||
const FGraphEventRef& Task = *It;
|
||||
if (Task.IsValid() && Task->IsComplete())
|
||||
{
|
||||
It.RemoveCurrent(); // Supprime l'élément actuel de manière sécurisée
|
||||
}
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
171
Source/DTFluxNetwork/Public/DTFluxAsyncParser.h
Normal file
171
Source/DTFluxNetwork/Public/DTFluxAsyncParser.h
Normal file
@ -0,0 +1,171 @@
|
||||
// ================================================================================================
|
||||
// DTFluxAsyncParser.h - Async Response Parser
|
||||
// ================================================================================================
|
||||
#pragma once
|
||||
|
||||
#include "CoreMinimal.h"
|
||||
#include "HAL/CriticalSection.h"
|
||||
#include "Async/TaskGraphInterfaces.h"
|
||||
#include "Struct/DTFluxServerResponseStruct.h"
|
||||
|
||||
// Forward declarations
|
||||
|
||||
// ================================================================================================
|
||||
// DELEGATES POUR LE PARSING ASYNCHRONE
|
||||
// ================================================================================================
|
||||
|
||||
DECLARE_DELEGATE_ThreeParams(FOnParsingCompleted, const FGuid& /*RequestId*/,
|
||||
TSharedPtr<FDTFluxServerResponse> /*ParsedResponse*/, bool /*bSuccess*/);
|
||||
DECLARE_DELEGATE_TwoParams(FOnParsingFailed, const FGuid& /*RequestId*/, const FString& /*ErrorMessage*/);
|
||||
|
||||
// ================================================================================================
|
||||
// ASYNC PARSER - Délégation du parsing avec TaskGraph
|
||||
// ================================================================================================
|
||||
|
||||
/**
|
||||
* Gestionnaire centralisé pour le parsing asynchrone des réponses JSON
|
||||
* Utilise le TaskGraph d'Unreal Engine pour déléguer le parsing sur des worker threads
|
||||
*/
|
||||
class DTFLUXNETWORK_API FDTFluxAsyncParser
|
||||
{
|
||||
public:
|
||||
FDTFluxAsyncParser();
|
||||
~FDTFluxAsyncParser();
|
||||
|
||||
// === INTERFACE PUBLIQUE ===
|
||||
|
||||
/**
|
||||
* Lancer le parsing asynchrone d'une réponse JSON
|
||||
* @param RequestId - ID de la requête pour le suivi
|
||||
* @param RawJsonData - Données JSON brutes à parser
|
||||
* @param OnCompleted - Callback appelé en cas de succès (sur main thread)
|
||||
* @param OnFailed - Callback appelé en cas d'échec (sur main thread)
|
||||
*/
|
||||
void ParseResponseAsync(
|
||||
const FGuid& RequestId,
|
||||
const FString& RawJsonData,
|
||||
FOnParsingCompleted OnCompleted,
|
||||
FOnParsingFailed OnFailed = FOnParsingFailed()
|
||||
);
|
||||
|
||||
/**
|
||||
* Parsing synchrone avec timeout (pour les cas urgents)
|
||||
* @param RawJsonData - Données JSON à parser
|
||||
* @param TimeoutSeconds - Timeout maximum pour le parsing
|
||||
* @return Réponse parsée ou nullptr en cas d'échec
|
||||
*/
|
||||
TSharedPtr<FDTFluxServerResponse> ParseResponseSync(
|
||||
const FString& RawJsonData,
|
||||
float TimeoutSeconds = 1.0f
|
||||
);
|
||||
|
||||
/**
|
||||
* Annuler toutes les tâches de parsing en attente
|
||||
*/
|
||||
void CancelAllParsing();
|
||||
|
||||
// === STATISTIQUES ===
|
||||
|
||||
/**
|
||||
* Statistiques de performance du parsing
|
||||
*/
|
||||
struct FParsingStats
|
||||
{
|
||||
int32 TasksInProgress = 0; // Tâches actuellement en cours
|
||||
int32 TasksCompleted = 0; // Tâches terminées avec succès
|
||||
int32 TasksFailed = 0; // Tâches échouées
|
||||
float AverageParsingTimeMs = 0.0f; // Temps moyen de parsing en ms
|
||||
};
|
||||
|
||||
/**
|
||||
* Obtenir les statistiques de parsing
|
||||
*/
|
||||
FParsingStats GetStats() const;
|
||||
|
||||
/**
|
||||
* Réinitialiser les statistiques
|
||||
*/
|
||||
void ResetStats();
|
||||
|
||||
private:
|
||||
// === TRACKING DES TÂCHES ===
|
||||
mutable FCriticalSection TasksLock;
|
||||
TSet<FGraphEventRef> ActiveTasks;
|
||||
|
||||
// === STATISTIQUES ===
|
||||
mutable FCriticalSection StatsLock;
|
||||
mutable int32 TasksCompletedCount = 0;
|
||||
mutable int32 TasksFailedCount = 0;
|
||||
mutable TArray<float> ParsingTimes; // Historique des temps de parsing
|
||||
|
||||
// === MÉTHODES PRIVÉES ===
|
||||
|
||||
/**
|
||||
* Callback appelé quand une tâche se termine
|
||||
* @param bSuccess - Succès ou échec de la tâche
|
||||
* @param ParsingTimeMs - Temps de parsing en millisecondes
|
||||
*/
|
||||
void OnTaskCompleted(bool bSuccess, float ParsingTimeMs);
|
||||
|
||||
/**
|
||||
* Nettoyer les tâches terminées de la liste active
|
||||
*/
|
||||
void CleanupCompletedTasks();
|
||||
};
|
||||
|
||||
// ================================================================================================
|
||||
// TÂCHE DE PARSING POUR LE TASKGRAPH
|
||||
// ================================================================================================
|
||||
|
||||
/**
|
||||
* Tâche de parsing JSON exécutée sur un thread worker
|
||||
* Compatible avec le TaskGraph d'Unreal Engine
|
||||
*/
|
||||
class FDTFluxParsingTask
|
||||
{
|
||||
public:
|
||||
FDTFluxParsingTask(
|
||||
const FGuid& InRequestId,
|
||||
const FString& InRawJsonData,
|
||||
FOnParsingCompleted InOnCompleted,
|
||||
FOnParsingFailed InOnFailed
|
||||
);
|
||||
|
||||
// === INTERFACE TASK GRAPH ===
|
||||
|
||||
FORCEINLINE TStatId GetStatId() const
|
||||
{
|
||||
RETURN_QUICK_DECLARE_CYCLE_STAT(FDTFluxParsingTask, STATGROUP_TaskGraphTasks);
|
||||
}
|
||||
|
||||
static FORCEINLINE TStatId GetStatId_DoWork()
|
||||
{
|
||||
RETURN_QUICK_DECLARE_CYCLE_STAT(FDTFluxParsingTask_DoWork, STATGROUP_TaskGraphTasks);
|
||||
}
|
||||
|
||||
static FORCEINLINE ENamedThreads::Type GetDesiredThread()
|
||||
{
|
||||
// Exécuter sur un thread worker (pas le main thread)
|
||||
return ENamedThreads::AnyBackgroundThreadNormalTask;
|
||||
}
|
||||
|
||||
static FORCEINLINE ESubsequentsMode::Type GetSubsequentsMode()
|
||||
{
|
||||
return ESubsequentsMode::TrackSubsequents;
|
||||
}
|
||||
|
||||
// === EXÉCUTION DE LA TÂCHE ===
|
||||
|
||||
/**
|
||||
* Méthode principale d'exécution de la tâche
|
||||
* Appelée automatiquement par le TaskGraph sur un worker thread
|
||||
*/
|
||||
void DoTask(ENamedThreads::Type CurrentThread, const FGraphEventRef& MyCompletionGraphEvent);
|
||||
|
||||
private:
|
||||
FGuid RequestId;
|
||||
FString RawJsonData;
|
||||
FOnParsingCompleted OnCompleted;
|
||||
FOnParsingFailed OnFailed;
|
||||
double StartTime;
|
||||
};
|
||||
@ -1,66 +1,444 @@
|
||||
// Fill out your copyright notice in the Description page of Project Settings.
|
||||
// ================================================================================================
|
||||
// DTFluxRequestManager.h - Gestionnaire C++ optimisé avec cache, timeout et retry
|
||||
// ================================================================================================
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "CoreMinimal.h"
|
||||
#include "UObject/Object.h"
|
||||
#include "Containers/Queue.h"
|
||||
#include "Tickable.h"
|
||||
#include "Struct/DTFluxRequestStructs.h"
|
||||
#include "HAL/CriticalSection.h"
|
||||
#include "Struct/DTFluxServerResponseStruct.h"
|
||||
#include "Types/Enum/DTFluxCoreEnum.h"
|
||||
#include "DTFluxQueuedManager.generated.h"
|
||||
|
||||
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnRequestTimedOut, const FDTFluxQueuedRequest&, TimedOutRequest);
|
||||
class FDTFluxAsyncParser;
|
||||
|
||||
/**
|
||||
* @brief Classe Tickable gérant les requêtes WebSockets qui ne sont pas traçables nativement par l'API.
|
||||
* Cette classe utilise TQueue pour gérer efficacement les requêtes en attente et vérifie leur état dans le tick.
|
||||
*/
|
||||
UCLASS()
|
||||
class DTFLUXNETWORK_API UDTFluxQueuedManager : public UObject, public FTickableGameObject
|
||||
|
||||
// ================================================================================================
|
||||
// ENUMS ET STRUCTURES POUR LES REQUÊTES
|
||||
// ================================================================================================
|
||||
|
||||
UENUM(BlueprintType)
|
||||
enum class EDTFluxRequestState : uint8
|
||||
{
|
||||
Pending UMETA(DisplayName = "Pending"),
|
||||
Sent UMETA(DisplayName = "Sent"),
|
||||
Completed UMETA(DisplayName = "Completed"),
|
||||
Failed UMETA(DisplayName = "Failed"),
|
||||
TimedOut UMETA(DisplayName = "TimedOut"),
|
||||
Cached UMETA(DisplayName = "Cached"),
|
||||
Retrying UMETA(DisplayName = "Retrying")
|
||||
};
|
||||
|
||||
USTRUCT(BlueprintType)
|
||||
struct DTFLUXNETWORK_API FDTFluxRequestConfig
|
||||
{
|
||||
GENERATED_BODY()
|
||||
|
||||
public:
|
||||
/** Constructeur par défaut */
|
||||
UDTFluxQueuedManager();
|
||||
virtual ~UDTFluxQueuedManager() override;
|
||||
void Initialize();
|
||||
FGuid QueueRequest(EDTFluxRequestType RequestType, int32 ContestId = -1, int32 StageId = -1, int32 SplitId = -1,
|
||||
const FString& RawMessage = "");
|
||||
bool MarkRequestAsError(const FGuid& TargetRequestGuid);
|
||||
bool MarkRequestAsResponded(const FGuid& TargetRequestGuid);
|
||||
bool MarkRequestAsResponded(const FDTFluxQueuedRequest& TargetRequest);
|
||||
bool IsRequestPending(FGuid& OutRequestId, EDTFluxRequestType RequestType, int32 ContestId = -1, int32 StageId = -1,
|
||||
int32 SplitId = -1);
|
||||
FDTFluxQueuedRequest* GetRequestPending(EDTFluxRequestType RequestType, int32 ContestId = -1, int32 StageId = -1,
|
||||
int32 SplitId = -1);
|
||||
const FDTFluxQueuedRequest* GetRequest(const FGuid& SearchedGuid);
|
||||
int32 GetPendingRequestCount();
|
||||
int32 CleanupTimedOutRequests();
|
||||
int32 CleanCashedRequests();
|
||||
void ClearAllRequests();
|
||||
// bool TryProcessResponse(const FDTFluxServerResponse& Response);
|
||||
UPROPERTY(EditAnywhere, BlueprintReadWrite)
|
||||
float TimeoutSeconds = 5.0f;
|
||||
|
||||
UPROPERTY(EditAnywhere, BlueprintReadWrite)
|
||||
int32 MaxRetries = 3;
|
||||
|
||||
UPROPERTY(EditAnywhere, BlueprintReadWrite)
|
||||
float RetryBackoffMultiplier = 1.5f;
|
||||
|
||||
UPROPERTY(EditAnywhere, BlueprintReadWrite)
|
||||
bool bEnableCache = true;
|
||||
|
||||
UPROPERTY(EditAnywhere, BlueprintReadWrite)
|
||||
float CacheValiditySeconds = 60.0f;
|
||||
};
|
||||
|
||||
USTRUCT(BlueprintType)
|
||||
struct DTFLUXNETWORK_API FDTFluxTrackedRequest
|
||||
{
|
||||
GENERATED_BODY()
|
||||
|
||||
// === IDENTIFICATION ===
|
||||
UPROPERTY(BlueprintReadOnly)
|
||||
FGuid RequestId = FGuid::NewGuid();
|
||||
|
||||
UPROPERTY(BlueprintReadOnly)
|
||||
EDTFluxApiDataType RequestType = EDTFluxApiDataType::None;
|
||||
|
||||
UPROPERTY(BlueprintReadOnly)
|
||||
int32 ContestId = -1;
|
||||
|
||||
UPROPERTY(BlueprintReadOnly)
|
||||
int32 StageId = -1;
|
||||
|
||||
UPROPERTY(BlueprintReadOnly)
|
||||
int32 SplitId = -1;
|
||||
|
||||
// === ÉTAT ET TIMING ===
|
||||
UPROPERTY(BlueprintReadOnly)
|
||||
EDTFluxRequestState State = EDTFluxRequestState::Pending;
|
||||
|
||||
UPROPERTY(BlueprintReadOnly)
|
||||
FDateTime CreatedAt = FDateTime::Now();
|
||||
|
||||
UPROPERTY(BlueprintReadOnly)
|
||||
FDateTime SentAt = FDateTime::MinValue();
|
||||
|
||||
UPROPERTY(BlueprintReadOnly)
|
||||
FDateTime CompletedAt = FDateTime::MinValue();
|
||||
|
||||
UPROPERTY(BlueprintReadOnly)
|
||||
FDateTime LastAttemptTime = FDateTime::Now();
|
||||
|
||||
// === CONFIGURATION ===
|
||||
FDTFluxRequestConfig Config;
|
||||
|
||||
// === RETRY LOGIC ===
|
||||
UPROPERTY(BlueprintReadOnly)
|
||||
int32 CurrentRetries = 0;
|
||||
|
||||
// === DONNÉES DE RÉPONSE ===
|
||||
UPROPERTY(BlueprintReadOnly)
|
||||
FString RawResponseData;
|
||||
|
||||
// Réponse parsée (lazy loading)
|
||||
mutable TOptional<TSharedPtr<FDTFluxServerResponse>> ParsedResponse;
|
||||
|
||||
UPROPERTY(BlueprintReadOnly)
|
||||
bool bIsResponseParsed = false;
|
||||
|
||||
UPROPERTY(BlueprintReadOnly)
|
||||
FString LastErrorMessage;
|
||||
|
||||
// === MÉTHODES UTILITAIRES ===
|
||||
|
||||
bool HasTimedOut() const;
|
||||
bool CanRetry() const;
|
||||
bool IsCacheValid() const;
|
||||
float GetRetryDelay() const;
|
||||
bool Matches(EDTFluxApiDataType InType, int32 InContestId = -1, int32 InStageId = -1, int32 InSplitId = -1) const;
|
||||
FString GetCacheKey() const;
|
||||
void SetRawResponse(const FString& RawData);
|
||||
FString Serialize() const;
|
||||
};
|
||||
|
||||
// ================================================================================================
|
||||
// DELEGATES POUR LES CALLBACKS
|
||||
// ================================================================================================
|
||||
|
||||
DECLARE_DELEGATE_OneParam(FOnDTFluxRequestSuccess, const FDTFluxTrackedRequest&);
|
||||
DECLARE_DELEGATE_TwoParams(FOnDTFluxRequestError, const FDTFluxTrackedRequest&, const FString& /*ErrorMessage*/);
|
||||
|
||||
DECLARE_MULTICAST_DELEGATE_TwoParams(FOnRequestStateChangedNative, const FGuid& /*RequestId*/,
|
||||
EDTFluxRequestState& /*NewState*/);
|
||||
DECLARE_MULTICAST_DELEGATE_OneParam(FOnRequestCompletedNative, const FDTFluxTrackedRequest& /*CompletedRequest*/);
|
||||
DECLARE_MULTICAST_DELEGATE_OneParam(FOnRequestFailedNative, const FDTFluxTrackedRequest& /*FailedRequest*/);
|
||||
|
||||
// ================================================================================================
|
||||
// REQUEST MANAGER - Classe C++ principale avec SmartPointers
|
||||
// ================================================================================================
|
||||
|
||||
/**
|
||||
* Gestionnaire de requêtes trackées avec cache, timeout, retry et parsing asynchrone
|
||||
* Implémentation C++ pure avec SmartPointers pour des performances optimales
|
||||
*/
|
||||
class DTFLUXNETWORK_API FDTFluxQueuedRequestManager : public FTickableGameObject
|
||||
{
|
||||
public:
|
||||
FDTFluxQueuedRequestManager();
|
||||
virtual ~FDTFluxQueuedRequestManager();
|
||||
|
||||
// === LIFECYCLE ===
|
||||
|
||||
/**
|
||||
* Initialiser le gestionnaire de requêtes
|
||||
* @param DefaultConfig Configuration par défaut pour les nouvelles requêtes
|
||||
*/
|
||||
void Initialize(const FDTFluxRequestConfig& DefaultConfig = FDTFluxRequestConfig());
|
||||
|
||||
/**
|
||||
* Arrêter le gestionnaire et nettoyer toutes les ressources
|
||||
*/
|
||||
void Shutdown();
|
||||
|
||||
/**
|
||||
* Vérifier si le gestionnaire est initialisé
|
||||
*/
|
||||
bool IsInitialized() const { return bIsInitialized.load(); }
|
||||
|
||||
// === CRÉATION DE REQUÊTES ===
|
||||
|
||||
/**
|
||||
* Créer une nouvelle requête trackée
|
||||
* @param RequestType Type de requête (ContestRanking, StageRanking, etc.)
|
||||
* @param ContestId ID du contest (-1 si non applicable)
|
||||
* @param StageId ID du stage (-1 si non applicable)
|
||||
* @param SplitId ID du split (-1 si non applicable)
|
||||
* @param CustomConfig Configuration spécifique pour cette requête
|
||||
* @return GUID de la requête créée
|
||||
*/
|
||||
FGuid CreateTrackedRequest(
|
||||
EDTFluxApiDataType RequestType,
|
||||
int32 ContestId = -1,
|
||||
int32 StageId = -1,
|
||||
int32 SplitId = -1,
|
||||
const FDTFluxRequestConfig& CustomConfig = FDTFluxRequestConfig()
|
||||
);
|
||||
|
||||
/**
|
||||
* Créer une requête trackée avec callbacks C++
|
||||
* @param RequestType Type de requête
|
||||
* @param ContestId ID du contest
|
||||
* @param StageId ID du stage
|
||||
* @param SplitId ID du split
|
||||
* @param OnSuccess Callback appelé en cas de succès
|
||||
* @param OnError Callback appelé en cas d'erreur
|
||||
* @param CustomConfig Configuration spécifique
|
||||
* @return GUID de la requête créée
|
||||
*/
|
||||
FGuid CreateTrackedRequestWithCallbacks(
|
||||
EDTFluxApiDataType RequestType,
|
||||
int32 ContestId,
|
||||
int32 StageId,
|
||||
int32 SplitId,
|
||||
FOnDTFluxRequestSuccess OnSuccess,
|
||||
FOnDTFluxRequestError OnError,
|
||||
const FDTFluxRequestConfig& CustomConfig = FDTFluxRequestConfig()
|
||||
);
|
||||
|
||||
// === GESTION DES REQUÊTES ===
|
||||
|
||||
/**
|
||||
* Marquer une requête comme envoyée
|
||||
*/
|
||||
bool MarkRequestAsSent(const FGuid& RequestId);
|
||||
|
||||
/**
|
||||
* Compléter une requête avec la réponse reçue
|
||||
* @param RequestId ID de la requête
|
||||
* @param RawResponseData Données JSON brutes de la réponse
|
||||
* @param bUseAsyncParsing Utiliser le parsing asynchrone (recommandé)
|
||||
*/
|
||||
bool CompleteRequest(const FGuid& RequestId, const FString& RawResponseData, bool bUseAsyncParsing = true);
|
||||
|
||||
/**
|
||||
* Marquer une requête comme échouée
|
||||
*/
|
||||
bool FailRequest(const FGuid& RequestId, const FString& ErrorMessage);
|
||||
|
||||
/**
|
||||
* Relancer une requête (si retry possible)
|
||||
*/
|
||||
bool RetryRequest(const FGuid& RequestId);
|
||||
|
||||
// === RECHERCHE ET CACHE ===
|
||||
|
||||
/**
|
||||
* Chercher une requête en attente correspondant aux critères
|
||||
*/
|
||||
bool FindPendingRequest(
|
||||
FGuid& OutRequestId,
|
||||
EDTFluxApiDataType RequestType,
|
||||
int32 ContestId = -1,
|
||||
int32 StageId = -1,
|
||||
int32 SplitId = -1
|
||||
) const;
|
||||
|
||||
/**
|
||||
* Récupérer une réponse depuis le cache (données brutes)
|
||||
*/
|
||||
bool GetFromCache(
|
||||
EDTFluxApiDataType RequestType,
|
||||
FString& OutRawResponse,
|
||||
int32 ContestId = -1,
|
||||
int32 StageId = -1,
|
||||
int32 SplitId = -1
|
||||
) const;
|
||||
|
||||
/**
|
||||
* Récupérer une réponse parsée depuis le cache
|
||||
*/
|
||||
bool GetParsedFromCache(
|
||||
EDTFluxApiDataType RequestType,
|
||||
TSharedPtr<FDTFluxServerResponse>& OutResponse,
|
||||
int32 ContestId = -1,
|
||||
int32 StageId = -1,
|
||||
int32 SplitId = -1
|
||||
) const;
|
||||
|
||||
// === ACCESSEURS ===
|
||||
|
||||
/**
|
||||
* Récupérer une requête par son ID
|
||||
*/
|
||||
bool GetRequest(const FGuid& RequestId, FDTFluxTrackedRequest& OutRequest) const;
|
||||
|
||||
/**
|
||||
* Récupérer un pointeur vers une requête (plus efficace)
|
||||
*/
|
||||
const FDTFluxTrackedRequest* GetRequestPtr(const FGuid& RequestId) const;
|
||||
|
||||
/**
|
||||
* Récupérer toutes les requêtes dans un état donné
|
||||
*/
|
||||
TArray<FDTFluxTrackedRequest> GetRequestsByState(EDTFluxRequestState State) const;
|
||||
|
||||
/**
|
||||
* Compter les requêtes dans un état donné
|
||||
*/
|
||||
int32 GetRequestCount(EDTFluxRequestState State = EDTFluxRequestState::Pending) const;
|
||||
|
||||
// === STATISTIQUES ===
|
||||
|
||||
/**
|
||||
* Statistiques complètes du gestionnaire de requêtes
|
||||
*/
|
||||
struct FRequestStatistics
|
||||
{
|
||||
int32 Pending = 0;
|
||||
int32 Cached = 0;
|
||||
int32 Completed = 0;
|
||||
int32 Failed = 0;
|
||||
int32 TotalRequests = 0;
|
||||
int32 CacheHits = 0;
|
||||
int32 CacheMisses = 0;
|
||||
float HitRate = 0.0f;
|
||||
};
|
||||
|
||||
FRequestStatistics GetStatistics() const;
|
||||
|
||||
// === NETTOYAGE ===
|
||||
|
||||
/**
|
||||
* Nettoyer les entrées de cache expirées
|
||||
* @return Nombre d'entrées supprimées
|
||||
*/
|
||||
int32 CleanupExpiredCache();
|
||||
|
||||
/**
|
||||
* Nettoyer les requêtes terminées anciennes
|
||||
* @param OlderThanSeconds Supprimer les requêtes plus anciennes que ce délai
|
||||
* @return Nombre de requêtes supprimées
|
||||
*/
|
||||
int32 CleanupCompletedRequests(float OlderThanSeconds = 300.0f);
|
||||
|
||||
/**
|
||||
* Vider toutes les requêtes et le cache
|
||||
*/
|
||||
void ClearAllRequests();
|
||||
|
||||
// === EVENTS ===
|
||||
|
||||
FOnRequestStateChangedNative OnRequestStateChanged;
|
||||
FOnRequestCompletedNative OnRequestCompleted;
|
||||
FOnRequestFailedNative OnRequestFailed;
|
||||
|
||||
// === INTERFACE TICKABLE ===
|
||||
|
||||
// Interface FTickableGameObject
|
||||
virtual void Tick(float DeltaTime) override;
|
||||
virtual bool IsTickable() const override;
|
||||
virtual TStatId GetStatId() const override;
|
||||
virtual bool IsTickable() const override { return true; };
|
||||
|
||||
virtual TStatId GetStatId() const override
|
||||
{
|
||||
RETURN_QUICK_DECLARE_CYCLE_STAT(FDTFluxQueuedRequestManager, STATGROUP_Tickables);
|
||||
};
|
||||
virtual bool IsTickableWhenPaused() const override { return true; }
|
||||
virtual bool IsTickableInEditor() const override { return true; }
|
||||
// Interface ~FTickableGameObject
|
||||
|
||||
|
||||
UPROPERTY(BlueprintAssignable, Category = "DTFlux|Network")
|
||||
FOnRequestTimedOut OnRequestTimedOut;
|
||||
// === ACCESSEUR POUR LE PARSER (debug/stats) ===
|
||||
const FDTFluxAsyncParser* GetAsyncParser() const { return AsyncParser.Get(); }
|
||||
|
||||
private:
|
||||
TQueue<FDTFluxQueuedRequest, EQueueMode::Mpsc> PendingRequestsQueue;
|
||||
TQueue<FDTFluxQueuedRequest, EQueueMode::Mpsc> CompletedRequestsQueue;
|
||||
TQueue<FDTFluxQueuedRequest, EQueueMode::Mpsc> TimedOutRequestsQueue;
|
||||
// === CONFIGURATION ===
|
||||
FDTFluxRequestConfig DefaultConfig;
|
||||
std::atomic<bool> bIsInitialized{false};
|
||||
|
||||
bool bIsInitialized;
|
||||
float CheckInterval;
|
||||
float TimeSinceLastCheck;
|
||||
// === TIMING POUR LE TICK ===
|
||||
float TimeSinceLastTimeoutCheck = 0.0f;
|
||||
float TimeSinceLastCacheCleanup = 0.0f;
|
||||
float TimeSinceLastRetryCheck = 0.0f;
|
||||
|
||||
static constexpr float TimeoutCheckInterval = 1.0f;
|
||||
static constexpr float CacheCleanupInterval = 30.0f;
|
||||
static constexpr float RetryCheckInterval = 0.5f;
|
||||
|
||||
// === STOCKAGE THREAD-SAFE ===
|
||||
mutable FCriticalSection RequestsLock;
|
||||
TMap<FGuid, TSharedPtr<FDTFluxTrackedRequest>> AllRequests;
|
||||
TMap<FString, FGuid> CacheKeyToRequestId;
|
||||
|
||||
// === CALLBACKS C++ ===
|
||||
mutable FCriticalSection CallbacksLock;
|
||||
TMap<FGuid, FOnDTFluxRequestSuccess> SuccessCallbacks;
|
||||
TMap<FGuid, FOnDTFluxRequestError> ErrorCallbacks;
|
||||
|
||||
// === MÉTRIQUES ===
|
||||
mutable FCriticalSection MetricsLock;
|
||||
mutable int32 TotalRequests = 0;
|
||||
mutable int32 CacheHits = 0;
|
||||
mutable int32 CacheMisses = 0;
|
||||
|
||||
|
||||
// === PARSER ASYNCHRONE ===
|
||||
TUniquePtr<FDTFluxAsyncParser> AsyncParser;
|
||||
|
||||
// === MÉTHODES PRIVÉES ===
|
||||
|
||||
/**
|
||||
* Changer l'état d'une requête et notifier les observers
|
||||
*/
|
||||
void ChangeRequestState(TSharedPtr<FDTFluxTrackedRequest> Request, EDTFluxRequestState NewState);
|
||||
|
||||
/**
|
||||
* Traiter les requêtes en timeout (appelé périodiquement)
|
||||
*/
|
||||
void ProcessTimeouts();
|
||||
|
||||
/**
|
||||
* Traiter les requêtes à relancer (appelé périodiquement)
|
||||
*/
|
||||
void ProcessRetries();
|
||||
|
||||
/**
|
||||
* Nettoyer le cache périodiquement
|
||||
*/
|
||||
void ProcessCacheCleanup();
|
||||
|
||||
/**
|
||||
* Déclencher les callbacks pour une requête
|
||||
*/
|
||||
void TriggerCallbacks(const FDTFluxTrackedRequest& Request);
|
||||
|
||||
/**
|
||||
* Nettoyer les callbacks d'une requête
|
||||
*/
|
||||
void CleanupCallbacks(const FGuid& RequestId);
|
||||
|
||||
/**
|
||||
* Enregistrer un hit cache dans les métriques
|
||||
*/
|
||||
void RecordCacheHit() const;
|
||||
|
||||
/**
|
||||
* Enregistrer un miss cache dans les métriques
|
||||
*/
|
||||
void RecordCacheMiss() const;
|
||||
|
||||
|
||||
// === CALLBACKS POUR LE PARSING ASYNCHRONE ===
|
||||
|
||||
/**
|
||||
* Callback appelé quand le parsing asynchrone réussit
|
||||
*/
|
||||
void OnParsingCompleted(const FGuid& RequestId, TSharedPtr<FDTFluxServerResponse> ParsedResponse, bool bSuccess);
|
||||
|
||||
/**
|
||||
* Callback appelé quand le parsing asynchrone échoue
|
||||
*/
|
||||
void OnParsingFailed(const FGuid& RequestId, const FString& ErrorMessage);
|
||||
|
||||
// === UTILITAIRES STATIQUES ===
|
||||
|
||||
/**
|
||||
* Générer une clé de cache unique pour une requête
|
||||
*/
|
||||
static FString GenerateCacheKey(EDTFluxApiDataType RequestType, int32 ContestId, int32 StageId, int32 SplitId);
|
||||
};
|
||||
|
||||
@ -1,41 +1,54 @@
|
||||
// Fill out your copyright notice in the Description page of Project Settings.
|
||||
// ================================================================================================
|
||||
// DTFluxNetworkSubsystem.h - Interface UObject avec compatibilité Blueprint
|
||||
// ================================================================================================
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "CoreMinimal.h"
|
||||
#include "DTFluxQueuedManager.h"
|
||||
#include "Struct/DTFluxServerResponseStruct.h"
|
||||
#include "Subsystems/EngineSubsystem.h"
|
||||
#include "Types/DTFluxNetworkSettingsTypes.h"
|
||||
#include "Types/Enum/DTFluxCoreEnum.h"
|
||||
#include "Types/Struct/DTFluxRaceDataStructs.h"
|
||||
#include "Types/Struct/DTFluxRankingStructs.h"
|
||||
#include "Types/Struct/DTFluxSplitSensor.h"
|
||||
#include "Types/Struct/DTFluxTeamListStruct.h"
|
||||
#include "DTFluxQueuedManager.h"
|
||||
#include "DTFluxNetworkSubsystem.generated.h"
|
||||
|
||||
|
||||
// Forward declarations
|
||||
class FDTFluxWebSocketClient;
|
||||
class UDTFluxQueuedManager;
|
||||
class FDTFluxQueuedRequestManager;
|
||||
|
||||
typedef TSharedPtr<FDTFluxWebSocketClient> FDTFluxWebSocketClientSP;
|
||||
class FDTFluxHttpClient;
|
||||
typedef TSharedPtr<FDTFluxHttpClient> FDTFluxHttpClientSP;
|
||||
|
||||
// ================================================================================================
|
||||
// DELEGATES BLUEPRINT POUR LES REQUÊTES TRACKÉES
|
||||
// ================================================================================================
|
||||
|
||||
// Delegates pour les requêtes avec callback
|
||||
DECLARE_DELEGATE_TwoParams(FOnDTFluxRequestResponseError, const FGuid&, const FString&);
|
||||
DECLARE_DELEGATE_TwoParams(FOnDTFluxTrackedRequestResponse, const FGuid&, FDTFluxServerResponse&);
|
||||
DECLARE_DELEGATE_TwoParams(FOnDTFluxTrackedRequestTimeout, const FGuid&, const FString& /*ErrorMessage*/);
|
||||
// Delegates Blueprint pour les requêtes avec tracking
|
||||
DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams(FOnDTFluxTrackedRequestCompleted, const FGuid&, RequestId,
|
||||
EDTFluxApiDataType, RequestType, const FString&, ResponseData);
|
||||
|
||||
DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams(FOnDTFluxTrackedRequestFailed, const FGuid&, RequestId,
|
||||
EDTFluxApiDataType, RequestType, const FString&, ErrorMessage);
|
||||
|
||||
// ================================================================================================
|
||||
// DELEGATES LEGACY POUR LA COMPATIBILITÉ
|
||||
// ================================================================================================
|
||||
|
||||
DECLARE_DELEGATE_OneParam(FOnRaceDataReceived, const FDTFluxRaceData& /*RaceDataDefinition*/);
|
||||
DECLARE_DELEGATE_OneParam(FOnTeamListReceived, const FDTFluxTeamListDefinition& /*TeamListDefinition*/);
|
||||
DECLARE_DELEGATE_OneParam(FOnStageRankingReceived, const FDTFluxStageRankings& /*StageRankings*/);
|
||||
DECLARE_DELEGATE_OneParam(FOnSplitRankingReceived, const FDTFluxSplitRankings& /*SplitRankings*/);
|
||||
DECLARE_DELEGATE_OneParam(FOnContestRankingReceived, const FDTFluxContestRankings& /*ContestRankings*/);
|
||||
DECLARE_DELEGATE_OneParam(FOnSplitSensorReceived, const FDTFluxSplitSensorInfo& /*SplitSensorInfo*/);
|
||||
DECLARE_DELEGATE_OneParam(FOnTeamUpdateReceived, const FDTFluxTeamListDefinition& /*ParticipantToUpdate*/);
|
||||
DECLARE_DELEGATE_OneParam(FOnTeamStatusUpdateReceived, const FDTFluxTeamStatusUpdate& /*TeamToUpdate*/);
|
||||
|
||||
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FOnWebSocketConnected);
|
||||
|
||||
// ================================================================================================
|
||||
// NETWORK SUBSYSTEM - Interface UObject avec compatibilité Blueprint
|
||||
// ================================================================================================
|
||||
|
||||
/**
|
||||
*
|
||||
* Subsystem réseau DTFlux avec support complet des requêtes trackées et compatibilité legacy
|
||||
* Combine l'efficacité du RequestManager C++ avec l'interface Blueprint UObject
|
||||
*/
|
||||
UCLASS(Blueprintable)
|
||||
class DTFLUXNETWORK_API UDTFluxNetworkSubsystem : public UEngineSubsystem
|
||||
@ -43,180 +56,236 @@ class DTFLUXNETWORK_API UDTFluxNetworkSubsystem : public UEngineSubsystem
|
||||
GENERATED_BODY()
|
||||
|
||||
public:
|
||||
UPROPERTY()
|
||||
// === ÉTAT DE CONNEXION ===
|
||||
UPROPERTY(BlueprintReadOnly, Category = "DTFlux|Network")
|
||||
EDTFluxConnectionStatus WsStatus = EDTFluxConnectionStatus::Unset;
|
||||
|
||||
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FOnWebSocketConnected);
|
||||
// === CONNEXION WEBSOCKET (Legacy) ===
|
||||
|
||||
UPROPERTY(BlueprintAssignable, Category="DTFlux|Network")
|
||||
FOnWebSocketConnected OnWebSocketConnected;
|
||||
|
||||
DECLARE_DELEGATE_OneParam(FOnRaceDataReceived, const FDTFluxRaceData& /*RaceDataDefinition*/);
|
||||
FOnRaceDataReceived OnRaceDataReceived;
|
||||
|
||||
FOnRaceDataReceived& OnReceivedRaceData()
|
||||
{
|
||||
return OnRaceDataReceived;
|
||||
};
|
||||
|
||||
// === DELEGATES POUR LES DONNÉES REÇUES (PUSH) ===
|
||||
DECLARE_DELEGATE_OneParam(FOnTeamListReceived, const FDTFluxTeamListDefinition& /*TeamListDefinition*/);
|
||||
FOnTeamListReceived OnTeamListReceived;
|
||||
|
||||
FOnTeamListReceived& OnReceivedTeamList()
|
||||
{
|
||||
return OnTeamListReceived;
|
||||
};
|
||||
|
||||
DECLARE_DELEGATE_OneParam(FOnStageRankingReceived, const FDTFluxStageRankings& /*StageRankings*/);
|
||||
FOnStageRankingReceived OnStageRankingReceived;
|
||||
|
||||
FOnStageRankingReceived& OnReceivedStageRanking()
|
||||
{
|
||||
return OnStageRankingReceived;
|
||||
}
|
||||
|
||||
DECLARE_DELEGATE_OneParam(FOnSplitRankingReceived, const FDTFluxSplitRankings& /*SplitRankings*/);
|
||||
FOnSplitRankingReceived OnSplitRankingReceived;
|
||||
|
||||
FOnSplitRankingReceived& OnReceivedSplitRanking()
|
||||
{
|
||||
return OnSplitRankingReceived;
|
||||
}
|
||||
|
||||
DECLARE_DELEGATE_OneParam(FOnContestRankingReceived, const FDTFluxContestRankings& /*ContestRankings*/);
|
||||
FOnContestRankingReceived OnContestRankingReceived;
|
||||
|
||||
FOnContestRankingReceived& OnReceivedContestRanking()
|
||||
{
|
||||
return OnContestRankingReceived;
|
||||
};
|
||||
|
||||
// === DELEGATES POUR LES DONNÉES REÇUES (PULL) ===
|
||||
DECLARE_DELEGATE_OneParam(FOnSplitSensorReceived, const FDTFluxSplitSensorInfo& /*ContestRankings*/);
|
||||
FOnSplitSensorReceived OnSplitSensorReceived;
|
||||
|
||||
FOnSplitSensorReceived& OnReceivedSplitSensor()
|
||||
{
|
||||
return OnSplitSensorReceived;
|
||||
};
|
||||
|
||||
DECLARE_DELEGATE_OneParam(FOnTeamUpdateReceived, const FDTFluxTeamListDefinition& /*ParticipantToUpdate*/);
|
||||
FOnTeamUpdateReceived OnTeamUpdateReceived;
|
||||
|
||||
FOnTeamUpdateReceived& OnReceivedTeamUpdate()
|
||||
{
|
||||
return OnTeamUpdateReceived;
|
||||
};
|
||||
|
||||
DECLARE_DELEGATE_OneParam(FOnTeamStatusUpdateReceived, const FDTFluxTeamStatusUpdate& /*TeamToUpdate*/);
|
||||
FOnTeamStatusUpdateReceived OnTeamStatusUpdateReceived;
|
||||
|
||||
FOnTeamStatusUpdateReceived& OnReceivedTeamStatusUpdate()
|
||||
{
|
||||
return OnTeamStatusUpdateReceived;
|
||||
};
|
||||
|
||||
UFUNCTION(BlueprintCallable, Category="DTFlux|Network")
|
||||
/**
|
||||
* Se connecter au serveur WebSocket
|
||||
*/
|
||||
UFUNCTION(BlueprintCallable, Category = "DTFlux|Network")
|
||||
void Connect();
|
||||
UFUNCTION(BlueprintCallable, Category="DTFlux|Network")
|
||||
|
||||
/**
|
||||
* Se déconnecter du serveur WebSocket
|
||||
*/
|
||||
UFUNCTION(BlueprintCallable, Category = "DTFlux|Network")
|
||||
void Disconnect();
|
||||
UFUNCTION(BlueprintCallable, Category="DTFlux|Network")
|
||||
|
||||
/**
|
||||
* Reconnecter au serveur WebSocket
|
||||
*/
|
||||
UFUNCTION(BlueprintCallable, Category = "DTFlux|Network")
|
||||
void Reconnect();
|
||||
|
||||
// === REQUÊTES TRACKÉES (Nouveau système optimisé) ===
|
||||
|
||||
// === REQUÊTES AVEC QUEUE ET TRACKING ===
|
||||
UFUNCTION(BlueprintCallable, Category="DTFlux|Tracked Requests")
|
||||
FGuid SendTrackedRequest(EDTFluxApiDataType RequestType, int32 ContestId = -1, int32 StageId = -1,
|
||||
int32 SplitId = -1, float TimeoutSeconds = 30.0f);
|
||||
/**
|
||||
* Envoyer une requête trackée avec cache, timeout et retry
|
||||
* @param RequestType Type de requête (ContestRanking, StageRanking, etc.)
|
||||
* @param ContestId ID du contest (-1 si non applicable)
|
||||
* @param StageId ID du stage (-1 si non applicable)
|
||||
* @param SplitId ID du split (-1 si non applicable)
|
||||
* @param TimeoutSeconds Timeout en secondes
|
||||
* @param MaxRetries Nombre maximum de tentatives
|
||||
* @param bEnableCache Activer le cache pour cette requête
|
||||
* @return GUID de la requête pour le suivi
|
||||
*/
|
||||
UFUNCTION(BlueprintCallable, Category = "DTFlux|Tracked Requests")
|
||||
FGuid SendTrackedRequest(
|
||||
EDTFluxApiDataType RequestType,
|
||||
int32 ContestId = -1,
|
||||
int32 StageId = -1,
|
||||
int32 SplitId = -1,
|
||||
float TimeoutSeconds = 5.0f,
|
||||
int32 MaxRetries = 3,
|
||||
bool bEnableCache = true
|
||||
);
|
||||
|
||||
FGuid SendTrackedRequestWithCallback(EDTFluxApiDataType RequestType, int32 ContestId, int32 StageId, int32 SplitId,
|
||||
FOnDTFluxTrackedRequestResponse OnCompleted,
|
||||
FOnDTFluxTrackedRequestTimeout OnTimeout,
|
||||
TOptional<FOnDTFluxRequestResponseError> OnError = TOptional<
|
||||
FOnDTFluxRequestResponseError>(),
|
||||
float TimeoutSeconds = 30.0f);
|
||||
/**
|
||||
* Envoyer une requête trackée avec callbacks C++ (non Blueprint)
|
||||
* @param RequestType Type de requête
|
||||
* @param ContestId ID du contest
|
||||
* @param StageId ID du stage
|
||||
* @param SplitId ID du split
|
||||
* @param OnSuccess Callback appelé en cas de succès
|
||||
* @param OnError Callback appelé en cas d'erreur
|
||||
* @param TimeoutSeconds Timeout en secondes
|
||||
* @param MaxRetries Nombre maximum de tentatives
|
||||
* @param bEnableCache Activer le cache
|
||||
* @return GUID de la requête
|
||||
*/
|
||||
FGuid SendTrackedRequestWithCallbacks(
|
||||
EDTFluxApiDataType RequestType,
|
||||
int32 ContestId,
|
||||
int32 StageId,
|
||||
int32 SplitId,
|
||||
FOnDTFluxRequestSuccess& OnSuccess,
|
||||
FOnDTFluxRequestError& OnError,
|
||||
float TimeoutSeconds = 5.0f,
|
||||
int32 MaxRetries = 3,
|
||||
bool bEnableCache = true
|
||||
);
|
||||
|
||||
UFUNCTION(BlueprintCallable, Category="DTFlux|Tracked Requests")
|
||||
bool GetTrackedRequest(const FGuid& RequestId, FDTFluxQueuedRequest& OutRequest) const;
|
||||
const FDTFluxQueuedRequest* GetTrackedRequestPtr(const FGuid& RequestId) const;
|
||||
UFUNCTION(BlueprintCallable, Category="DTFlux|Tracked Requests", CallInEditor)
|
||||
// === ACCESSEURS BLUEPRINT POUR LES REQUÊTES TRACKÉES ===
|
||||
|
||||
/**
|
||||
* Récupérer une requête trackée par son ID
|
||||
*/
|
||||
UFUNCTION(BlueprintCallable, Category = "DTFlux|Tracked Requests")
|
||||
bool GetTrackedRequest(const FGuid& RequestId, FDTFluxTrackedRequest& OutRequest) const;
|
||||
|
||||
/**
|
||||
* Vérifier si une requête a reçu une réponse
|
||||
*/
|
||||
UFUNCTION(BlueprintCallable, Category = "DTFlux|Tracked Requests")
|
||||
bool HasRequestReceivedResponse(const FGuid& RequestId) const;
|
||||
UFUNCTION(BlueprintCallable, Category="DTFlux|Tracked Requests")
|
||||
|
||||
/**
|
||||
* Récupérer les données de réponse d'une requête
|
||||
*/
|
||||
UFUNCTION(BlueprintCallable, Category = "DTFlux|Tracked Requests")
|
||||
FString GetRequestResponseData(const FGuid& RequestId) const;
|
||||
UFUNCTION(BlueprintCallable, Category="DTFlux|Tracked Requests")
|
||||
|
||||
/**
|
||||
* Vérifier si une requête similaire est en attente
|
||||
*/
|
||||
UFUNCTION(BlueprintCallable, Category = "DTFlux|Tracked Requests")
|
||||
bool IsRequestPending(EDTFluxApiDataType RequestType, int32 ContestId = -1, int32 StageId = -1,
|
||||
int32 SplitId = -1) const;
|
||||
UFUNCTION(BlueprintCallable, Category="DTFlux|Tracked Requests")
|
||||
|
||||
/**
|
||||
* Compter le nombre de requêtes en attente
|
||||
*/
|
||||
UFUNCTION(BlueprintCallable, Category = "DTFlux|Tracked Requests")
|
||||
int32 GetPendingRequestCount() const;
|
||||
UFUNCTION(BlueprintCallable, Category="DTFlux|Tracked Requests")
|
||||
UDTFluxQueuedManager* GetQueueManager() const;
|
||||
|
||||
// === EVENTS BLUEPRINT POUR LE TRACKING ===
|
||||
UPROPERTY(BlueprintAssignable, Category="DTFlux|Tracked Requests")
|
||||
FOnDTFluxTrackedRequestCompleted OnTrackedRequestCompleted;
|
||||
UPROPERTY(BlueprintAssignable, Category="DTFlux|Tracked Requests")
|
||||
FOnDTFluxTrackedRequestFailed OnTrackedRequestFailed;
|
||||
UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
|
||||
/**
|
||||
* Récupérer les statistiques du gestionnaire de requêtes
|
||||
*/
|
||||
UFUNCTION(BlueprintCallable, Category = "DTFlux|Tracked Requests")
|
||||
void GetRequestStatistics(int32& OutPending, int32& OutCached, int32& OutCompleted, int32& OutFailed,
|
||||
float& OutHitRate) const;
|
||||
|
||||
// === REQUÊTES DIRECTES (LEGACY) ===
|
||||
// === REQUÊTES LEGACY (Compatibilité totale) ===
|
||||
|
||||
/**
|
||||
* Envoyer une requête en mode legacy (pour compatibilité)
|
||||
*/
|
||||
UFUNCTION(BlueprintCallable, Category = "DTFlux|Legacy")
|
||||
void SendRequest(const EDTFluxApiDataType RequestType, int InContestId = -1, int InStageId = -1,
|
||||
int InSplitId = -1);
|
||||
UFUNCTION(BlueprintCallable, Category="DTFlux|Network")
|
||||
|
||||
/**
|
||||
* Envoyer un message brut via WebSocket
|
||||
*/
|
||||
UFUNCTION(BlueprintCallable, Category = "DTFlux|Network")
|
||||
void SendMessage(const FString& Message);
|
||||
|
||||
// === EVENTS BLUEPRINT ===
|
||||
|
||||
/**
|
||||
* Event déclenché lors de la connexion WebSocket
|
||||
*/
|
||||
UPROPERTY(BlueprintAssignable, Category = "DTFlux|Network")
|
||||
FOnWebSocketConnected OnWebSocketConnected;
|
||||
|
||||
/**
|
||||
* Event déclenché quand une requête trackée se termine avec succès
|
||||
*/
|
||||
UPROPERTY(BlueprintAssignable, Category = "DTFlux|Tracked Requests")
|
||||
FOnDTFluxTrackedRequestCompleted OnTrackedRequestCompleted;
|
||||
|
||||
/**
|
||||
* Event déclenché quand une requête trackée échoue
|
||||
*/
|
||||
UPROPERTY(BlueprintAssignable, Category = "DTFlux|Tracked Requests")
|
||||
FOnDTFluxTrackedRequestFailed OnTrackedRequestFailed;
|
||||
|
||||
// === DELEGATES LEGACY (Compatibilité totale) ===
|
||||
|
||||
FOnRaceDataReceived OnRaceDataReceived;
|
||||
FOnTeamListReceived OnTeamListReceived;
|
||||
FOnStageRankingReceived OnStageRankingReceived;
|
||||
FOnSplitRankingReceived OnSplitRankingReceived;
|
||||
FOnContestRankingReceived OnContestRankingReceived;
|
||||
FOnSplitSensorReceived OnSplitSensorReceived;
|
||||
FOnTeamUpdateReceived OnTeamUpdateReceived;
|
||||
FOnTeamStatusUpdateReceived OnTeamStatusUpdateReceived;
|
||||
|
||||
// Accesseurs pour la compatibilité legacy
|
||||
FOnRaceDataReceived& OnReceivedRaceData() { return OnRaceDataReceived; }
|
||||
FOnTeamListReceived& OnReceivedTeamList() { return OnTeamListReceived; }
|
||||
FOnStageRankingReceived& OnReceivedStageRanking() { return OnStageRankingReceived; }
|
||||
FOnSplitRankingReceived& OnReceivedSplitRanking() { return OnSplitRankingReceived; }
|
||||
FOnContestRankingReceived& OnReceivedContestRanking() { return OnContestRankingReceived; }
|
||||
FOnSplitSensorReceived& OnReceivedSplitSensor() { return OnSplitSensorReceived; }
|
||||
FOnTeamUpdateReceived& OnReceivedTeamUpdate() { return OnTeamUpdateReceived; }
|
||||
FOnTeamStatusUpdateReceived& OnReceivedTeamStatusUpdate() { return OnTeamStatusUpdateReceived; }
|
||||
|
||||
// === ACCESSEUR PUBLIC POUR LE REQUEST MANAGER ===
|
||||
|
||||
/**
|
||||
* Accéder au gestionnaire de requêtes (pour usage avancé)
|
||||
*/
|
||||
TSharedPtr<FDTFluxQueuedRequestManager> GetRequestManager() const { return RequestManager; }
|
||||
|
||||
protected:
|
||||
// ~Subsystem Interface
|
||||
// === LIFECYCLE DU SUBSYSTEM ===
|
||||
virtual void Initialize(FSubsystemCollectionBase& Collection) override;
|
||||
virtual void Deinitialize() override;
|
||||
// ~Subsystem Interface
|
||||
|
||||
|
||||
private:
|
||||
// === CONFIGURATION ===
|
||||
FDTFluxWsSettings WsSettings;
|
||||
FDTFluxHttpSettings HttpSettings;
|
||||
|
||||
UPROPERTY()
|
||||
UDTFluxQueuedManager* QueueManager;
|
||||
|
||||
// === MAPPING DES CALLBACKS C++ ===
|
||||
TMap<FGuid, FOnDTFluxTrackedRequestResponse> PendingCallbacks;
|
||||
TMap<FGuid, FOnDTFluxTrackedRequestTimeout> PendingTimeoutCallbacks;
|
||||
TMap<FGuid, FOnDTFluxRequestResponseError> PendingErrorCallbacks;
|
||||
|
||||
// === CLIENTS RÉSEAU ===
|
||||
FDTFluxWebSocketClientSP WsClient = nullptr;
|
||||
FDTFluxHttpClientSP HttpClient = nullptr;
|
||||
|
||||
// === MÉTHODES DE CONFIGURATION ===
|
||||
UFUNCTION()
|
||||
void WsSettingsChanged(const FDTFluxWsSettings& NewWsSettings);
|
||||
UFUNCTION()
|
||||
void HttpSettingsChanged(const FDTFluxHttpSettings& NewHttpSettings);
|
||||
void ReconnectWs(const FName WsClientId);
|
||||
void ReconnectHttp(const FName WsClientId);
|
||||
// === REQUEST MANAGER C++ ===
|
||||
TSharedPtr<FDTFluxQueuedRequestManager> RequestManager;
|
||||
|
||||
// === GESTION DES ÉVÉNEMENTS WEBSOCKET ===
|
||||
void RegisterWebSocketEvents();
|
||||
void UnregisterWebSocketEvents();
|
||||
|
||||
void OnWebSocketConnected_Subsystem();
|
||||
void OnWebSocketConnectionError_Subsystem(const FString& Error);
|
||||
void OnWebSocketClosedEvent_Subsystem(int32 StatusCode, const FString& Reason, bool bWasClean);
|
||||
void OnWebSocketMessageEvent_Subsystem(const FString& MessageString);
|
||||
void OnWebSocketMessageSentEvent_Subsystem(const FString& MessageSent);
|
||||
|
||||
// Handles pour les événements WebSocket
|
||||
FDelegateHandle OnWsConnectedEventDelegateHandle;
|
||||
FDelegateHandle OnWsConnectionErrorEventDelegateHandle;
|
||||
FDelegateHandle OnWsClosedEventDelegateHandle;
|
||||
FDelegateHandle OnWsMessageEventDelegateHandle;
|
||||
FDelegateHandle OnWsMessageSentEventDelegateHandle;
|
||||
|
||||
// === GESTION DES ÉVÉNEMENTS HTTP ===
|
||||
void RegisterHttpEvents();
|
||||
void UnregisterHttpEvents();
|
||||
// === PARSING ET TRAITEMENT DES RÉPONSES ===
|
||||
|
||||
// === PARSING DES RÉPONSES ===
|
||||
void ParseTeamListResponse(FDTFluxServerResponse& ServerResponse);
|
||||
/**
|
||||
* Essayer de matcher une réponse à une requête trackée
|
||||
* @param MessageString Message JSON reçu
|
||||
* @return true si la réponse correspond à une requête trackée
|
||||
*/
|
||||
bool TryMatchResponseToQueuedRequest(const FString& MessageString);
|
||||
|
||||
/**
|
||||
* Traiter une réponse en mode legacy
|
||||
* @param MessageString Message JSON à traiter
|
||||
*/
|
||||
void ProcessLegacyResponse(const FString& MessageString);
|
||||
|
||||
/**
|
||||
* Traiter une réponse déjà parsée
|
||||
* @param ParsedResponse Réponse parsée à traiter
|
||||
*/
|
||||
void ProcessParsedResponse(TSharedPtr<FDTFluxServerResponse> ParsedResponse);
|
||||
|
||||
// === MÉTHODES DE PARSING LEGACY (pour compatibilité) ===
|
||||
void ParseTeamListResponse(FDTFluxServerResponse& Response);
|
||||
void ParseRaceData(FDTFluxServerResponse& Response);
|
||||
void ParseContestRanking(FDTFluxServerResponse& Response);
|
||||
void ParseStageRankingResponse(FDTFluxServerResponse& Response);
|
||||
@ -225,19 +294,45 @@ private:
|
||||
void ParseSplitSensorResponse(FDTFluxServerResponse& Response);
|
||||
EDTFluxResponseStatus ProcessPushMessage(FDTFluxServerResponse& Response);
|
||||
|
||||
void Parse(FDTFluxServerResponse& Response);
|
||||
void OnWebSocketMessageEvent_Subsystem(const FString& MessageString);
|
||||
void OnWebSocketMessageSentEvent_Subsystem(const FString& MessageSent);
|
||||
bool CleanRequestCallbacks(const FGuid& RequestId);
|
||||
// === CALLBACKS POUR LE REQUEST MANAGER ===
|
||||
|
||||
// === GESTION DES REQUÊTES TRACKÉES ===
|
||||
/**
|
||||
* Callback appelé quand une requête trackée se termine
|
||||
*/
|
||||
void OnRequestCompleted_Internal(const FDTFluxTrackedRequest& CompletedRequest);
|
||||
|
||||
/**
|
||||
* Callback appelé quand une requête trackée échoue
|
||||
*/
|
||||
void OnRequestFailed_Internal(const FDTFluxTrackedRequest& FailedRequest);
|
||||
|
||||
// === CONFIGURATION DYNAMIQUE ===
|
||||
|
||||
/**
|
||||
* Callback appelé quand les paramètres WebSocket changent
|
||||
*/
|
||||
UFUNCTION()
|
||||
void OnRequestTimedOut_Internal(const FDTFluxQueuedRequest& TimedOutRequest);
|
||||
bool TryMatchResponseToQueuedRequest(FDTFluxServerResponse& Response);
|
||||
void CompleteTrackedRequest(const FGuid& RequestId, const FString& ResponseData, EDTFluxRequestType RequestType);
|
||||
void FailTrackedRequest(const FGuid& RequestId, const FString& ErrorMessage, EDTFluxRequestType RequestType);
|
||||
void SendQueuedRequest(const FDTFluxQueuedRequest& QueuedRequest);
|
||||
void WsSettingsChanged(const FDTFluxWsSettings& NewWsSettings);
|
||||
|
||||
/**
|
||||
* Reconnecter le client WebSocket
|
||||
*/
|
||||
void ReconnectWs(const FName WsClientId);
|
||||
|
||||
// === UTILITAIRES ===
|
||||
|
||||
/**
|
||||
* Construire une adresse WebSocket complète
|
||||
*/
|
||||
static FString ConstructWsAddress(const FString& Address, const FString& Path, const int& Port);
|
||||
|
||||
/**
|
||||
* Envoyer une requête trackée via le réseau
|
||||
*/
|
||||
void SendQueuedRequest(const FDTFluxTrackedRequest& QueuedRequest);
|
||||
|
||||
/**
|
||||
* Déterminer si on doit utiliser le parsing asynchrone
|
||||
*/
|
||||
bool ShouldUseAsyncParsing(const FString& JsonData) const;
|
||||
};
|
||||
|
||||
Reference in New Issue
Block a user