HTTP

HTTP

#Overview

name: HTTP

This variable is created as a Console Variable (cvar).

It is referenced in 28 C++ source files.

#Summary

#Usage in the C++ source code

The purpose of the HTTP variable in Unreal Engine 5 is to configure and manage HTTP-related settings and functionality. Here are the key points about this variable:

  1. The HTTP variable is primarily used in the HTTP module of Unreal Engine, which handles network communications using the HTTP protocol.

  2. It is referenced in various subsystems and plugins, including ElectraPlayer, NetcodeUnitTest, CrashReportClient, and IoStoreOnDemand.

  3. The value of this variable is typically set in the engine configuration files, particularly in GEngineIni (Engine.ini).

  4. It interacts with several other variables and settings, such as HttpTimeout, HttpTotalTimeout, HttpConnectionTimeout, etc.

  5. Developers should be aware that this variable affects various aspects of HTTP communication, including timeouts, connection limits, and enabled/disabled states.

  6. Best practices when using this variable include:

    • Carefully configuring timeout values to balance between responsiveness and allowing sufficient time for operations to complete.
    • Considering the impact on performance and resource usage when adjusting settings like HttpMaxConnectionsPerServer.
    • Regularly reviewing and updating these settings based on the specific needs of your project.

  7. Special considerations:

    • The HTTP variable can significantly impact network performance and behavior of your application.
    • Changes to these settings may require testing across different network conditions to ensure optimal performance.
    • Some settings, like HttpNoProxy, can affect how your application interacts with network infrastructure.

  8. The HTTP module initializes these settings during startup and can reload them during runtime, allowing for dynamic configuration adjustments.

  9. The HTTP variable and its related settings are crucial for features like content streaming, online services, and crash reporting in Unreal Engine projects.

#References in C++ code

#Callsites

This variable is referenced in the following C++ source code:

#Loc: <Workspace>/Engine/Plugins/Media/ElectraPlayer/Source/ElectraPlayerRuntime/Private/Runtime/Player/DASH/StreamReaderDASH.cpp:1098

Scope (from outer to inner):

file
namespace    Electra
function     void FStreamReaderDASH::FStreamHandler::HandleRequestMP4

Source code excerpt:

			ProgressListener->ProgressDelegate   = IElectraHttpManager::FProgressListener::FProgressDelegate::CreateRaw(this, &FStreamHandler::HTTPProgressCallback);
			ProgressListener->CompletionDelegate = IElectraHttpManager::FProgressListener::FCompletionDelegate::CreateRaw(this, &FStreamHandler::HTTPCompletionCallback);
			TSharedPtrTS<IElectraHttpManager::FRequest> HTTP(new IElectraHttpManager::FRequest);
			HTTP->Parameters.URL = RequestURL;
			HTTP->Parameters.StreamType = Request->StreamType;
			HTTP->Parameters.QualityIndex = Request->QualityIndex;
			HTTP->Parameters.MaxQualityIndex = Request->MaxQualityIndex;
			HTTP->ReceiveBuffer = ReadBuffer.ReceiveBuffer;
			HTTP->ProgressListener = ProgressListener;
			HTTP->ResponseCache = PlayerSessionService->GetHTTPResponseCache();
			HTTP->ExternalDataReader = PlayerSessionService->GetExternalDataReader();
			HTTP->Parameters.Range.Set(Request->Segment.MediaURL.Range);
			HTTP->Parameters.AcceptEncoding.Set(TEXT("identity"));
			if (Request->Segment.MediaURL.CustomHeader.Len())
			{
				HTTP->Parameters.RequestHeaders.Emplace(HTTP::FHTTPHeader({DASH::HTTPHeaderOptionName, Request->Segment.MediaURL.CustomHeader}));
			}
			HTTP->Parameters.bCollectTimingTraces = Request->Segment.bLowLatencyChunkedEncodingExpected;
			// Set timeouts for media segment retrieval
			HTTP->Parameters.ConnectTimeout = PlayerSessionService->GetOptionValue(DASH::OptionKeyMediaSegmentConnectTimeout).SafeGetTimeValue(FTimeValue().SetFromMilliseconds(1000 * 4));
			HTTP->Parameters.NoDataTimeout = PlayerSessionService->GetOptionValue(DASH::OptionKeyMediaSegmentNoDataTimeout).SafeGetTimeValue(FTimeValue().SetFromMilliseconds(1000 * 4));

			ProgressReportCount = 0;
			DownloadCompleteSignal.Reset();
			PlayerSessionService->GetHTTPManager()->AddRequest(HTTP, false);

			MP4Parser = IParserISO14496_12::CreateParser();
			NumMOOFBoxesFound = 0;

			int64 LastSuccessfulFilePos = 0;
			uint32 TrackTimescale = 0;

