Ange/DTFluxAPI
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Removed CachedRequest functionality + Fixed(Tested) PursuitSequence bug

Browse Source
This commit is contained in:
Ange-Marie MAURIN
2025-07-12 16:07:37 +02:00
parent a08bcd98a4
commit f1d583926b
8 changed files with 190 additions and 400 deletions
Download Patch File Download Diff File Expand all files Collapse all files

240
Source/DTFluxNetwork/Private/DTFluxQueuedManager.cpp
View File

@ -23,11 +23,6 @@ bool FDTFluxTrackedRequest::CanRetry() const
(State == EDTFluxRequestState::Failed || State == EDTFluxRequestState::TimedOut);
}
bool FDTFluxTrackedRequest::IsCacheValid() const
{
if (State != EDTFluxRequestState::Cached) return false;
return (FDateTime::Now() - CompletedAt).GetTotalSeconds() < Config.CacheValiditySeconds;
}
float FDTFluxTrackedRequest::GetRetryDelay() const
{
@ -40,11 +35,6 @@ bool FDTFluxTrackedRequest::Matches(EDTFluxApiDataType InType, int32 InContestId
return RequestType == InType && ContestId == InContestId && StageId == InStageId && SplitId == InSplitId;
}
FString FDTFluxTrackedRequest::GetCacheKey() const
{
return FString::Printf(TEXT("%s_%d_%d_%d"),
*UEnum::GetValueAsString(RequestType), ContestId, StageId, SplitId);
}
void FDTFluxTrackedRequest::SetRawResponse(const FString& RawData)
{
@ -118,8 +108,8 @@ void FDTFluxQueuedRequestManager::Initialize(const FDTFluxRequestConfig& InDefau
DefaultConfig = InDefaultConfig;
bIsInitialized.store(true);
UE_LOG(logDTFluxNetwork, Log, TEXT("RequestManager initialized with timeout=%.1fs, cache=%.1fs"),
DefaultConfig.TimeoutSeconds, DefaultConfig.CacheValiditySeconds);
UE_LOG(logDTFluxNetwork, Log, TEXT("RequestManager initialized with timeout=%.1fs"),
DefaultConfig.TimeoutSeconds);
}
void FDTFluxQueuedRequestManager::Shutdown()
@ -134,7 +124,6 @@ void FDTFluxQueuedRequestManager::Shutdown()
FScopeLock CallbacksLock_Local(&CallbacksLock);
AllRequests.Empty();
CacheKeyToRequestId.Empty();
SuccessCallbacks.Empty();
ErrorCallbacks.Empty();
}
@ -154,37 +143,7 @@ FGuid FDTFluxQueuedRequestManager::CreateTrackedRequest(
UE_LOG(logDTFluxNetwork, Error, TEXT("RequestManager not initialized"));
return FGuid();
}
// Vérifier le cache d'abord
FString CachedResponse;
if (CustomConfig.bEnableCache && GetFromCache(RequestType, CachedResponse, ContestId, StageId, SplitId))
{
UE_LOG(logDTFluxNetwork, Log, TEXT("Request served from cache: Type=%s"),
*UEnum::GetValueAsString(RequestType));
// Créer une "fausse" requête pour représenter le hit cache
auto CachedRequest = MakeShared<FDTFluxTrackedRequest>();
CachedRequest->RequestType = RequestType;
CachedRequest->ContestId = ContestId;
CachedRequest->StageId = StageId;
CachedRequest->SplitId = SplitId;
CachedRequest->Config = CustomConfig.bEnableCache ? CustomConfig : DefaultConfig;
CachedRequest->State = EDTFluxRequestState::Cached;
CachedRequest->RawResponseData = CachedResponse;
CachedRequest->CompletedAt = FDateTime::Now();
FGuid CacheRequestId = CachedRequest->RequestId;
{
FScopeLock Lock(&RequestsLock);
AllRequests.Add(CacheRequestId, CachedRequest);
}
RecordCacheHit();
return CacheRequestId;
}
// Créer une nouvelle requête
// Create new request
auto NewRequest = MakeShared<FDTFluxTrackedRequest>();
NewRequest->RequestType = RequestType;
NewRequest->ContestId = ContestId;
@ -199,12 +158,8 @@ FGuid FDTFluxQueuedRequestManager::CreateTrackedRequest(
AllRequests.Add(RequestId, NewRequest);
TotalRequests++;
}
RecordCacheMiss();
UE_LOG(logDTFluxNetwork, Log, TEXT("Created tracked request %s: Type=%s, Contest=%d, Stage=%d, Split=%d"),
*RequestId.ToString(), *UEnum::GetValueAsString(RequestType), ContestId, StageId, SplitId);
return RequestId;
}
@ -257,7 +212,6 @@ bool FDTFluxQueuedRequestManager::CompleteRequest(const FGuid& RequestId, const
{
UE_LOG(logDTFluxNetwork, Log, TEXT("FDTFluxQueuedRequestManager::CompleteRequest() %s"), *RequestId.ToString());
TSharedPtr<FDTFluxTrackedRequest> Request;
{
FScopeLock Lock(&RequestsLock);
if (TSharedPtr<FDTFluxTrackedRequest>* RequestPtr = AllRequests.Find(RequestId))
@ -265,19 +219,18 @@ bool FDTFluxQueuedRequestManager::CompleteRequest(const FGuid& RequestId, const
Request = *RequestPtr;
}
}
if (!Request.IsValid())
{
UE_LOG(logDTFluxNetwork, Warning, TEXT("Request %s not found"), *RequestId.ToString());
return false;
}
// Stocker la réponse brute
// Store RawResponse
Request->SetRawResponse(RawResponseData);
Request->CompletedAt = FDateTime::Now();
UE_LOG(logDTFluxNetwork, Log, TEXT("Request %s completed at %s"), *RequestId.ToString(),
*Request->CompletedAt.ToString());
// Décider du parsing selon les callbacks et la configuration
// Decide to parse based upon config
bool bHasCallbacks = false;
{
FScopeLock Lock(&CallbacksLock);
@ -292,7 +245,7 @@ bool FDTFluxQueuedRequestManager::CompleteRequest(const FGuid& RequestId, const
bHasCallbacks ? TEXT("true") : TEXT("false"), bUseAsyncParsing ? TEXT("true") : TEXT("false"),
RawResponseData.IsEmpty() ? TEXT("true") : TEXT("false"));
// Parsing asynchrone pour les callbacks
// Async parsing for Cb
FOnParsingCompleted OnCompleted = FOnParsingCompleted::CreateRaw(
this, &FDTFluxQueuedRequestManager::OnParsingCompleted
);
@ -300,9 +253,8 @@ bool FDTFluxQueuedRequestManager::CompleteRequest(const FGuid& RequestId, const
FOnParsingFailed OnFailed = FOnParsingFailed::CreateRaw(
this, &FDTFluxQueuedRequestManager::OnParsingFailed
);
// Maybe send to parser in another place
AsyncParser->ParseResponseAsync(RequestId, RawResponseData, OnCompleted, OnFailed);
// CleanupCallbacks(RequestId);
UE_LOG(logDTFluxNetwork, Verbose, TEXT("Started async parsing for request %s"), *RequestId.ToString());
return true;
}
@ -310,26 +262,21 @@ bool FDTFluxQueuedRequestManager::CompleteRequest(const FGuid& RequestId, const
{
UE_LOG(logDTFluxNetwork, Warning, TEXT("request %s completed without sync"), *RequestId.ToString());
// Compléter immédiatement sans parsing ou avec parsing sync
EDTFluxRequestState NewState = Request->Config.bEnableCache
? EDTFluxRequestState::Cached
: EDTFluxRequestState::Completed;
EDTFluxRequestState NewState = EDTFluxRequestState::Completed;
ChangeRequestState(Request, NewState);
if (Request->Config.bEnableCache)
{
FScopeLock Lock(&RequestsLock);
CacheKeyToRequestId.Add(Request->GetCacheKey(), RequestId);
}
// Déclencher les callbacks avec les données brutes
TriggerCallbacks(*Request);
CleanupCallbacks(RequestId);
return true;
}
}
/**
* @todo Check protocol errors ???
* @param RequestId
* @param ErrorMessage
* @return
*/
bool FDTFluxQueuedRequestManager::FailRequest(const FGuid& RequestId, const FString& ErrorMessage)
{
TSharedPtr<FDTFluxTrackedRequest> Request;
@ -350,7 +297,6 @@ bool FDTFluxQueuedRequestManager::FailRequest(const FGuid& RequestId, const FStr
Request->LastErrorMessage = ErrorMessage;
ChangeRequestState(Request, EDTFluxRequestState::Failed);
// Déclencher les callbacks d'erreur
TriggerCallbacks(*Request);
CleanupCallbacks(RequestId);
@ -407,76 +353,6 @@ bool FDTFluxQueuedRequestManager::FindPendingRequest(
return false;
}
bool FDTFluxQueuedRequestManager::GetFromCache(
EDTFluxApiDataType RequestType,
FString& OutRawResponse,
int32 ContestId,
int32 StageId,
int32 SplitId) const
{
FString CacheKey = GenerateCacheKey(RequestType, ContestId, StageId, SplitId);
FScopeLock Lock(&RequestsLock);
if (const FGuid* RequestId = CacheKeyToRequestId.Find(CacheKey))
{
if (const TSharedPtr<FDTFluxTrackedRequest>* RequestPtr = AllRequests.Find(*RequestId))
{
const TSharedPtr<FDTFluxTrackedRequest>& CachedRequest = *RequestPtr;
if (CachedRequest->IsCacheValid() && !CachedRequest->RawResponseData.IsEmpty())
{
OutRawResponse = CachedRequest->RawResponseData;
return true;
}
}
}
return false;
}
bool FDTFluxQueuedRequestManager::GetParsedFromCache(
EDTFluxApiDataType RequestType,
TSharedPtr<FDTFluxServerResponse>& OutResponse,
int32 ContestId,
int32 StageId,
int32 SplitId) const
{
FString CacheKey = GenerateCacheKey(RequestType, ContestId, StageId, SplitId);
FScopeLock Lock(&RequestsLock);
if (const FGuid* RequestId = CacheKeyToRequestId.Find(CacheKey))
{
if (const TSharedPtr<FDTFluxTrackedRequest>* RequestPtr = AllRequests.Find(*RequestId))
{
const TSharedPtr<FDTFluxTrackedRequest>& CachedRequest = *RequestPtr;
if (CachedRequest->IsCacheValid())
{
// Parsing lazy si nécessaire
if (!CachedRequest->ParsedResponse.IsSet() && !CachedRequest->RawResponseData.IsEmpty())
{
OutResponse = AsyncParser->ParseResponseSync(CachedRequest->RawResponseData, 1.0f);
if (OutResponse.IsValid())
{
CachedRequest->ParsedResponse = OutResponse;
const_cast<FDTFluxTrackedRequest*>(CachedRequest.Get())->bIsResponseParsed = true;
}
}
else if (CachedRequest->ParsedResponse.IsSet())
{
OutResponse = CachedRequest->ParsedResponse.GetValue();
}
return OutResponse.IsValid();
}
}
}
return false;
}
// === ACCESSEURS ===
bool FDTFluxQueuedRequestManager::GetRequest(const FGuid& RequestId, FDTFluxTrackedRequest& OutRequest) const
@ -554,9 +430,6 @@ FDTFluxQueuedRequestManager::FRequestStatistics FDTFluxQueuedRequestManager::Get
case EDTFluxRequestState::Retrying:
Stats.Pending++;
break;
case EDTFluxRequestState::Cached:
Stats.Cached++;
break;
case EDTFluxRequestState::Completed:
Stats.Completed++;
break;
@ -568,46 +441,10 @@ FDTFluxQueuedRequestManager::FRequestStatistics FDTFluxQueuedRequestManager::Get
}
Stats.TotalRequests = TotalRequests;
Stats.CacheHits = CacheHits;
Stats.CacheMisses = CacheMisses;
if (Stats.TotalRequests > 0)
{
Stats.HitRate = ((float)Stats.CacheHits / (float)Stats.TotalRequests) * 100.0f;
}
return Stats;
}
// === NETTOYAGE ===
int32 FDTFluxQueuedRequestManager::CleanupExpiredCache()
{
FScopeLock Lock(&RequestsLock);
TArray<FGuid> ExpiredRequests;
for (const auto& [RequestId, Request] : AllRequests)
{
if (Request->State == EDTFluxRequestState::Cached && !Request->IsCacheValid())
{
ExpiredRequests.Add(RequestId);
}
}
for (const FGuid& RequestId : ExpiredRequests)
{
if (TSharedPtr<FDTFluxTrackedRequest>* RequestPtr = AllRequests.Find(RequestId))
{
const TSharedPtr<FDTFluxTrackedRequest>& Request = *RequestPtr;
CacheKeyToRequestId.Remove(Request->GetCacheKey());
AllRequests.Remove(RequestId);
}
}
return ExpiredRequests.Num();
}
int32 FDTFluxQueuedRequestManager::CleanupCompletedRequests(float OlderThanSeconds)
{
FScopeLock Lock(&RequestsLock);
@ -638,7 +475,6 @@ void FDTFluxQueuedRequestManager::ClearAllRequests()
FScopeLock CallbacksLock_Local(&CallbacksLock);
AllRequests.Empty();
CacheKeyToRequestId.Empty();
SuccessCallbacks.Empty();
ErrorCallbacks.Empty();
@ -652,7 +488,6 @@ void FDTFluxQueuedRequestManager::Tick(float DeltaTime)
// Mise à jour des timers
TimeSinceLastTimeoutCheck += DeltaTime;
TimeSinceLastCacheCleanup += DeltaTime;
TimeSinceLastRetryCheck += DeltaTime;
// Vérifier les timeouts
@ -668,13 +503,6 @@ void FDTFluxQueuedRequestManager::Tick(float DeltaTime)
ProcessRetries();
TimeSinceLastRetryCheck = 0.0f;
}
// Nettoyage du cache
if (TimeSinceLastCacheCleanup >= CacheCleanupInterval)
{
ProcessCacheCleanup();
TimeSinceLastCacheCleanup = 0.0f;
}
}
void FDTFluxQueuedRequestManager::ChangeRequestState(TSharedPtr<FDTFluxTrackedRequest> Request,
@ -756,17 +584,11 @@ void FDTFluxQueuedRequestManager::ProcessRetries()
}
}
void FDTFluxQueuedRequestManager::ProcessCacheCleanup()
{
CleanupExpiredCache();
CleanupCompletedRequests(600.0f);
}
void FDTFluxQueuedRequestManager::TriggerCallbacks(const FDTFluxTrackedRequest& Request)
{
FScopeLock Lock(&CallbacksLock);
if (Request.State == EDTFluxRequestState::Completed || Request.State == EDTFluxRequestState::Cached)
if (Request.State == EDTFluxRequestState::Completed)
{
// Success Cb
const FOnDTFluxRequestSuccess* SuccessCallback = SuccessCallbacks.Find(Request.RequestId);
@ -793,18 +615,6 @@ void FDTFluxQueuedRequestManager::CleanupCallbacks(const FGuid& RequestId)
ErrorCallbacks.Remove(RequestId);
}
void FDTFluxQueuedRequestManager::RecordCacheHit() const
{
FScopeLock Lock(&MetricsLock);
CacheHits++;
}
void FDTFluxQueuedRequestManager::RecordCacheMiss() const
{
FScopeLock Lock(&MetricsLock);
CacheMisses++;
}
void FDTFluxQueuedRequestManager::OnParsingCompleted(const FGuid& RequestId,
TSharedPtr<FDTFluxServerResponse> ParsedResponse, bool bSuccess)
{
@ -833,16 +643,9 @@ void FDTFluxQueuedRequestManager::OnParsingCompleted(const FGuid& RequestId,
{
Request->ParsedResponse = ParsedResponse;
Request->bIsResponseParsed = true;
EDTFluxRequestState NewState = Request->Config.bEnableCache
? EDTFluxRequestState::Cached
: EDTFluxRequestState::Completed;
EDTFluxRequestState NewState = EDTFluxRequestState::Completed;
ChangeRequestState(Request, NewState);
if (Request->Config.bEnableCache)
{
FScopeLock Lock(&RequestsLock);
CacheKeyToRequestId.Add(Request->GetCacheKey(), RequestId);
}
UE_LOG(logDTFluxNetwork, Log,
TEXT("DTFluxQueuedRequestManager: Async parsing completed for request %s"),
*RequestId.ToString());
@ -854,7 +657,6 @@ void FDTFluxQueuedRequestManager::OnParsingCompleted(const FGuid& RequestId,
UE_LOG(logDTFluxNetwork, Error, TEXT("Async parsing failed for request %s"), *RequestId.ToString());
}
// ✅ FIX: Déclencher les callbacks maintenant !
TriggerCallbacks(*Request);
CleanupCallbacks(RequestId);
}
@ -866,13 +668,3 @@ void FDTFluxQueuedRequestManager::OnParsingFailed(const FGuid& RequestId, const
*ErrorMessage);
FailRequest(RequestId, FString::Printf(TEXT("Parsing failed: %s"), *ErrorMessage));
}
FString FDTFluxQueuedRequestManager::GenerateCacheKey(EDTFluxApiDataType RequestType, int32 ContestId, int32 StageId,
int32 SplitId)
{
return FString::Printf(TEXT("%s_%d_%d_%d"),
*UEnum::GetValueAsString(RequestType),
ContestId,
StageId,
SplitId);
}

44
Source/DTFluxNetwork/Private/Subsystems/DTFluxNetworkSubsystem.cpp
View File

@ -36,8 +36,6 @@ void UDTFluxNetworkSubsystem::Initialize(FSubsystemCollectionBase& Collection)
DefaultConfig.TimeoutSeconds = 5.0f;
DefaultConfig.MaxRetries = 3;
DefaultConfig.RetryBackoffMultiplier = 1.5f;
DefaultConfig.bEnableCache = true;
DefaultConfig.CacheValiditySeconds = 60.0f;
RequestManager->Initialize(DefaultConfig);
@ -143,8 +141,6 @@ FGuid UDTFluxNetworkSubsystem::SendTrackedRequest(
FDTFluxRequestConfig CustomConfig;
CustomConfig.TimeoutSeconds = TimeoutSeconds;
CustomConfig.MaxRetries = MaxRetries;
CustomConfig.bEnableCache = bEnableCache;
CustomConfig.CacheValiditySeconds = 60.0f;
CustomConfig.RetryBackoffMultiplier = 1.5f;
FGuid RequestId = RequestManager->CreateTrackedRequest(RequestType, ContestId, StageId, SplitId, CustomConfig);
@ -154,12 +150,8 @@ FGuid UDTFluxNetworkSubsystem::SendTrackedRequest(
// Récupérer la requête pour l'envoyer
if (const FDTFluxTrackedRequest* Request = RequestManager->GetRequestPtr(RequestId))
{
// Si la requête est déjà en cache, pas besoin d'envoyer
if (Request->State != EDTFluxRequestState::Cached)
{
RequestManager->MarkRequestAsSent(RequestId);
SendQueuedRequest(*Request);
}
RequestManager->MarkRequestAsSent(RequestId);
SendQueuedRequest(*Request);
}
}
@ -174,8 +166,8 @@ FGuid UDTFluxNetworkSubsystem::SendTrackedRequestWithCallbacks(
FOnDTFluxRequestSuccess& OnSuccess,
FOnDTFluxRequestError& OnError,
float TimeoutSeconds,
int32 MaxRetries,
bool bEnableCache)
int32 MaxRetries
)
{
if (!RequestManager.IsValid())
{
@ -186,8 +178,6 @@ FGuid UDTFluxNetworkSubsystem::SendTrackedRequestWithCallbacks(
FDTFluxRequestConfig CustomConfig;
CustomConfig.TimeoutSeconds = TimeoutSeconds;
CustomConfig.MaxRetries = MaxRetries;
CustomConfig.bEnableCache = bEnableCache;
CustomConfig.CacheValiditySeconds = 60.0f;
CustomConfig.RetryBackoffMultiplier = 1.5f;
FGuid RequestId = RequestManager->CreateTrackedRequestWithCallbacks(
@ -197,11 +187,8 @@ FGuid UDTFluxNetworkSubsystem::SendTrackedRequestWithCallbacks(
{
if (const FDTFluxTrackedRequest* Request = RequestManager->GetRequestPtr(RequestId))
{
if (Request->State != EDTFluxRequestState::Cached)
{
RequestManager->MarkRequestAsSent(RequestId);
SendQueuedRequest(*Request);
}
RequestManager->MarkRequestAsSent(RequestId);
SendQueuedRequest(*Request);
}
}
@ -227,7 +214,6 @@ bool UDTFluxNetworkSubsystem::HasRequestReceivedResponse(const FGuid& RequestId)
if (GetTrackedRequest(RequestId, Request))
{
return Request.State == EDTFluxRequestState::Completed ||
Request.State == EDTFluxRequestState::Cached ||
!Request.RawResponseData.IsEmpty();
}
return false;
@ -264,22 +250,19 @@ int32 UDTFluxNetworkSubsystem::GetPendingRequestCount() const
return 0;
}
void UDTFluxNetworkSubsystem::GetRequestStatistics(int32& OutPending, int32& OutCached, int32& OutCompleted,
int32& OutFailed, float& OutHitRate) const
void UDTFluxNetworkSubsystem::GetRequestStatistics(int32& OutPending, int32& OutCompleted,
int32& OutFailed) const
{
if (RequestManager.IsValid())
{
FDTFluxQueuedRequestManager::FRequestStatistics Stats = RequestManager->GetStatistics();
OutPending = Stats.Pending;
OutCached = Stats.Cached;
OutCompleted = Stats.Completed;
OutFailed = Stats.Failed;
OutHitRate = Stats.HitRate;
}
else
{
OutPending = OutCached = OutCompleted = OutFailed = 0;
OutHitRate = 0.0f;
OutPending = OutCompleted = OutFailed = 0;
}
}
@ -362,7 +345,7 @@ void UDTFluxNetworkSubsystem::RegisterWebSocketEvents()
&UDTFluxNetworkSubsystem::OnWebSocketMessageSentEvent_Subsystem);
}
void UDTFluxNetworkSubsystem::UnregisterWebSocketEvents()
void UDTFluxNetworkSubsystem::UnregisterWebSocketEvents() const
{
if (!WsClient.IsValid()) return;
@ -794,11 +777,10 @@ void UDTFluxNetworkSubsystem::SendQueuedRequest(const FDTFluxTrackedRequest& Que
bool UDTFluxNetworkSubsystem::ShouldUseAsyncParsing(const FString& JsonData) const
{
// Critères pour décider du parsing asynchrone :
// Critère pour décider du parsing asynchrone :
// - Taille des données (> 1KB par défaut)
// - Charge actuelle du système
// - Type de données (certains types sont plus complexes à parser)
// Pour le moment uniquement taille
const int32 AsyncThreshold = 1024; // 1KB
constexpr int32 AsyncThreshold = 1024; // 1KB
return JsonData.Len() > AsyncThreshold;
}