bool GenerateProjectFiles(const FString& ProjectFileName)
{
IDesktopPlatform* DesktopPlatform = FDesktopPlatformModule::Get();
// Check it's a code project
FString SourceDir = FPaths::GetPath(ProjectFileName) / TEXT("Source");
if(!IPlatformFile::GetPlatformPhysical().DirectoryExists(*SourceDir))
{
FPlatformMisc::MessageBoxExt(EAppMsgType::Ok, TEXT("This project does not have any source code. You need to add C++ source files to the project from the Editor before you can generate project files."), TEXT("Error"));
return false;
}
// Get the engine root directory
FString RootDir;
if (!GetValidatedEngineRootDir(ProjectFileName, RootDir))
{
return false;
}
// Build the argument list
FString Arguments = TEXT("-game");
if (FDesktopPlatformModule::Get()->IsSourceDistribution(RootDir))
{
Arguments += TEXT(" -engine");
}
// Start capturing the log output
FStringOutputDevice LogCapture;
LogCapture.SetAutoEmitLineTerminator(true);
GLog->AddOutputDevice(&LogCapture);
// Generate project files
FFeedbackContext* Warn = DesktopPlatform->GetNativeFeedbackContext();
bool bResult = DesktopPlatform->GenerateProjectFiles(RootDir, ProjectFileName, Warn);
GLog->RemoveOutputDevice(&LogCapture);
// Display an error dialog if we failed
if(!bResult)
{
FPlatformInstallation::ErrorDialog(TEXT("Failed to generate project files."), LogCapture);
return false;
}
return true;
}
//
// If analysis/clang compilation gives an error, we still can provide some meaningful data to user,
// which is why we return 0 in such cases. We return error only when -OutputFile is not provided and
// when saving output file fails.
//
int main(int32 ArgC, const char* ArgV[])
{
FString CmdLine = CreateCommandLine(ArgC, ArgV);
FString ShortCmdLine = FCommandLine::RemoveExeName(*CmdLine);
ShortCmdLine = ShortCmdLine.Trim();
GEngineLoop.PreInit(*ShortCmdLine);
if (!FParse::Value(*CmdLine, TEXT("-OutputFile="), OutputFileName))
{
return 1;
}
OutputFileContents.SetAutoEmitLineTerminator(true);
if (FParse::Param(*CmdLine, TEXT("AnalyzePCHFile")))
{
AnalyzePCHFile(CmdLine);
}
if (FParse::Param(*CmdLine, TEXT("CreateIncludeFiles")))
{
CreateIncludeFiles(ArgC, ArgV);
}
if (FParse::Param(*CmdLine, TEXT("CheckThreadSafety")))
{
CheckThreadSafety(ArgC, ArgV);
}
if (!FFileHelper::SaveStringToFile(OutputFileContents, *OutputFileName))
{
return 2;
}
return 0;
}
bool ANUTActor::NotifyControlMessage(UNetConnection* Connection, uint8 MessageType, FInBunch& Bunch)
{
bool bHandledMessage = false;
if (MessageType == NMT_NUTControl)
{
uint8 CmdType = 0;
FString Command;
FNetControlMessage<NMT_NUTControl>::Receive(Bunch, CmdType, Command);
// Console command
if (CmdType == ENUTControlCommand::Command_NoResult || CmdType == ENUTControlCommand::Command_SendResult)
{
UE_LOG(LogUnitTest, Log, TEXT("NMT_NUTControl: Executing command: %s"), *Command);
FStringOutputDevice CmdResult;
CmdResult.SetAutoEmitLineTerminator(true);
bool bCmdSuccess = false;
bCmdSuccess = GEngine->Exec(GetWorld(), *Command, CmdResult);
UE_LOG(LogUnitTest, Log, TEXT("NMT_NUTControl: Command result: %s"), *CmdResult);
bool bSendResult = CmdType == ENUTControlCommand::Command_SendResult;
if (bSendResult)
{
uint8 ReturnCmdType = (bCmdSuccess ? ENUTControlCommand::CommandResult_Success :
ENUTControlCommand::CommandResult_Failed);
FNetControlMessage<NMT_NUTControl>::Send(Connection, ReturnCmdType, CmdResult);
}
}
// Console command result
else if (CmdType == ENUTControlCommand::CommandResult_Failed || CmdType == ENUTControlCommand::CommandResult_Success)
{
bool bCmdSuccess = CmdType == ENUTControlCommand::CommandResult_Success;
if (bCmdSuccess)
{
UE_LOG(LogUnitTest, Log, TEXT("NMT_NUTControl: Got command result:"));
UE_LOG(LogUnitTest, Log, TEXT("%s"), *Command);
}
else
{
UE_LOG(LogUnitTest, Log, TEXT("NMT_NUTControl: Failed to execute command"));
}
}
// Ping request
else if (CmdType == ENUTControlCommand::Ping)
{
uint8 TempCmdType = ENUTControlCommand::Pong;
FString Dud;
FNetControlMessage<NMT_NUTControl>::Send(Connection, TempCmdType, Dud);
}
// Pong reply - this should only be implemented by custom unit tests; hence the assert
else if (CmdType == ENUTControlCommand::Pong)
{
UNIT_ASSERT(false);
}
// Custom implemented events, with the result triggered through 'NotifyEvent'
else if (CmdType == ENUTControlCommand::WatchEvent)
{
// NOTE: Only the last NetConnection to request a WatchEvent, will receive notifications
EventWatcher = Connection;
// Watch for the end of seamless travel
if (Command == TEXT("SeamlessTravelEnd"))
{
FCoreUObjectDelegates::PostLoadMap.AddStatic(&ANUTActor::NotifyPostLoadMap);
}
}
// Event watch notification - should only be implemented by custom unit tests
else if (CmdType == ENUTControlCommand::NotifyEvent)
{
UNIT_ASSERT(false);
}
// Create an actor instance (the 'summon' console command, doesn't work without a cheat manager)
else if (CmdType == ENUTControlCommand::Summon)
{
const TCHAR* Cmd = *Command;
FString SpawnClassName = FParse::Token(Cmd, false);
bool bForceBeginPlay = FParse::Param(Cmd, TEXT("ForceBeginPlay"));
// Hack specifically for getting the GameplayDebugger working - think the mainline code is broken
bool bGameplayDebuggerHack = FParse::Param(Cmd, TEXT("GameplayDebuggerHack"));
UClass* SpawnClass = FindObject<UClass>(NULL, *SpawnClassName);
if (SpawnClass != NULL)
{
FActorSpawnParameters SpawnParms;
SpawnParms.Owner = GetOwner();
AActor* NewActor = GetWorld()->SpawnActor<AActor>(SpawnClass, SpawnParms);
if (NewActor != NULL)
{
UE_LOG(LogUnitTest, Log, TEXT("Successfully summoned actor of class '%s'"), *SpawnClassName);
if (bForceBeginPlay && !NewActor->HasActorBegunPlay())
{
UE_LOG(LogUnitTest, Log, TEXT("Forcing call to 'BeginPlay' on newly spawned actor."));
NewActor->BeginPlay();
}
if (bGameplayDebuggerHack)
{
// Assign the LocalPlayerOwner property, to the PC owning this NUTActor, using reflection (to avoid dependency)
UObjectProperty* LocalPlayerOwnerProp =
FindField<UObjectProperty>(NewActor->GetClass(), TEXT("LocalPlayerOwner"));
if (LocalPlayerOwnerProp != NULL)
{
LocalPlayerOwnerProp->SetObjectPropertyValue(
LocalPlayerOwnerProp->ContainerPtrToValuePtr<UObject*>(NewActor), GetOwner());
}
else
{
UE_LOG(LogUnitTest, Log, TEXT("WARNING: Failed to find 'LocalPlayerOwner' property. Unit test broken."));
}
// Also hack-disable ticking, so that the replicator doesn't spawn a second replicator
NewActor->SetActorTickEnabled(false);
}
}
else
{
UE_LOG(LogUnitTest, Log, TEXT("SpawnActor failed for class '%s'"), *Command);
}
}
else
{
UE_LOG(LogUnitTest, Log, TEXT("Could not find actor class '%s'"), *Command);
}
}
// Suspend the game, until a resume request is received (used for giving time, to attach a debugger)
else if (CmdType == ENUTControlCommand::SuspendProcess)
{
UE_LOG(LogUnitTest, Log, TEXT("Suspend start."));
// Setup a named pipe, to monitor for the resume request
FString ResumePipeName = FString::Printf(TEXT("%s%u"), NUT_SUSPEND_PIPE, FPlatformProcess::GetCurrentProcessId());
FPlatformNamedPipe ResumePipe;
bool bPipeCreated = ResumePipe.Create(ResumePipeName, true, false);
if (bPipeCreated)
{
if (!ResumePipe.OpenConnection())
{
UE_LOG(LogUnitTest, Log, TEXT("WARNING: Failed to open pipe connection."));
}
}
else
{
UE_LOG(LogUnitTest, Log, TEXT("WARNING: Failed to create resume pipe."));
}
// Spin/sleep (effectively suspended) until a resume request is received
while (true)
{
if (bPipeCreated && ResumePipe.IsReadyForRW())
{
int32 ResumeVal = 0;
if (ResumePipe.ReadInt32(ResumeVal) && !!ResumeVal)
{
UE_LOG(LogUnitTest, Log, TEXT("Got resume request."));
break;
}
}
FPlatformProcess::Sleep(1.0f);
}
ResumePipe.Destroy();
UE_LOG(LogUnitTest, Log, TEXT("Suspend end."));
}
bHandledMessage = true;
}
return bHandledMessage;
}
bool FPerfCounters::ProcessRequest(uint8* Buffer, int32 BufferLen, FResponse& Response)
{
bool bSuccess = false;
// scan the buffer for a line
FUTF8ToTCHAR WideBuffer(reinterpret_cast<const ANSICHAR*>(Buffer));
const TCHAR* BufferEnd = FCString::Strstr(WideBuffer.Get(), TEXT("\r\n"));
if (BufferEnd != nullptr)
{
// crack into pieces
FString MainLine(BufferEnd - WideBuffer.Get(), WideBuffer.Get());
TArray<FString> Tokens;
MainLine.ParseIntoArrayWS(Tokens);
if (Tokens.Num() >= 2)
{
FString ContentType(TEXT("application/json"));
Response.Code = 200;
// handle the request
if (Tokens[0] != TEXT("GET"))
{
Response.Body = FString::Printf(TEXT("{ \"error\": \"Method %s not allowed\" }"), *Tokens[0]);
Response.Code = 405;
}
else if (Tokens[1].StartsWith(TEXT("/stats")))
{
Response.Body = GetAllCountersAsJson();
}
else if (Tokens[1].StartsWith(TEXT("/exec?c=")))
{
FString ExecCmd = Tokens[1].Mid(8);
FString ExecCmdDecoded = FPlatformHttp::UrlDecode(ExecCmd);
FStringOutputDevice StringOutDevice;
StringOutDevice.SetAutoEmitLineTerminator(true);
bool bResult = false;
if (ExecCmdCallback.IsBound())
{
bResult = ExecCmdCallback.Execute(ExecCmdDecoded, StringOutDevice);
Response.Body = StringOutDevice;
ContentType = TEXT("text/text");
}
else
{
Response.Body = FString::Printf(TEXT("{ \"error\": \"exec handler not found\" }"));
}
Response.Code = bResult ? 200 : 404;
}
else
{
Response.Body = FString::Printf(TEXT("{ \"error\": \"%s not found\" }"), *Tokens[1]);
Response.Code = 404;
}
// send the response headers
Response.Header = FString::Printf(TEXT("HTTP/1.0 %d\r\nContent-Length: %d\r\nContent-Type: %s\r\n\r\n"), Response.Code, Response.Body.Len(), *ContentType);
bSuccess = true;
}
else
{
UE_LOG(LogPerfCounters, Warning, TEXT("Unable to parse HTTP request header: %s"), *MainLine);
}
}
else
{
UE_LOG(LogPerfCounters, Warning, TEXT("Unable to immediately receive full request header"));
}
return bSuccess;
}