#Loc: <Workspace>/Engine/Plugins/Media/ElectraPlayer/Source/ElectraPlayerRuntime/Private/Runtime/Player/DASH/StreamReaderDASH.cpp:1552

Scope (from outer to inner):

file
namespace    Electra
function     void FStreamReaderDASH::FStreamHandler::HandleRequestMP4

Source code excerpt:

			ProgressListener.Reset();
			// Note: It is only safe to access the connection info when the HTTP request has completed or the request been removed.
			PlayerSessionService->GetHTTPManager()->RemoveRequest(HTTP, false);
			CurrentRequest->ConnectionInfo = HTTP->ConnectionInfo;
			HTTP.Reset();
		}
	}
	else
	{
		// Init segment error.
		if (!HasReadBeenAborted())

#Loc: <Workspace>/Engine/Plugins/Media/ElectraPlayer/Source/ElectraPlayerRuntime/Private/Runtime/Player/DASH/StreamReaderDASH.cpp:1940

Scope (from outer to inner):

file
namespace    Electra
function     void FStreamReaderDASH::FStreamHandler::HandleRequestMKV

Source code excerpt:

			ProgressListener->ProgressDelegate = IElectraHttpManager::FProgressListener::FProgressDelegate::CreateRaw(this, &FStreamHandler::HTTPProgressCallback);
			ProgressListener->CompletionDelegate = IElectraHttpManager::FProgressListener::FCompletionDelegate::CreateRaw(this, &FStreamHandler::HTTPCompletionCallback);
			TSharedPtrTS<IElectraHttpManager::FRequest> HTTP(new IElectraHttpManager::FRequest);
			HTTP->Parameters.URL = RequestURL;
			HTTP->Parameters.StreamType = Request->StreamType;
			HTTP->Parameters.QualityIndex = Request->QualityIndex;
			HTTP->Parameters.MaxQualityIndex = Request->MaxQualityIndex;
			HTTP->ReceiveBuffer = ReadBuffer.ReceiveBuffer;
			HTTP->ProgressListener = ProgressListener;
			HTTP->ResponseCache = PlayerSessionService->GetHTTPResponseCache();
			HTTP->ExternalDataReader = PlayerSessionService->GetExternalDataReader();
			HTTP->Parameters.Range.Set(Request->Segment.MediaURL.Range);
			HTTP->Parameters.AcceptEncoding.Set(TEXT("identity"));
			if (Request->Segment.MediaURL.CustomHeader.Len())
			{
				HTTP->Parameters.RequestHeaders.Emplace(HTTP::FHTTPHeader({DASH::HTTPHeaderOptionName, Request->Segment.MediaURL.CustomHeader}));
			}
			HTTP->Parameters.bCollectTimingTraces = Request->Segment.bLowLatencyChunkedEncodingExpected;
			// Set timeouts for media segment retrieval
			HTTP->Parameters.ConnectTimeout = PlayerSessionService->GetOptionValue(DASH::OptionKeyMediaSegmentConnectTimeout).SafeGetTimeValue(FTimeValue().SetFromMilliseconds(1000 * 4));
			HTTP->Parameters.NoDataTimeout = PlayerSessionService->GetOptionValue(DASH::OptionKeyMediaSegmentNoDataTimeout).SafeGetTimeValue(FTimeValue().SetFromMilliseconds(1000 * 4));

			ProgressReportCount = 0;
			DownloadCompleteSignal.Reset();
			PlayerSessionService->GetHTTPManager()->AddRequest(HTTP, false);

			bool bDone = false;

			// Encrypted?
			TSharedPtr<ElectraCDM::IMediaCDMDecrypter, ESPMode::ThreadSafe> Decrypter;
			if (Request->DrmClient.IsValid())

#Loc: <Workspace>/Engine/Plugins/Media/ElectraPlayer/Source/ElectraPlayerRuntime/Private/Runtime/Player/DASH/StreamReaderDASH.cpp:2188

Scope (from outer to inner):

file
namespace    Electra
function     void FStreamReaderDASH::FStreamHandler::HandleRequestMKV

Source code excerpt:

			ProgressListener.Reset();
			// Note: It is only safe to access the connection info when the HTTP request has completed or the request been removed.
			PlayerSessionService->GetHTTPManager()->RemoveRequest(HTTP, false);
			CurrentRequest->ConnectionInfo = HTTP->ConnectionInfo;
			HTTP.Reset();
		}
	}
	else
	{
		// Init segment error.
		if (!HasReadBeenAborted())

#Loc: <Workspace>/Engine/Plugins/Media/ElectraPlayer/Source/ElectraPlayerRuntime/Private/Runtime/Player/HLS/StreamReaderHLSfmp4.cpp:401

Scope (from outer to inner):

file
namespace    Electra
function     FStreamReaderHLSfmp4::FStreamHandler::ELicenseKeyResult FStreamReaderHLSfmp4::FStreamHandler::GetLicenseKey

Source code excerpt:

		else
		{
			TSharedPtrTS<IElectraHttpManager::FRequest> HTTP(new IElectraHttpManager::FRequest);
			ReadBuffer.Reset();
			ReadBuffer.ReceiveBuffer = MakeSharedTS<IElectraHttpManager::FReceiveBuffer>();

			Metrics::FSegmentDownloadStats& ds = InRequest->DownloadStats;
			ds.URL = LicenseKeyInfo->URI;

			HTTP->Parameters.URL   = LicenseKeyInfo->URI;
			HTTP->ReceiveBuffer    = ReadBuffer.ReceiveBuffer;

			ProgressReportCount = 0;
			DownloadCompleteSignal.Reset();

			// Is there a static resource provider that we can try?
			bool bHaveStaticResponse = false;

#Loc: <Workspace>/Engine/Plugins/Media/ElectraPlayer/Source/ElectraPlayerRuntime/Private/Runtime/Player/HLS/StreamReaderHLSfmp4.cpp:445

Scope (from outer to inner):

file
namespace    Electra
function     FStreamReaderHLSfmp4::FStreamHandler::ELicenseKeyResult FStreamReaderHLSfmp4::FStreamHandler::GetLicenseKey

Source code excerpt:

				ProgressListener->ProgressDelegate   = IElectraHttpManager::FProgressListener::FProgressDelegate::CreateRaw(this, &FStreamHandler::HTTPProgressCallback);
				ProgressListener->CompletionDelegate = IElectraHttpManager::FProgressListener::FCompletionDelegate::CreateRaw(this, &FStreamHandler::HTTPCompletionCallback);
				HTTP->ProgressListener = ProgressListener;
				HTTP->ExternalDataReader = PlayerSessionService->GetExternalDataReader();
				PlayerSessionService->GetHTTPManager()->AddRequest(HTTP, false);
				while(!HasReadBeenAborted())
				{
					if (DownloadCompleteSignal.WaitTimeout(1000 * 100))
					{
						break;
					}

#Loc: <Workspace>/Engine/Plugins/Media/ElectraPlayer/Source/ElectraPlayerRuntime/Private/Runtime/Player/HLS/StreamReaderHLSfmp4.cpp:457

Scope (from outer to inner):

file
namespace    Electra
function     FStreamReaderHLSfmp4::FStreamHandler::ELicenseKeyResult FStreamReaderHLSfmp4::FStreamHandler::GetLicenseKey

Source code excerpt:

				ProgressListener.Reset();
				// Note: It is only safe to access the connection info when the HTTP request has completed or the request been removed.
				PlayerSessionService->GetHTTPManager()->RemoveRequest(HTTP, false);
			}

			InRequest->ConnectionInfo = HTTP->ConnectionInfo;
			if (!HTTP->ConnectionInfo.StatusInfo.ErrorDetail.IsError())
			{
				// Notify license key download ok.
				PlayerSessionService->SendMessageToPlayer(FLicenseKeyMessage::Create(FLicenseKeyMessage::EReason::LicenseKeyDownload, FErrorDetail(), &HTTP->ConnectionInfo));

				// There is not much we can validate here. The key is the direct key data without any wrapping.
				if (ReadBuffer.ReceiveBuffer->Buffer.Num() == 16)
				{
					LicenseKeyData = MakeShared<TArray<uint8>, ESPMode::ThreadSafe>();
					LicenseKeyData->AddUninitialized(ReadBuffer.ReceiveBuffer->Buffer.Num());

#Loc: <Workspace>/Engine/Plugins/Media/ElectraPlayer/Source/ElectraPlayerRuntime/Private/Runtime/Player/HLS/StreamReaderHLSfmp4.cpp:484

Scope (from outer to inner):

file
function     FStreamReaderHLSfmp4::FStreamHandler::ELicenseKeyResult FStreamReaderHLSfmp4::FStreamHandler::GetLicenseKey

Source code excerpt:

					PlayerSessionService->SendMessageToPlayer(FLicenseKeyMessage::Create(FLicenseKeyMessage::EReason::LicenseKeyData,
																						 FErrorDetail().SetError(UEMEDIA_ERROR_FORMAT_ERROR).SetFacility(Facility::EFacility::LicenseKey).SetCode((uint16)FStreamReaderHLSfmp4::FStreamHandler::ELicenseKeyResult::FormatError).SetMessage("Invalid license key length"),
																						 &HTTP->ConnectionInfo));
					return FStreamReaderHLSfmp4::FStreamHandler::ELicenseKeyResult::FormatError;
				}
			}
			else
			{
				// Notify license key download failure.
				PlayerSessionService->SendMessageToPlayer(FLicenseKeyMessage::Create(FLicenseKeyMessage::EReason::LicenseKeyDownload,
																					 FErrorDetail().SetError(UEMEDIA_ERROR_READ_ERROR).SetFacility(Facility::EFacility::LicenseKey).SetCode((uint16)FStreamReaderHLSfmp4::FStreamHandler::ELicenseKeyResult::DownloadError).SetMessage("License key download failure"),
																					 &HTTP->ConnectionInfo));
				return FStreamReaderHLSfmp4::FStreamHandler::ELicenseKeyResult::DownloadError;
			}
		}
	}
	return FStreamReaderHLSfmp4::FStreamHandler::ELicenseKeyResult::DownloadError;
}

