You've already forked UnrealEngineUWP
mirror of
https://github.com/izzy2lost/UnrealEngineUWP.git
synced 2026-03-26 18:15:20 -07:00
479468c9ee
#rb Per.Larsson #jira UE-151641 #preflight 63ea068cde74ffbae5dc3a7f ### Problem - A lot of systems rely on the engine to know which project is being loaded on start up so that the correct config settings can be applied however so far the UVT has not required the user to provide the desired project. This is because in theory, the tool could be given a list of packages or a changelist to process that contain packages from more than one project and if that happens we need to handle it correctly. - The tool currently groups the provided packages by project, then runs the requested command on each project one at a time, initializing the VA system with that projects config files, then shutting it done once the project packages are processed. This allows us to pick up the correct settings for VA but other systems that we rely on, such as the DDC do not allow this sort of dynamic initialization and so may not have the correct settings. ### Solution - Before the projects packages are processed we check to see if the project applied to the process during initialization (if any) matches the project to be processed. If not we launch a new version of the tool with the correct project settings and have the child process perform the main processing. The output of each child process (or any projects we were able to run in process) are then provided to the command for a final "post projects" phase. - This means we can support multiple packages from multiple processes AND not require the user type out the project name when using the tool from the cmdline. - Although launching a child process only adds a few seconds of overhead (per project) any tool or process that make use of UVT should be updated to provide the project where possible. ### Changes ### FUnrealVirtualizationToolApp - As explained in the problem section, we now need to support launching a new instance of the tool as a child process. - We communicate with the child process by providing an input file via the cmdline, which is then parsed and used to recreate the original command and project settings. Once the command has run in the child process it will write its output to an output file which the calling process can then read back in. - So our new logic is to check the project that the tool was started with (in case the user provided a project path in the cmdline) against each project that we need to process. If the paths match then we can just process the project, if they do not match we launch a child process with the correct path and retrieve the output once done. -- If a child process detects an incorrect path we just error out to avoid endless recursive process launching. - Output from the child process is clearly logged to the user as coming from a child process to make debugging easier. ### FCommand - Added ToJson/FromJson methods to FCommand, which simulates the same interface as though it was using the json serialization macros, however we want more control over things so do the serialization manually via FCommand::Serialize -- Serialization is only used if the command is sent to a child process (if the current project is wrong), in which case the command should serialize out all info that it derived during setup that it will need to process correctly. Usually this consists of the options that were parsed from the command line. Then when the child process is run we will recreate the command via the same serialize method. - Added a new class FProcessPipes, which acts as a wrapper around the pipes we can create by calling FPlatformProcess::CreatePipe which are returned as raw pointers. This ensures that the pipes are cleaned up once the FProcessPipes object goes out of scope. - The ::Run method has been split into two, ::ProcessProject and ::ProcessOutput -- ::ProcessProject is called once per project and allows the command to return output via the Output parameter. This can be call in process or via a child process if the project needs to be set. -- ::ProcessOutput is called once all projects have been processed and provides an array which is a collection of the output from each call to ::ProcessProject. This is always called in process. -- The output is passed around by the base type FCommandOutput. It is expected that commands derive their own type and as we do not mix command types, they should know how to cast the output back to the correct type when ::ProcessOutput is called. This is a bit messy but to go further risks over engineering given it is unlikely that more commands will be added to the tool. If we do expand the tool in the future then this can be revisited. ### FCommandOutput - A struct used to represent the output of a command. - If the command is run as a child process then this struct will be serialized out to disk (via json) then loaded back in by the calling process so that the output of each child process can be combined. - Commands are expected to derive their own output structure and deal with the json serialization. To make this easier we provide a JSON_SERIALIZE_PARENT macro to allow for serialization of inheritance chains. - This system does require that commands know which type of output to cast FCommandOutput to. At the moment we do not provide any type safety. - Add json serialization to FProject and it's child struct FPlugin. - FProject::GetProjectFilePath now returns as a reference to a FString rather than a FStringView. [CL 24257111 by paul chipchase in ue5-main branch]
63 lines
1.4 KiB
C++
63 lines
1.4 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
#pragma once
|
|
|
|
#include "Containers/Array.h"
|
|
#include "Containers/StringFwd.h"
|
|
#include "Containers/UnrealString.h"
|
|
#include "Serialization/JsonSerializerMacros.h"
|
|
|
|
namespace UE::Virtualization
|
|
{
|
|
|
|
struct FPlugin : public FJsonSerializable
|
|
{
|
|
public:
|
|
FString PluginFilePath;
|
|
|
|
TArray<FString> PackagePaths;
|
|
|
|
public:
|
|
BEGIN_JSON_SERIALIZER
|
|
JSON_SERIALIZE("PluginPath", PluginFilePath);
|
|
JSON_SERIALIZE_ARRAY("PackagePaths", PackagePaths);
|
|
END_JSON_SERIALIZER
|
|
};
|
|
|
|
class FProject : public FJsonSerializable
|
|
{
|
|
public:
|
|
FProject() = default;
|
|
FProject(FString&& ProjectFilePath);
|
|
~FProject() = default;
|
|
|
|
void AddFile(const FString& FilePath);
|
|
void AddPluginFile(const FString& FilePath, FString&& PluginFilePath);
|
|
|
|
const FString& GetProjectFilePath() const;
|
|
FStringView GetProjectName() const;
|
|
FStringView GetProjectRoot() const;
|
|
|
|
TArray<FString> GetAllPackages() const;
|
|
|
|
void RegisterMountPoints() const;
|
|
void UnRegisterMountPoints() const;
|
|
|
|
bool TryLoadConfig(FConfigFile& OutConfig) const;
|
|
|
|
private:
|
|
FString ProjectFilePath;
|
|
|
|
TArray<FPlugin> Plugins;
|
|
TArray<FString> PackagePaths;
|
|
|
|
public:
|
|
BEGIN_JSON_SERIALIZER
|
|
JSON_SERIALIZE("ProjectPath", ProjectFilePath);
|
|
JSON_SERIALIZE_ARRAY_SERIALIZABLE("Plugins", Plugins, FPlugin);
|
|
JSON_SERIALIZE_ARRAY("PackagePaths", PackagePaths);
|
|
END_JSON_SERIALIZER
|
|
};
|
|
|
|
} //namespace UE::Virtualization
|