void UPhilipsHueBridge::HandleLightStateRequestComplete(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded)
{
FString MessageBody = "";
if (!HttpResponse.IsValid())
{
MessageBody = "{\"success\":\"Error: Unable to process HTTP Request!\"}";
}
else if (EHttpResponseCodes::IsOk(HttpResponse->GetResponseCode()))
{
MessageBody = HttpResponse->GetContentAsString();
int32 idx = MessageBody.Find("error");
if (idx > 0){
//Send Error;
}
else
{
//Successfully sent!
}
}
else
{
MessageBody = FString::Printf(TEXT("{\"success\":\"HTTP Error: %d\"}"), HttpResponse->GetResponseCode());
}
}
/**
* This is a callback function that is called when the "AttemptAuthentication" function
* has completed its request.
*
* @param Request
* @param Response Contains the data of the response, including the response code.
* @param bWasSuccessful Contains true if the request was successful. Else it contains false.
*
*/
void CloudyWebAPIImpl::OnAuthResponseComplete(FHttpRequestPtr Request,
FHttpResponsePtr Response, bool bWasSuccessful)
{
if (bWasSuccessful)
{
UE_LOG(CloudyWebAPILog, Warning, TEXT("Response Code = %d"), Response->GetResponseCode());
if (!Response.IsValid())
{
UE_LOG(CloudyWebAPILog, Warning, TEXT("Request failed!"));
}
else if (EHttpResponseCodes::IsOk(Response->GetResponseCode()))
{
TSharedPtr<FJsonObject> JsonObject = MakeShareable(new FJsonObject());
TSharedRef<TJsonReader<TCHAR>> JsonReader = TJsonReaderFactory<TCHAR>::Create(Response->GetContentAsString());
FJsonSerializer::Deserialize(JsonReader, JsonObject);
Token = JsonObject->GetStringField("token");
UE_LOG(CloudyWebAPILog, Warning, TEXT("Token = %s"), *Token);
}
}
else
{
UE_LOG(CloudyWebAPILog, Error, TEXT("Request failed! Is the server up?"));
}
}
void FSimplygonRESTClient::DownloadAsset_Response(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
{
if (!Response.IsValid())
{
SwarmTask->SetState(SRS_FAILED);
}
else if (EHttpResponseCodes::IsOk(Response->GetResponseCode()))
{
TArray<uint8> data = Response->GetContent();
if (!FFileHelper::SaveArrayToFile(data, *SwarmTask->OutputFilename))
{
UE_LOG(LogSimplygonRESTClient, Log, TEXT("Unable to save file %S"), *SwarmTask->OutputFilename);
SwarmTask->SetState(SRS_FAILED);
}
else
{
SwarmTask->OnAssetDownloaded().ExecuteIfBound(*SwarmTask);
SwarmTask->SetState(SRS_ASSETDOWNLOADED);
UE_LOG(LogSimplygonRESTClient, Log, TEXT("Asset downloaded"));
}
}
else
{
SwarmTask->SetState(SRS_FAILED);
UE_LOG(LogSimplygonRESTClient, Warning, TEXT("Response: %i"), Response->GetResponseCode());
}
}
void FHttpNetworkReplayStreamer::HttpDownloadHeaderFinished( FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded )
{
check( HttpState == EHttptate::DownloadingHeader );
check( StreamerState == EStreamerState::NeedToDownloadHeader );
check( StreamArchive.IsLoading() );
HttpState = EHttptate::Idle;
if ( bSucceeded && HttpResponse->GetResponseCode() == EHttpResponseCodes::Ok )
{
HeaderArchive.Buffer.Append( HttpResponse->GetContent() );
UE_LOG( LogHttpReplay, Log, TEXT( "FHttpNetworkReplayStreamer::HttpDownloadHeaderFinished. Size: %i" ), HeaderArchive.Buffer.Num() );
StartStreamingDelegate.ExecuteIfBound( true, StreamArchive.IsSaving() );
StreamerState = EStreamerState::StreamingDown;
}
else
{
// FAIL
UE_LOG( LogHttpReplay, Error, TEXT( "FHttpNetworkReplayStreamer::HttpDownloadHeaderFinished. FAILED." ) );
StreamArchive.Buffer.Empty();
StartStreamingDelegate.ExecuteIfBound( false, StreamArchive.IsSaving() );
SetLastError( ENetworkReplayError::ServiceUnavailable );
}
// Reset delegate
StartStreamingDelegate = FOnStreamReadyDelegate();
}
bool FHttpRetrySystem::FManager::ShouldRetry(const FHttpRetryRequestEntry& HttpRetryRequestEntry)
{
bool bResult = false;
FHttpResponsePtr Response = HttpRetryRequestEntry.Request->GetResponse();
// invalid response means connection or network error but we need to know which one
if (!Response.IsValid())
{
// ONLY retry bad responses if they are connection errors (NOT protocol errors or unknown) otherwise request may be sent (and processed!) twice
EHttpRequestStatus::Type Status = HttpRetryRequestEntry.Request->GetStatus();
if (Status == EHttpRequestStatus::Failed_ConnectionError)
{
bResult = true;
}
else if (Status == EHttpRequestStatus::Failed)
{
// we will also allow retry for GET and HEAD requests even if they may duplicate on the server
FString Verb = HttpRetryRequestEntry.Request->GetVerb();
if (Verb == TEXT("GET") || Verb == TEXT("HEAD"))
{
bResult = true;
}
}
}
else
{
// this may be a successful response with one of the explicitly listed response codes we want to retry on
if (HttpRetryRequestEntry.Request->RetryResponseCodes.Contains(Response->GetResponseCode()))
{
bResult = true;
}
}
return bResult;
}
void UPhilipsHueBridge::HandleUserIDTestRequestComplete(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded)
{
FString MessageBody = "";
// If HTTP fails client-side, this will still be called but with a NULL shared pointer!
if (!HttpResponse.IsValid())
{
MessageBody = "{\"success\":\"Error: Unable to process HTTP Request!\"}";
}
else if (EHttpResponseCodes::IsOk(HttpResponse->GetResponseCode()))
{
MessageBody = HttpResponse->GetContentAsString();
int32 idx = MessageBody.Find("unauthorized user");
if (idx > 0){
//Remind push linking
OnPushLinkRequested.Broadcast(Id);
//AquireUserID(false);
}
else
{
Connected = true;
// Successfully tested the user id
OnHueUserAuthorized.Broadcast(ConnectedUser);
}
}
else
{
MessageBody = FString::Printf(TEXT("{\"success\":\"HTTP Error: %d\"}"), HttpResponse->GetResponseCode());
}
}
void UHeliosGetterProxy_Float::OnHeliosRequestComplete(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded) {
if (!bSucceeded) {
UE_LOG(LogTemp, Error, TEXT("Helios > request failed: %s"), *HttpRequest->GetURL());
OnFail.Broadcast(0);
return;
}
if (!HttpResponse.IsValid()) {
UE_LOG(LogTemp, Warning, TEXT("Helios > invalid response for request: %s"), *HttpRequest->GetURL());
OnFail.Broadcast(0);
return;
}
FString ContentAsString = HttpResponse->GetContentAsString();
json Content = json::parse(TCHAR_TO_UTF8(*ContentAsString));
if (Content.size() != 1) {
UE_LOG(LogTemp, Warning, TEXT("Helios > invalid json returned"));
OnFail.Broadcast(0);
return;
}
if (!Content["value"].is_number_float()) {
UE_LOG(LogTemp, Warning, TEXT("Helios > invalid type returned"));
OnFail.Broadcast(0);
return;
}
float Result = Content["value"];
OnSuccess.Broadcast(Result);
}
void FSimplygonRESTClient::UploadAsset_Response(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
{
if (!Response.IsValid())
{
SwarmTask->SetState(SRS_FAILED);
}
else if (EHttpResponseCodes::IsOk(Response->GetResponseCode()))
{
FString msg = Response->GetContentAsString();
UE_LOG(LogSimplygonRESTClient, Log, TEXT("Upload asset response: %s"), *msg);
TSharedPtr<FJsonObject> JsonParsed;
TSharedRef<TJsonReader<TCHAR>> JsonReader = TJsonReaderFactory<TCHAR>::Create(msg);
if (FJsonSerializer::Deserialize(JsonReader, JsonParsed))
{
SwarmTask->InputAssetId = JsonParsed->GetStringField("AssetId");
UE_LOG(LogSimplygonRESTClient, Log, TEXT("AssetId: %s"), *SwarmTask->InputAssetId);
}
SwarmTask->SetState(SRS_ASSETUPLOADED);
}
else
{
SwarmTask->SetState(SRS_FAILED);
UE_LOG(LogSimplygonRESTClient, Warning, TEXT("Response: %i"), Response->GetResponseCode());
}
}
void FHttpServiceTracker::EndpointMetrics::TrackRequest(const FHttpRequestPtr& HttpRequest)
{
// keep a histogram of response codes
const FHttpResponsePtr HttpResponse = HttpRequest->GetResponse();
const int32 ResponseCode = HttpResponse.IsValid() ? HttpResponse->GetResponseCode() : 0;
// track all responses in a histogram
ResponseCodes.FindOrAdd(ResponseCode)++;
const float ElapsedTime = HttpRequest->GetElapsedTime();
const int64 DownloadBytes = HttpRequest->GetResponse()->GetContent().Num();
// track successes/fails separately
if (IsSuccessfulResponse(ResponseCode))
{
++SuccessCount;
// sum elapsed time for average calc
ElapsedTimeSuccessTotal += ElapsedTime;
ElapsedTimeSuccessMax = FMath::Max(ElapsedTimeSuccessMax, ElapsedTime);
ElapsedTimeSuccessMin = FMath::Min(ElapsedTimeSuccessMin, ElapsedTime);
// sum download rate for average calc
DownloadBytesSuccessTotal += DownloadBytes;
}
else
{
++FailCount;
// sum elapsed time for average calc
ElapsedTimeFailTotal += ElapsedTime;
ElapsedTimeFailMax = FMath::Max(ElapsedTimeFailMax, ElapsedTime);
ElapsedTimeFailMin = FMath::Min(ElapsedTimeFailMin, ElapsedTime);
// sum download rate for average calc
DownloadBytesFailTotal += DownloadBytes;
}
}
void UPhilipsHueBridge::HandleUserIDRequestComplete(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded)
{
FString MessageBody = "";
FString userid = "";
// If HTTP fails client-side, this will still be called but with a NULL shared pointer!
if (!HttpResponse.IsValid())
{
MessageBody = "{\"success\":\"Error: Unable to process HTTP Request!\"}";
}
else if (EHttpResponseCodes::IsOk(HttpResponse->GetResponseCode()))
{
MessageBody = HttpResponse->GetContentAsString();
TSharedRef< TJsonReader<> > JsonReader = TJsonReaderFactory<>::Create(*MessageBody);
int32 idx = MessageBody.Find("\"username\"");
if (idx > 0){
userid = MessageBody.Trim();
userid.RemoveFromStart("[{\"success\":{\"username\":\"");
userid.RemoveFromEnd("\"}}]");
ConnectedUser = userid;
SaveUserIDToFile();
OnHueUserAuthorized.Broadcast(userid);
}
else
{
OnPushLinkRequested.Broadcast(Id);
}
}
else
{
MessageBody = FString::Printf(TEXT("{\"success\":\"HTTP Error: %d\"}"), HttpResponse->GetResponseCode());
}
}
static PyObject *py_ue_ihttp_request_get_response(ue_PyIHttpRequest *self, PyObject * args)
{
FHttpResponsePtr response = self->http_request->GetResponse();
if (!response.IsValid())
{
return PyErr_Format(PyExc_Exception, "unable to retrieve IHttpResponse");
}
return py_ue_new_ihttp_response(response.Get());
}
bool FHttpRetrySystem::FManager::ShouldRetry(const FHttpRetryRequestEntry& HttpRetryRequestEntry)
{
bool bResult = false;
FHttpResponsePtr Response = HttpRetryRequestEntry.HttpRequest->GetResponse();
if (!Response.IsValid() || Response->GetResponseCode() == 0)
{
bResult = true;
}
return bResult;
}
bool PlayFabRequestHandler::DecodeRequest(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded, PlayFab::FPlayFabBaseModel& OutResult, PlayFab::FPlayFabError& OutError)
{
PlayFabRequestHandler::pendingCalls -= 1;
FString ResponseStr, ErrorStr;
if (bSucceeded && HttpResponse.IsValid())
{
if (EHttpResponseCodes::IsOk(HttpResponse->GetResponseCode()))
{
// Create the Json parser
ResponseStr = HttpResponse->GetContentAsString();
TSharedPtr<FJsonObject> JsonObject;
TSharedRef<TJsonReader<> > JsonReader = TJsonReaderFactory<>::Create(ResponseStr);
if (FJsonSerializer::Deserialize(JsonReader, JsonObject) && JsonObject.IsValid())
{
if (PlayFabRequestHandler::DecodeError(JsonObject, OutError))
{
return false;
}
const TSharedPtr<FJsonObject>* DataJsonObject;
if (JsonObject->TryGetObjectField(TEXT("data"), DataJsonObject))
{
return OutResult.readFromValue(*DataJsonObject);
}
}
}
else
{
// Create the Json parser
ResponseStr = HttpResponse->GetContentAsString();
TSharedPtr<FJsonObject> JsonObject;
TSharedRef<TJsonReader<> > JsonReader = TJsonReaderFactory<>::Create(ResponseStr);
if (FJsonSerializer::Deserialize(JsonReader, JsonObject) && JsonObject.IsValid())
{
if (PlayFabRequestHandler::DecodeError(JsonObject, OutError))
{
return false;
}
}
}
}
// If we get here, we failed to connect meaningfully to the server - Assume a timeout
OutError.HttpCode = 408;
OutError.ErrorCode = PlayFabErrorConnectionTimeout;
// For text returns, use the non-json response if possible, else default to no response
OutError.ErrorName = OutError.ErrorMessage = OutError.HttpStatus = TEXT("Request Timeout or null response");
return false;
}
void FHttpNetworkReplayStreamer::HttpStartDownloadingFinished( FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded )
{
check( HttpState == EHttptate::StartDownloading );
check( StreamerState == EStreamerState::NeedToDownloadHeader );
HttpState = EHttptate::Idle;
if ( bSucceeded && HttpResponse->GetResponseCode() == EHttpResponseCodes::Ok )
{
FString NumChunksString = HttpResponse->GetHeader( TEXT( "NumChunks" ) );
FString DemoTimeString = HttpResponse->GetHeader( TEXT( "Time" ) );
FString State = HttpResponse->GetHeader( TEXT( "State" ) );
ViewerName = HttpResponse->GetHeader( TEXT( "Viewer" ) );
bStreamIsLive = State == TEXT( "Live" );
NumDownloadChunks = FCString::Atoi( *NumChunksString );
DemoTimeInMS = FCString::Atoi( *DemoTimeString );
UE_LOG( LogHttpReplay, Log, TEXT( "FHttpNetworkReplayStreamer::HttpStartDownloadingFinished. Viewer: %s, State: %s, NumChunks: %i, DemoTime: %2.2f" ), *ViewerName, *State, NumDownloadChunks, (float)DemoTimeInMS / 1000 );
// First, download the header
if ( NumDownloadChunks > 0 )
{
StreamerState = EStreamerState::NeedToDownloadHeader;
}
else
{
UE_LOG( LogHttpReplay, Warning, TEXT( "FHttpNetworkReplayStreamer::HttpStartDownloadingFinished. NO CHUNKS" ) );
StartStreamingDelegate.ExecuteIfBound( false, StreamArchive.IsSaving() );
// Reset delegate
StartStreamingDelegate = FOnStreamReadyDelegate();
SetLastError( ENetworkReplayError::ServiceUnavailable );
}
}
else
{
UE_LOG( LogHttpReplay, Error, TEXT( "FHttpNetworkReplayStreamer::HttpStartDownloadingFinished. FAILED" ) );
StartStreamingDelegate.ExecuteIfBound( false, StreamArchive.IsSaving() );
// Reset delegate
StartStreamingDelegate = FOnStreamReadyDelegate();
SetLastError( ENetworkReplayError::ServiceUnavailable );
}
}
bool FHttpRetrySystem::FManager::ShouldRetry(const FHttpRetryRequestEntry& HttpRetryRequestEntry)
{
bool bResult = false;
FHttpResponsePtr Response = HttpRetryRequestEntry.HttpRequest->GetResponse();
if (!Response.IsValid() ||
Response->GetResponseCode() == 0 ||
HttpRetryRequestEntry.HttpRequest->RetryResponseCodesOverride.Contains(Response->GetResponseCode()) ||
RetryResponseCodesDefault.Contains(Response->GetResponseCode()))
{
bResult = true;
}
return bResult;
}
void UBPDownloader::HandleHeaderReceived(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded)
{
if (bSucceeded && HttpResponse.IsValid())
{
FString FileLength = HttpResponse->GetHeader(L"Content-Length");// ();
FileTotalBytes = (float)UKismetStringLibrary::Conv_StringToInt(FileLength);
//Start Downloading
StartDownload();
}
else
{
RemoveFromRoot();
OnFail.Broadcast(0.f);//FilePath
}
}
void FHttpNetworkReplayStreamer::HttpStopUploadingFinished( FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded )
{
check( HttpState == EHttptate::StopUploading );
check( StreamerState == EStreamerState::StreamingUpFinal );
HttpState = EHttptate::Idle;
StreamerState = EStreamerState::Idle;
if ( bSucceeded && HttpResponse->GetResponseCode() == EHttpResponseCodes::Ok )
{
UE_LOG( LogHttpReplay, Log, TEXT( "FHttpNetworkReplayStreamer::HttpStopUploadingFinished. SessionName: %s" ), *SessionName );
}
else
{
UE_LOG( LogHttpReplay, Error, TEXT( "FHttpNetworkReplayStreamer::HttpStopUploadingFinished. FAILED" ) );
SetLastError( ENetworkReplayError::ServiceUnavailable );
}
StreamArchive.ArIsLoading = false;
StreamArchive.ArIsSaving = false;
StreamArchive.Buffer.Empty();
StreamArchive.Pos = 0;
StreamFileCount = 0;
bStopStreamingCalled = false;
SessionName.Empty();
}
void FSimplygonRESTClient::ProcessJob_Response(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
{
if (!Response.IsValid())
{
SwarmTask->SetState(SRS_FAILED);
}
else if (EHttpResponseCodes::IsOk(Response->GetResponseCode()))
{
SwarmTask->SetState(SRS_JOBPROCESSING);
}
else
{
SwarmTask->SetState(SRS_FAILED);
UE_LOG(LogSimplygonRESTClient, Warning, TEXT("Process job response: %i"), Response->GetResponseCode());
}
}
void FHttpNetworkReplayStreamer::HttpUploadFinished( FHttpRequestPtr , FHttpResponsePtr HttpResponse, bool bSucceeded )
{
check( HttpState == EHttptate::UploadingStream );
check( StreamerState == EStreamerState::StreamingUp || StreamerState == EStreamerState::StreamingUpFinal );
HttpState = EHttptate::Idle;
if ( bSucceeded && HttpResponse->GetResponseCode() == EHttpResponseCodes::Ok )
{
UE_LOG( LogHttpReplay, Verbose, TEXT( "FHttpNetworkReplayStreamer::HttpUploadFinished." ) );
if ( StreamerState == EStreamerState::StreamingUpFinal )
{
// Create the Http request and add to pending request list
TSharedRef<class IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
HttpRequest->OnProcessRequestComplete().BindRaw( this, &FHttpNetworkReplayStreamer::HttpStopUploadingFinished );
HttpState = EHttptate::StopUploading;
HttpRequest->SetURL( FString::Printf( TEXT( "%sstopuploading?Version=%s&Session=%s&NumChunks=%i&Time=%i" ), *ServerURL, *SessionVersion, *SessionName, StreamFileCount, DemoTimeInMS ) );
HttpRequest->SetVerb( TEXT( "POST" ) );
HttpRequest->SetHeader( TEXT( "Content-Type" ), TEXT( "application/octet-stream" ) );
HttpRequest->ProcessRequest();
}
}
else
{
UE_LOG( LogHttpReplay, Error, TEXT( "FHttpNetworkReplayStreamer::HttpUploadFinished. FAILED" ) );
SetLastError( ENetworkReplayError::ServiceUnavailable );
}
}
int HttpRpcRequest::ParseRequestIdFromResponse(FHttpResponsePtr response) {
FString requestIdString = response->GetHeader("X-Request-ID");
if (requestIdString == "") {
return -1;
}
return FCString::Atoi(*requestIdString);
}
void FSimplygonRESTClient::AccountInfo_Response(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
{
if (!Response.IsValid())
{
SwarmTask->SetState(SRS_FAILED);
}
else if (EHttpResponseCodes::IsOk(Response->GetResponseCode()))
{
FString msg = Response->GetContentAsString();
UE_LOG(LogSimplygonRESTClient, Log, TEXT("Account info response: %s"), *msg);
}
else
{
SwarmTask->SetState(SRS_FAILED);
UE_LOG(LogSimplygonRESTClient, Warning, TEXT("Account info response: %i"), Response->GetResponseCode());
}
}
void FSimplygonRESTClient::UploadJobSettings_Response(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
{
if (!Response.IsValid())
{
SwarmTask->SetState(SRS_FAILED);
}
else if (EHttpResponseCodes::IsOk(Response->GetResponseCode()))
{
SwarmTask->SetState(SRS_JOBSETTINGSUPLOADED);
SwarmTask->OnAssetUploaded().ExecuteIfBound(*SwarmTask);
}
else
{
SwarmTask->SetState(SRS_FAILED);
UE_LOG(LogSimplygonRESTClient, Warning, TEXT("Upload job settings response: %i"), Response->GetResponseCode());
}
}
bool HttpRpcRequest::ParseMessageFromResponse(FHttpResponsePtr response) {
const FString contentType = response->GetContentType();
if (contentType.StartsWith(kContentTypeJson)) {
} else if (contentType.StartsWith(kContentTypeASCII)) {
if (!google::protobuf::TextFormat::ParseFromString(TCHAR_TO_UTF8(*response->GetContentAsString()), callState_.GetResponse())) {
UE_LOG(HttpRpcRequestLog, Error, TEXT("ASCII response parse failed"));
return false;
}
return true;
} else if (contentType.StartsWith(kContentTypeBinary)) {
} else {
UE_LOG(HttpRpcRequestLog, Error, TEXT("Invalid content type '%s'"), *contentType);
}
return false;
}
bool FCrashUpload::ParseServerResponse(FHttpResponsePtr Response)
{
// Turn the snippet into a complete XML document, to keep the XML parser happy
FXmlFile ParsedResponse(FString(TEXT("<Root>")) + Response->GetContentAsString() + TEXT("</Root>"), EConstructMethod::ConstructFromBuffer);
UE_LOG(CrashReportClientLog, Log, TEXT("Response->GetContentAsString(): '%s'"), *Response->GetContentAsString());
if (!ParsedResponse.IsValid())
{
UE_LOG(CrashReportClientLog, Log, TEXT("Invalid response!"));
return false;
}
if (auto ResultNode = ParsedResponse.GetRootNode()->FindChildNode(TEXT("CrashReporterResult")))
{
UE_LOG(CrashReportClientLog, Log, TEXT("ResultNode->GetAttribute(TEXT(\"bSuccess\")) = %s"), *ResultNode->GetAttribute(TEXT("bSuccess")));
return ResultNode->GetAttribute(TEXT("bSuccess")) == TEXT("true");
}
UE_LOG(CrashReportClientLog, Log, TEXT("Could not find CrashReporterResult"));
return false;
}
void FHttpServiceTracker::EndpointMetrics::TrackRequest(const FHttpRequestPtr& HttpRequest)
{
if(HttpRequest.IsValid())
{
// keep a histogram of response codes
const FHttpResponsePtr HttpResponse = HttpRequest->GetResponse();
const int32 ResponseCode = HttpResponse.IsValid() ? HttpResponse->GetResponseCode() : 0;
// track all responses in a histogram
ResponseCodes.FindOrAdd(ResponseCode)++;
const float ElapsedTime = HttpRequest->GetElapsedTime();
const int64 DownloadBytes = HttpResponse.IsValid() ? HttpResponse->GetContent().Num() : 0;
// track successes/fails separately
if (IsSuccessfulResponse(ResponseCode))
{
++SuccessCount;
// sum elapsed time for average calc
ElapsedTimeSuccessTotal += ElapsedTime;
ElapsedTimeSuccessMax = FMath::Max(ElapsedTimeSuccessMax, ElapsedTime);
ElapsedTimeSuccessMin = FMath::Min(ElapsedTimeSuccessMin, ElapsedTime);
// sum download rate for average calc
DownloadBytesSuccessTotal += DownloadBytes;
}
else
{
++FailCount;
// sum elapsed time for average calc
ElapsedTimeFailTotal += ElapsedTime;
ElapsedTimeFailMax = FMath::Max(ElapsedTimeFailMax, ElapsedTime);
ElapsedTimeFailMin = FMath::Min(ElapsedTimeFailMin, ElapsedTime);
// sum download rate for average calc
DownloadBytesFailTotal += DownloadBytes;
}
FString AnalyticsName = GetAnalyticsName(HttpRequest->GetURL());
if (LastAnalyticsName.Len() > 0 && AnalyticsName != LastAnalyticsName)
{
UE_LOG(LogAnalytics, Warning, TEXT("Endpoint analytics name has changed from '%s' to '%s', aggregated stats will be incorrect"),
*LastAnalyticsName, *AnalyticsName);
}
LastAnalyticsName = AnalyticsName;
}
}
void AVictoryPC::HTTPOnResponseReceived(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
{
FString ResponseStr = "AVictoryPC::HTTPOnResponseReceived>>> Connection Error";
if(bWasSuccessful)
{
ResponseStr = Response->GetContentAsString();
}
this->VictoryPC_GetMyIP_DataReceived(ResponseStr);
}
void FHttpNetworkReplayStreamer::HttpStartUploadingFinished( FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded )
{
check( HttpState == EHttptate::StartUploading );
check( StreamerState == EStreamerState::NeedToUploadHeader );
HttpState = EHttptate::Idle;
if ( bSucceeded && HttpResponse->GetResponseCode() == EHttpResponseCodes::Ok )
{
SessionName = HttpResponse->GetHeader( TEXT( "Session" ) );
UE_LOG( LogHttpReplay, Log, TEXT( "FHttpNetworkReplayStreamer::HttpStartUploadingFinished. SessionName: %s" ), *SessionName );
}
else
{
UE_LOG( LogHttpReplay, Error, TEXT( "FHttpNetworkReplayStreamer::HttpStartUploadingFinished. FAILED" ) );
SetLastError( ENetworkReplayError::ServiceUnavailable );
}
}
void FAnalyticsProviderET::EventRequestComplete(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded)
{
if (bSucceeded && HttpResponse.IsValid())
{
UE_LOG(LogAnalytics, VeryVerbose, TEXT("[%s] ET response for [%s]. Code: %d. Payload: %s"), *APIKey, *HttpRequest->GetURL(), HttpResponse->GetResponseCode(), *HttpResponse->GetContentAsString());
}
else
{
UE_LOG(LogAnalytics, VeryVerbose, TEXT("[%s] ET response for [%s]. No response"), *APIKey, *HttpRequest->GetURL());
}
}
void UMasterServerFunctions::OnResponseReceived(FHttpRequestPtr Request, FHttpResponsePtr Response, bool bWasSuccessful)
{
FString MessageBody = "";
if (!Response.IsValid()) { CurrentRequest.ResponseType = EHttpResponse::HR_NoData; Closed(MessageBody); return; }
if (EHttpResponseCodes::IsOk(Response->GetResponseCode()))
{
if (Response->GetContentType().Equals("application/json"))
{
MessageBody = DecompressBytes(Response->GetContent());
ProcessJSON(MessageBody);
}
}
else
{
MessageBody = FString::Printf(TEXT("{\"success\":\"HTTP Error: %d\"}"), Response->GetResponseCode());
}
Closed(MessageBody);
}
void HttpRpcRequest::onHttpRequestCompleted(FHttpRequestPtr request, FHttpResponsePtr response, bool bWasSuccessful) {
if (!bWasSuccessful) {
UE_LOG(HttpRpcRequestLog, Error, TEXT("HTTP request failed"));
callState_.GetController()->SetFailed("HTTP request failed");
} else {
const int responseCode = response->GetResponseCode();
if (responseCode != 200) {
if ((responseCode >= 300) && (responseCode < 400)) {
// TODO(san): Handle redirects.
callState_.GetController()->SetFailed("Unsupported redirect");
} else {
UE_LOG(HttpRpcRequestLog, Error, TEXT("HTTP response code %d (%s)"), response->GetResponseCode(), *response->GetContentAsString());
callState_.GetController()->SetFailed("Bad HTTP response code");
}
} else {
// Successful HTTP response.
int requestId = ParseRequestIdFromResponse(response);
if (requestId == -1) {
UE_LOG(HttpRpcRequestLog, Error, TEXT("HTTP response missing request id"));
callState_.GetController()->SetFailed("Response missing request id");
// TODO(san): Think about whether we should be strict about this given we have the request handy.
} else if (requestId != FCString::Atoi(*request->GetHeader("X-Request-ID"))) {
// If this happens legitimately then we are most likely inheriting a 'threading issue' from the
// HTTP module - in which case we'll probably need to track outstanding requests ourselves.
UE_LOG(HttpRpcRequestLog, Error, TEXT("Mismatched Request/Response!"));
callState_.GetController()->SetFailed("Mismatched Request/Response ID");
} else {
// Request ID is valid. Extract the protobuf from the HTTP content buffer.
if (!ParseMessageFromResponse(response)) {
UE_LOG(HttpRpcRequestLog, Warning, TEXT("Failed to parse response protobuf"));
callState_.GetController()->SetFailed("Failed to parse response protobuf");
}
}
}
}
Closure* cachedClosure = callState_.GetDone();
delete this;
cachedClosure->Run();
}