#Loc: <Workspace>/Engine/Plugins/Media/ElectraPlayer/Source/ElectraPlayerRuntime/Private/Runtime/Player/HLS/StreamReaderHLSfmp4.cpp:526

Scope (from outer to inner):

file
namespace    Electra
function     FStreamReaderHLSfmp4::FStreamHandler::EInitSegmentResult FStreamReaderHLSfmp4::FStreamHandler::GetInitSegment

Source code excerpt:

			}

			TSharedPtrTS<IElectraHttpManager::FRequest> HTTP(new IElectraHttpManager::FRequest);
			TSharedPtrTS<IElectraHttpManager::FProgressListener> ProgressListener(new IElectraHttpManager::FProgressListener);
			ProgressListener->ProgressDelegate = IElectraHttpManager::FProgressListener::FProgressDelegate::CreateRaw(this, &FStreamHandler::HTTPProgressCallback);
			ProgressListener->CompletionDelegate = IElectraHttpManager::FProgressListener::FCompletionDelegate::CreateRaw(this, &FStreamHandler::HTTPCompletionCallback);
			ReadBuffer.Reset();
			ReadBuffer.ReceiveBuffer = MakeSharedTS<IElectraHttpManager::FReceiveBuffer>();

#Loc: <Workspace>/Engine/Plugins/Media/ElectraPlayer/Source/ElectraPlayerRuntime/Private/Runtime/Player/HLS/StreamReaderHLSfmp4.cpp:539

Scope (from outer to inner):

file
namespace    Electra
function     FStreamReaderHLSfmp4::FStreamHandler::EInitSegmentResult FStreamReaderHLSfmp4::FStreamHandler::GetInitSegment

Source code excerpt:

			ds.SegmentType = Metrics::ESegmentType::Init;

			HTTP->Parameters.URL = RequestURL;
			HTTP->Parameters.StreamType = Request->StreamType;
			HTTP->Parameters.QualityIndex = Request->QualityIndex;
			HTTP->Parameters.MaxQualityIndex = Request->MaxQualityIndex;
			HTTP->ReceiveBuffer = ReadBuffer.ReceiveBuffer;
			HTTP->ProgressListener = ProgressListener;
			if (Request->InitSegmentInfo->ByteRange.IsSet())
			{
				HTTP->Parameters.Range.Start = Request->InitSegmentInfo->ByteRange.GetStart();
				HTTP->Parameters.Range.EndIncluding = Request->InitSegmentInfo->ByteRange.GetEnd();
			}
			// Set timeouts for init segment retrieval
			HTTP->Parameters.ConnectTimeout = FTimeValue().SetFromMilliseconds(1000 * 4);
			HTTP->Parameters.NoDataTimeout = FTimeValue().SetFromMilliseconds(1000 * 2);
			HTTP->ResponseCache = PlayerSessionService->GetHTTPResponseCache();
			HTTP->ExternalDataReader = PlayerSessionService->GetExternalDataReader();

			ProgressReportCount = 0;
			DownloadCompleteSignal.Reset();
			PlayerSessionService->GetHTTPManager()->AddRequest(HTTP, false);

			while(!HasReadBeenAborted())
			{
				if (DownloadCompleteSignal.WaitTimeout(1000 * 100))
				{
					break;

#Loc: <Workspace>/Engine/Plugins/Media/ElectraPlayer/Source/ElectraPlayerRuntime/Private/Runtime/Player/HLS/StreamReaderHLSfmp4.cpp:570

Scope (from outer to inner):

file
namespace    Electra
function     FStreamReaderHLSfmp4::FStreamHandler::EInitSegmentResult FStreamReaderHLSfmp4::FStreamHandler::GetInitSegment

Source code excerpt:

			ProgressListener.Reset();
			// Note: It is only safe to access the connection info when the HTTP request has completed or the request been removed.
			PlayerSessionService->GetHTTPManager()->RemoveRequest(HTTP, false);
			Request->ConnectionInfo = HTTP->ConnectionInfo;

			SCOPE_CYCLE_COUNTER(STAT_ElectraPlayer_HLS_StreamReader);
			CSV_SCOPED_TIMING_STAT(ElectraPlayer, HLS_StreamReader);
			if (!HTTP->ConnectionInfo.StatusInfo.ErrorDetail.IsError())
			{
// TODO: If encrypted we must now decrypt it!!
//		 The question is how to do this if there is no explicit IV and the media sequence number is to be used
//		 with the init segment being static and not having one.
//		 Presently the assumption is that the init segment is not encrypted.

#Loc: <Workspace>/Engine/Plugins/Media/ElectraPlayer/Source/ElectraPlayerRuntime/Private/Runtime/Player/HLS/StreamReaderHLSfmp4.cpp:832

Scope (from outer to inner):

file
namespace    Electra
function     void FStreamReaderHLSfmp4::FStreamHandler::HandleRequest

Source code excerpt:

				ProgressListener->ProgressDelegate = IElectraHttpManager::FProgressListener::FProgressDelegate::CreateRaw(this, &FStreamHandler::HTTPProgressCallback);
				ProgressListener->CompletionDelegate = IElectraHttpManager::FProgressListener::FCompletionDelegate::CreateRaw(this, &FStreamHandler::HTTPCompletionCallback);
				TSharedPtrTS<IElectraHttpManager::FRequest> HTTP(new IElectraHttpManager::FRequest);
				HTTP->Parameters.URL = RequestURL;
				HTTP->Parameters.StreamType = Request->StreamType;
				HTTP->Parameters.QualityIndex = Request->QualityIndex;
				HTTP->Parameters.MaxQualityIndex = Request->MaxQualityIndex;
				HTTP->ReceiveBuffer = ReadBuffer.ReceiveBuffer;
				HTTP->ProgressListener = ProgressListener;
				if (Request->Range.IsSet())
				{
					HTTP->Parameters.Range = Request->Range;
				}
				HTTP->ResponseCache = PlayerSessionService->GetHTTPResponseCache();
				// Set timeouts for media segment retrieval
				HTTP->Parameters.ConnectTimeout = FTimeValue().SetFromMilliseconds(1000 * 4);
				HTTP->Parameters.NoDataTimeout = FTimeValue().SetFromMilliseconds(1000 * 2);
				HTTP->ExternalDataReader = PlayerSessionService->GetExternalDataReader();

				ProgressReportCount = 0;
				DownloadCompleteSignal.Reset();
				PlayerSessionService->GetHTTPManager()->AddRequest(HTTP, false);

				MP4Parser = IParserISO14496_12::CreateParser();
				NumMOOFBoxesFound = 0;

				FTimeValue	BaseMediaDecodeTime;
				FTimeValue	TimeMappingOffset;

#Loc: <Workspace>/Engine/Plugins/Media/ElectraPlayer/Source/ElectraPlayerRuntime/Private/Runtime/Player/HLS/StreamReaderHLSfmp4.cpp:1100

Scope (from outer to inner):

file
namespace    Electra
function     void FStreamReaderHLSfmp4::FStreamHandler::HandleRequest

Source code excerpt:

				ProgressListener.Reset();
				// Note: It is only safe to access the connection info when the HTTP request has completed or the request been removed.
				PlayerSessionService->GetHTTPManager()->RemoveRequest(HTTP, false);
				CurrentRequest->ConnectionInfo = HTTP->ConnectionInfo;
				HTTP.Reset();
			}
		}
		else
		{
			if (!HasReadBeenAborted())
			{

#Loc: <Workspace>/Engine/Plugins/Media/ElectraPlayer/Source/ElectraPlayerRuntime/Private/Runtime/Player/mp4/StreamReaderMP4.cpp:362

Scope (from outer to inner):

file
namespace    Electra
function     void FStreamReaderMP4::HandleRequest

Source code excerpt:

	ReadBuffer.SetCurrentPos(Request->FileStartOffset);

	TSharedPtrTS<IElectraHttpManager::FRequest> HTTP(new IElectraHttpManager::FRequest);
	HTTP->Parameters.URL				= TimelineAsset->GetMediaURL();
	HTTP->Parameters.Range.Start		= Request->FileStartOffset;
	HTTP->Parameters.Range.EndIncluding = Request->FileEndOffset;
	// No compression as this would not yield much with already compressed video/audio data.
	HTTP->Parameters.AcceptEncoding.Set(TEXT("identity"));
	// Timeouts
	HTTP->Parameters.ConnectTimeout = PlayerSessionServices->GetOptionValue(MP4::OptionKeyMP4LoadConnectTimeout).SafeGetTimeValue(FTimeValue().SetFromMilliseconds(1000 * 8));
	HTTP->Parameters.NoDataTimeout = PlayerSessionServices->GetOptionValue(MP4::OptionKeyMP4LoadNoDataTimeout).SafeGetTimeValue(FTimeValue().SetFromMilliseconds(1000 * 6));

	// Explicit range?
	int64 NumRequestedBytes = HTTP->Parameters.Range.GetNumberOfBytes();

	HTTP->ReceiveBuffer = ReadBuffer.ReceiveBuffer;
	HTTP->ProgressListener = ProgressListener;
	HTTP->ResponseCache = PlayerSessionServices->GetHTTPResponseCache();
	HTTP->ExternalDataReader = PlayerSessionServices->GetExternalDataReader();
	PlayerSessionServices->GetHTTPManager()->AddRequest(HTTP, false);


	FTimeValue DurationSuccessfullyDelivered(FTimeValue::GetZero());
	FTimeValue DurationSuccessfullyRead(FTimeValue::GetZero());
	bool bDone = false;
	TSharedPtrTS<IParserISO14496_12::IAllTrackIterator> AllTrackIterator;

#Loc: <Workspace>/Engine/Plugins/Media/ElectraPlayer/Source/ElectraPlayerRuntime/Private/Runtime/Player/mp4/StreamReaderMP4.cpp:670

Scope (from outer to inner):

file
namespace    Electra
function     void FStreamReaderMP4::HandleRequest

Source code excerpt:

	// Remove the download request.
	ProgressListener.Reset();
	PlayerSessionServices->GetHTTPManager()->RemoveRequest(HTTP, false);
	Request->ConnectionInfo = HTTP->ConnectionInfo;
	HTTP.Reset();

	// Set downloaded and delivered duration from the primary track.
	FSelectedTrackData& PrimaryTrack = ActiveTrackMap.FindOrAdd(PrimaryTrackID);
	DurationSuccessfullyRead	  = PrimaryTrack.DurationSuccessfullyRead;
	DurationSuccessfullyDelivered = PrimaryTrack.DurationSuccessfullyDelivered;

#Loc: <Workspace>/Engine/Plugins/NetcodeUnitTest/NetcodeUnitTest/Source/NetcodeUnitTest/Private/UnitTestCommandlet.cpp:77

Scope (from outer to inner):

file
function     int32 UUnitTestCommandlet::Main

Source code excerpt:

	}

	FModuleManager::Get().LoadModule(TEXT("HTTP"));
	FModuleManager::Get().LoadModule(TEXT("OnlineSubsystem"));
	FModuleManager::Get().LoadModule(TEXT("OnlineSubsystemUtils"));

	if (!IsEngineExitRequested())
	{
		GIsRunning = true;

#Loc: <Workspace>/Engine/Source/Programs/CrashReportClient/Private/CrashReportClientApp.cpp:1079

Scope (from outer to inner):

file
function     void RunCrashReportClient

Source code excerpt:


	// Increase the HttpSendTimeout to 5 minutes
	GConfig->SetFloat(TEXT("HTTP"), TEXT("HttpSendTimeout"), 5 * 60.0f, GEngineIni);

	// Make sure all UObject classes are registered and default properties have been initialized
	ProcessNewlyLoadedUObjects();

	// Tell the module manager is may now process newly-loaded UObjects when new C++ modules are loaded
	FModuleManager::Get().StartProcessingNewlyLoadedObjects();

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/IoStoreOnDemand/Private/OnDemandHttpClient.cpp:125

Scope (from outer to inner):

file
namespace    UE::IO::IAS
function     void FHttpClient::IssueRequest

Source code excerpt:

void FHttpClient::IssueRequest(FRequestParams&& Params)
{
	using namespace UE::IO::IAS::HTTP;

	//TODO: Remove string conversion
	const auto Url = StringCast<ANSICHAR>(*Params.Url, Params.Url.Len());

	auto Sink = [
		this,

#Loc: <Workspace>/Engine/Source/Runtime/Online/HTTP/Private/HttpManager.cpp:143

Scope (from outer to inner):

file
function     void FHttpManager::ReloadFlushTimeLimits

Source code excerpt:

		{
		case EHttpFlushReason::Default:
			GConfig->GetDouble(TEXT("HTTP"), TEXT("FlushSoftTimeLimitDefault"), SoftLimitSeconds, GEngineIni);
			GConfig->GetDouble(TEXT("HTTP"), TEXT("FlushHardTimeLimitDefault"), HardLimitSeconds, GEngineIni);
			break;
		case EHttpFlushReason::Shutdown:
			GConfig->GetDouble(TEXT("HTTP"), TEXT("FlushSoftTimeLimitShutdown"), SoftLimitSeconds, GEngineIni);
			GConfig->GetDouble(TEXT("HTTP"), TEXT("FlushHardTimeLimitShutdown"), HardLimitSeconds, GEngineIni);
			
			if ((HardLimitSeconds >= 0) && ((SoftLimitSeconds < 0) || (SoftLimitSeconds >= HardLimitSeconds)))
			{
				UE_CLOG(!IsRunningCommandlet(), LogHttp, Warning, TEXT("Soft limit[%.02f] is higher than the hard limit set[%.02f] in file [%s]. Please change the soft limit to a value lower than the hard limit for Flush to work correctly. - 1 is unlimited and therefore the highest possible value."), static_cast<float>(SoftLimitSeconds), static_cast<float>(HardLimitSeconds), *GEngineIni);
				// we need to be absolutely sure that SoftLimitSeconds is always strictly less than HardLimitSeconds so remaining requests (if any) can be canceled before exiting
				if (HardLimitSeconds > 0.0)

#Loc: <Workspace>/Engine/Source/Runtime/Online/HTTP/Private/HttpManager.cpp:170

Scope (from outer to inner):

file
function     void FHttpManager::ReloadFlushTimeLimits

Source code excerpt:

			SoftLimitSeconds = -1.0;
			HardLimitSeconds = -1.0;
			GConfig->GetDouble(TEXT("HTTP"), TEXT("FlushSoftTimeLimitFullFlush"), SoftLimitSeconds, GEngineIni);
			GConfig->GetDouble(TEXT("HTTP"), TEXT("FlushHardTimeLimitFullFlush"), HardLimitSeconds, GEngineIni);
			break;
		}

		FHttpFlushTimeLimit TimeLimit(SoftLimitSeconds, HardLimitSeconds);

		FlushTimeLimitsMap.Add(Reason, TimeLimit);

#Loc: <Workspace>/Engine/Source/Runtime/Online/HTTP/Private/HttpManager.cpp:313

Scope (from outer to inner):

file
function     void FHttpManager::Flush

Source code excerpt:

	// The smaller the value, the more quickly we may find out that all requests have completed, but the more work may be done in the meantime.
	float SecondsToSleepForOutstandingThreadedRequests = 0.5f;
	GConfig->GetFloat(TEXT("HTTP"), TEXT("RequestCleanupDelaySec"), SecondsToSleepForOutstandingThreadedRequests, GEngineIni);

	UE_CLOG(!IsRunningCommandlet(), LogHttp, Verbose, TEXT("[FHttpManager::Flush] FlushReason [%s] FlushTimeSoftLimitSeconds [%.3fs] FlushTimeHardLimitSeconds [%.3fs] SecondsToSleepForOutstandingThreadedRequests [%.3fs]"), LexToString(FlushReason), FlushTimeSoftLimitSeconds, FlushTimeHardLimitSeconds, SecondsToSleepForOutstandingThreadedRequests);

	uint32 RequestsNum = 0;

	{

#Loc: <Workspace>/Engine/Source/Runtime/Online/HTTP/Private/HttpModule.cpp:33

Scope: file

Source code excerpt:

// FHttpModule

IMPLEMENT_MODULE(FHttpModule, HTTP);

FHttpModule* FHttpModule::Singleton = NULL;

static bool ShouldLaunchUrl(const TCHAR* Url)
{
	FString SchemeName;

#Loc: <Workspace>/Engine/Source/Runtime/Online/HTTP/Private/HttpModule.cpp:51

Scope (from outer to inner):

file
function     void FHttpModule::UpdateConfigs

Source code excerpt:

void FHttpModule::UpdateConfigs()
{
	GConfig->GetFloat(TEXT("HTTP"), TEXT("HttpTimeout"), HttpActivityTimeout, GEngineIni);
	GConfig->GetFloat(TEXT("HTTP"), TEXT("HttpTotalTimeout"), HttpTotalTimeout, GEngineIni);
	GConfig->GetFloat(TEXT("HTTP"), TEXT("HttpConnectionTimeout"), HttpConnectionTimeout, GEngineIni);
	GConfig->GetFloat(TEXT("HTTP"), TEXT("HttpActivityTimeout"), HttpActivityTimeout, GEngineIni);
	GConfig->GetFloat(TEXT("HTTP"), TEXT("HttpReceiveTimeout"), HttpReceiveTimeout, GEngineIni);
	GConfig->GetFloat(TEXT("HTTP"), TEXT("HttpSendTimeout"), HttpSendTimeout, GEngineIni);
	GConfig->GetInt(TEXT("HTTP"), TEXT("HttpMaxConnectionsPerServer"), HttpMaxConnectionsPerServer, GEngineIni);
	GConfig->GetBool(TEXT("HTTP"), TEXT("bEnableHttp"), bEnableHttp, GEngineIni);
	GConfig->GetBool(TEXT("HTTP"), TEXT("bUseNullHttp"), bUseNullHttp, GEngineIni);
	GConfig->GetFloat(TEXT("HTTP"), TEXT("HttpDelayTime"), HttpDelayTime, GEngineIni);
	GConfig->GetFloat(TEXT("HTTP"), TEXT("HttpThreadActiveFrameTimeInSeconds"), HttpThreadActiveFrameTimeInSeconds, GEngineIni);
	GConfig->GetFloat(TEXT("HTTP"), TEXT("HttpThreadActiveMinimumSleepTimeInSeconds"), HttpThreadActiveMinimumSleepTimeInSeconds, GEngineIni);
	GConfig->GetFloat(TEXT("HTTP"), TEXT("HttpThreadIdleFrameTimeInSeconds"), HttpThreadIdleFrameTimeInSeconds, GEngineIni);
	GConfig->GetFloat(TEXT("HTTP"), TEXT("HttpThreadIdleMinimumSleepTimeInSeconds"), HttpThreadIdleMinimumSleepTimeInSeconds, GEngineIni);
	GConfig->GetFloat(TEXT("HTTP"), TEXT("HttpEventLoopThreadTickIntervalInSeconds"), HttpEventLoopThreadTickIntervalInSeconds, GEngineIni);

	if (!FParse::Value(FCommandLine::Get(), TEXT("HttpNoProxy="), HttpNoProxy))
	{
		GConfig->GetString(TEXT("HTTP"), TEXT("HttpNoProxy"), HttpNoProxy, GEngineIni);
	}

	AllowedDomains.Empty();
	GConfig->GetArray(TEXT("HTTP"), TEXT("AllowedDomains"), AllowedDomains, GEngineIni);

	if (HttpManager != nullptr)
	{
		HttpManager->UpdateConfigs();
	}
}

#Loc: <Workspace>/Engine/Source/Runtime/Online/HTTP/Private/HttpModule.cpp:118

Scope (from outer to inner):

file
function     void FHttpModule::StartupModule

Source code excerpt:

	// Load from a configurable array of modules at this point, so things that need to bind to the SDK Manager init hooks can do so.
	TArray<FString> ModulesToLoad;
	GConfig->GetArray(TEXT("HTTP"), TEXT("ModulesToLoad"), ModulesToLoad, GEngineIni);
	for (const FString& ModuleToLoad : ModulesToLoad)
	{
		if (FModuleManager::Get().ModuleExists(*ModuleToLoad))
		{
			FModuleManager::Get().LoadModule(*ModuleToLoad);
		}

#Loc: <Workspace>/Engine/Source/Runtime/Online/HTTP/Private/HttpModule.cpp:278

Scope (from outer to inner):

file
function     bool FHttpModule::Exec_Runtime

Source code excerpt:

{
	// Ignore any execs that don't start with HTTP
	if (FParse::Command(&Cmd, TEXT("HTTP")))
	{
		return HandleHTTPCommand( Cmd, Ar );
	}
	return false;
}

#Loc: <Workspace>/Engine/Source/Runtime/Online/HTTP/Private/HttpRetrySystem.cpp:21

Scope: file

Source code excerpt:

);

LLM_DEFINE_TAG(HTTP);

namespace FHttpRetrySystem
{

TOptional<double> ReadThrottledTimeFromResponseInSeconds(FHttpResponsePtr Response)
{

#Loc: <Workspace>/Engine/Source/Runtime/Online/HTTP/Private/HttpRetrySystem.cpp:287

Scope (from outer to inner):

file
function     void FHttpRetrySystem::FRequest::HttpOnProcessRequestComplete

Source code excerpt:

	}

	LLM_SCOPE_BYTAG(HTTP);
	OnProcessRequestComplete().ExecuteIfBound(SelfPtr, ResultResponse, bResultSucceeded);

	ClearTimeout();
}

void FHttpRetrySystem::FRequest::HttpOnStatusCodeReceived(FHttpRequestPtr Request, int32 StatusCode)

#Loc: <Workspace>/Engine/Source/Runtime/Online/HTTP/Private/HttpRetrySystem.cpp:570

Scope (from outer to inner):

file
function     bool FHttpRetrySystem::FManager::Update

Source code excerpt:


	QUICK_SCOPE_CYCLE_COUNTER(STAT_FHttpRetrySystem_FManager_Update);
	LLM_SCOPE_BYTAG(HTTP);

	FScopeLock ScopeLock(&RequestListLock);

	bool bIsGreen = true;

	if (FileCount != nullptr)