public override void BuildTargetLib(TargetLib TargetLib, string TargetConfiguration)
{
DirectoryReference ConfigDirectory = GetProjectsDirectory(TargetLib, TargetConfiguration);
string Makefile = FileReference.Combine(ConfigDirectory, "Makefile").FullName;
if (!FileExists(Makefile))
{
throw new AutomationException("Unabled to build {0} - file not found.", Makefile);
}
DirectoryReference CommonToolsPath = new DirectoryReference(System.Environment.GetEnvironmentVariable("VS140COMNTOOLS"));
ProcessStartInfo StartInfo = new ProcessStartInfo();
StartInfo.FileName = "cmd.exe";
StartInfo.WorkingDirectory = ConfigDirectory.FullName;
StartInfo.Arguments = string.Format("/C \"{0}\" amd64 && nmake {1}", FileReference.Combine(CommonToolsPath, "..", "..", "VC", "vcvarsall.bat").FullName, TargetLib.MakeTarget);
LogInformation("Working in: {0}", StartInfo.WorkingDirectory);
LogInformation("{0} {1}", StartInfo.FileName, StartInfo.Arguments);
if (Utils.RunLocalProcessAndLogOutput(StartInfo) != 0)
{
throw new AutomationException("Unabled to build {0}. Build process failed.", Makefile);
}
}
public virtual void SetupTargetLib(TargetLib TargetLib, string TargetConfiguration)
{
LogInformation("Building {0} for {1} ({2})...", TargetLib.Name, TargetBuildPlatform, TargetConfiguration);
if (BuildHostPlatform.Current.Platform.IsInGroup(UnrealPlatformGroup.Unix))
{
Environment.SetEnvironmentVariable("CMAKE_ROOT", DirectoryReference.Combine(CMakeRootDirectory, "share").FullName);
LogInformation("set {0}={1}", "CMAKE_ROOT", Environment.GetEnvironmentVariable("CMAKE_ROOT"));
}
DirectoryReference CMakeTargetDirectory = GetProjectsDirectory(TargetLib, TargetConfiguration);
MakeFreshDirectoryIfRequired(CMakeTargetDirectory);
LogInformation("Generating projects for lib " + TargetLib.Name + ", " + FriendlyName);
ProcessStartInfo StartInfo = new ProcessStartInfo();
StartInfo.FileName = CMakeCommand;
StartInfo.WorkingDirectory = CMakeTargetDirectory.FullName;
StartInfo.Arguments = GetCMakeArguments(TargetLib, TargetConfiguration);
if (Utils.RunLocalProcessAndLogOutput(StartInfo) != 0)
{
throw new AutomationException("Unable to generate projects for {0}.", TargetLib.ToString() + ", " + FriendlyName);
}
}
public override void BuildTargetLib(TargetLib TargetLib, string TargetConfiguration)
{
DirectoryReference ConfigDirectory = GetProjectsDirectory(TargetLib, TargetConfiguration);
Environment.SetEnvironmentVariable("LIB_SUFFIX", TargetLib.BuildSuffix[TargetConfiguration]);
string Makefile = FileReference.Combine(ConfigDirectory, "Makefile").FullName;
if (!FileExists(Makefile))
{
throw new AutomationException("Unabled to build {0} - file not found.", Makefile);
}
ProcessStartInfo StartInfo = new ProcessStartInfo();
StartInfo.FileName = MakeCommand;
StartInfo.WorkingDirectory = ConfigDirectory.FullName;
// Bundled GNU make does not pass job number to subprocesses on Windows, work around that...
// Redefining the MAKE variable will cause the -j flag to be passed to child make instances.
StartInfo.Arguments = BuildHostPlatform.Current.Platform.IsInGroup(UnrealPlatformGroup.Windows)
? string.Format("{1} {2} \"MAKE={0} {1}\"", MakeCommand, MakeOptions, TargetLib.MakeTarget)
: string.Format("{0} {1}", MakeOptions, TargetLib.MakeTarget);
LogInformation("Working in: {0}", StartInfo.WorkingDirectory);
LogInformation("{0} {1}", StartInfo.FileName, StartInfo.Arguments);
if (Utils.RunLocalProcessAndLogOutput(StartInfo) != 0)
{
throw new AutomationException("Unabled to build {0}. Build process failed.", Makefile);
}
}
public virtual IEnumerable <FileReference> EnumerateOutputFiles(TargetLib TargetLib, string TargetConfiguration)
{
string SearchPrefix = "*" + TargetLib.BuildSuffix[TargetConfiguration] + ".";
DirectoryReference OutputLibraryDirectory = GetOutputLibraryDirectory(TargetLib, TargetConfiguration);
// Scan static libraries directory
IEnumerable <FileReference> Results = EnumerateOutputFiles(OutputLibraryDirectory, SearchPrefix + StaticLibraryExtension, TargetLib);
if (DebugDatabaseExtension != null)
{
Results = Results.Concat(EnumerateOutputFiles(OutputLibraryDirectory, SearchPrefix + DebugDatabaseExtension, TargetLib));
}
// Scan dynamic libraries directory
if (HasBinaries)
{
DirectoryReference OutputBinaryDirectory = GetOutputBinaryDirectory(TargetLib, TargetConfiguration);
Results = Results.Concat(EnumerateOutputFiles(OutputBinaryDirectory, SearchPrefix + DynamicLibraryExtension, TargetLib));
if (DebugDatabaseExtension != null)
{
Results = Results.Concat(EnumerateOutputFiles(OutputBinaryDirectory, SearchPrefix + DebugDatabaseExtension, TargetLib));
}
}
return(Results);
}
public virtual void CleanupTargetLib(TargetLib TargetLib, string TargetConfiguration)
{
if (string.IsNullOrEmpty(TargetConfiguration))
{
InternalUtils.SafeDeleteDirectory(DirectoryReference.Combine(GetTargetLibRootDirectory(TargetLib), "Build").FullName);
}
else
{
DirectoryReference CMakeTargetDirectory = GetProjectsDirectory(TargetLib, TargetConfiguration);
InternalUtils.SafeDeleteDirectory(CMakeTargetDirectory.FullName);
}
}
public override void BuildTargetLib(TargetLib TargetLib, string TargetConfiguration)
{
DirectoryReference Directory = GetProjectsDirectory(TargetLib, TargetConfiguration);
string ProjectFile = FileReference.Combine(Directory, TargetLib.ToString() + ".xcodeproj").FullName;
if (!DirectoryExists(ProjectFile))
{
throw new AutomationException("Unabled to build project {0}. Project file not found.", ProjectFile);
}
RunAndLog(CmdEnv, "/usr/bin/xcodebuild", string.Format("-project \"{0}\" -target=\"ALL_BUILD\" -configuration {1} -quiet", ProjectFile, TargetConfiguration));
}
private DirectoryReference GetTargetLibBaseBuildScriptDirectory(TargetLib TargetLib)
{
// Some libraries use BuildForUE4 instead of BuildForUE, check this here
DirectoryReference BuildForUEDirectory = DirectoryReference.Combine(GetTargetLibBaseRootDirectory(TargetLib), "BuildForUE");
if (!DirectoryReference.Exists(BuildForUEDirectory))
{
// If not available then check BuildForUE4
BuildForUEDirectory = DirectoryReference.Combine(GetTargetLibBaseRootDirectory(TargetLib), "BuildForUE4");
}
return(BuildForUEDirectory);
}
public virtual string GetCMakeArguments(TargetLib TargetLib, string TargetConfiguration)
{
string Args = "\"" + GetTargetLibPlatformCMakeDirectory(TargetLib).FullName + "\"";
Args += " -G \"" + CMakeGeneratorName + "\"";
if (SeparateProjectPerConfig)
{
Args += " -DCMAKE_BUILD_TYPE=\"" + TargetConfiguration + "\"";
}
FileReference ToolchainPath = GetToolchainPath(TargetLib, TargetConfiguration);
if (ToolchainPath != null && FileReference.Exists(ToolchainPath))
{
Args += " -DCMAKE_TOOLCHAIN_FILE=\"" + ToolchainPath.FullName + "\"";
}
FileReference ProjectIncludePath = GetProjectIncludePath(TargetLib, TargetConfiguration);
if (ProjectIncludePath != null && FileReference.Exists(ProjectIncludePath))
{
Args += " -DCMAKE_PROJECT_INCLUDE_FILE=\"" + ProjectIncludePath.FullName + "\"";
}
Args += " -DCMAKE_ARCHIVE_OUTPUT_DIRECTORY=\"" + GetOutputLibraryDirectory(TargetLib, TargetConfiguration) + "\"";
if (HasBinaries)
{
Args += " -DCMAKE_LIBRARY_OUTPUT_DIRECTORY=\"" + GetOutputBinaryDirectory(TargetLib, TargetConfiguration) + "\"";
Args += " -DCMAKE_RUNTIME_OUTPUT_DIRECTORY=\"" + GetOutputBinaryDirectory(TargetLib, TargetConfiguration) + "\"";
}
if (UseResponseFiles)
{
// Enable response files for platforms that require them.
// Response files are used for include paths etc, to fix max command line length issues.
Args += " -DUSE_RESPONSE_FILES=1";
}
string AdditionalArgs = GetAdditionalCMakeArguments(TargetLib, TargetConfiguration);
if (AdditionalArgs != null)
{
Args += AdditionalArgs.Replace("${TARGET_CONFIG}", TargetConfiguration ?? "");
}
return(Args);
}
private TargetLib GetTargetLib()
{
TargetLib TargetLib = new TargetLib();
TargetLib.Name = ParseParamValue("TargetLib", "");
TargetLib.Version = ParseParamValue("TargetLibVersion", "");
TargetLib.SourcePath = ParseParamValue("TargetLibSourcePath", "");
TargetLib.LibOutputPath = ParseParamValue("LibOutputPath", "");
TargetLib.CMakeProjectIncludeFile = ParseParamValue("CMakeProjectIncludeFile", "");
TargetLib.CMakeAdditionalArguments = ParseParamValue("CMakeAdditionalArguments", "");
TargetLib.MakeTarget = ParseParamValue("MakeTarget", TargetLib.Name).ToLower();
if (string.IsNullOrEmpty(TargetLib.Name) || string.IsNullOrEmpty(TargetLib.Version))
{
throw new AutomationException("Must specify both -TargetLib and -TargetLibVersion");
}
return(TargetLib);
}
protected FileReference GetToolchainPath(TargetLib TargetLib, string TargetConfiguration)
{
string ToolchainName = GetToolchainName(TargetLib, TargetConfiguration);
if (ToolchainName == null)
{
return(null);
}
// First check for an overriden toolchain in the BuildForUE/Platform directory
FileReference ToolChainPath = FileReference.Combine(GetTargetLibBuildScriptDirectory(TargetLib), IsPlatformExtension ? "" : Platform.ToString(), ToolchainName);
if (!FileReference.Exists(ToolChainPath))
{
// If not available then use the top level toolchain path
ToolChainPath = FileReference.Combine(PlatformEngineRoot, "Source", "ThirdParty", "CMake", "PlatformScripts", IsPlatformExtension ? "" : Platform.ToString(), ToolchainName);
}
return(ToolChainPath);
}
protected DirectoryReference GetTargetLibPlatformCMakeDirectory(TargetLib TargetLib)
{
// Possible "standard" locations for the CMakesLists.txt are BuildForUE/Platform, BuildForUE or the source root
// First check for an overriden CMakeLists.txt in the BuildForUE/Platform directory
DirectoryReference CMakeDirectory = GetTargetLibBuildScriptDirectory(TargetLib);
if (!FileReference.Exists(FileReference.Combine(CMakeDirectory, IsPlatformExtension ? "" : Platform.ToString(), "CMakeLists.txt")))
{
// If not available then check BuildForUE
CMakeDirectory = GetTargetLibBaseBuildScriptDirectory(TargetLib);
if (!FileReference.Exists(FileReference.Combine(CMakeDirectory, "CMakeLists.txt")))
{
// If not available then check the lib source root
CMakeDirectory = TargetLib.GetLibSourceDirectory();
}
}
return(CMakeDirectory);
}
protected DirectoryReference GetProjectsDirectory(TargetLib TargetLib, string TargetConfiguration) =>
DirectoryReference.Combine(GetTargetLibRootDirectory(TargetLib), "Build",
IsPlatformExtension ? "" : TargetBuildPlatform,
PlatformBuildSubdirectory ?? "",
SeparateProjectPerConfig ? TargetLib.BuildMap[TargetConfiguration] : "");
protected FileReference GetProjectIncludePath(TargetLib TargetLib, string TargetConfiguration)
{
return(FileReference.Combine(GetTargetLibBuildScriptDirectory(TargetLib), IsPlatformExtension ? "" : Platform.ToString(), TargetLib.CMakeProjectIncludeFile));
}
protected DirectoryReference GetOutputLibraryDirectory(TargetLib TargetLib, string TargetConfiguration)
{
return(DirectoryReference.Combine(GetTargetLibRootDirectory(TargetLib), TargetLib.LibOutputPath, IsPlatformExtension ? "" : Platform.ToString(), PlatformBuildSubdirectory ?? "", TargetConfiguration));
}
public abstract void BuildTargetLib(TargetLib TargetLib, string TargetConfiguration);
protected DirectoryReference GetOutputBinaryDirectory(TargetLib TargetLib, string TargetConfiguration)
{
return(DirectoryReference.Combine(PlatformEngineRoot, IsPlatformExtension ? "" : Platform.ToString(), PlatformBuildSubdirectory ?? "", TargetConfiguration));
}
public abstract bool SupportsTargetLib(TargetLib Library);
public override void ExecuteBuild()
{
bool bAutoCreateChangelist = true;
if (ParseParam("SkipCreateChangelist"))
{
bAutoCreateChangelist = false;
}
bool bAutoSubmit = bAutoCreateChangelist;
if (ParseParam("SkipSubmit"))
{
bAutoSubmit = false;
}
// if we don't pass anything, we'll just merge by default
string RobomergeCommand = ParseParamValue("Robomerge", "").ToLower();
if (!string.IsNullOrEmpty(RobomergeCommand))
{
// for merge default action, add flag to make sure buildmachine commit isn't skipped
if (RobomergeCommand == "merge")
{
RobomergeCommand = "#robomerge[all] #DisregardExcludedAuthors";
}
// otherwise add hashtags
else if (RobomergeCommand == "ignore")
{
RobomergeCommand = "#robomerge #ignore";
}
else if (RobomergeCommand == "null")
{
RobomergeCommand = "#robomerge #null";
}
// otherwise the submit will likely fail.
else
{
throw new AutomationException("Invalid Robomerge param passed in {0}. Must be \"merge\", \"null\", or \"ignore\"", RobomergeCommand);
}
}
SetupBuildEnvironment();
TargetPlatform Platform = GetTargetPlatform();
TargetLib TargetLib = GetTargetLib();
List <string> TargetConfigurations = GetTargetConfigurations();
if (Platform.SeparateProjectPerConfig)
{
foreach (string TargetConfiguration in TargetConfigurations)
{
Platform.SetupTargetLib(TargetLib, TargetConfiguration);
}
}
else
{
Platform.SetupTargetLib(TargetLib, null);
}
HashSet <FileReference> FilesToReconcile = new HashSet <FileReference>();
foreach (string TargetConfiguration in TargetConfigurations)
{
foreach (FileReference FileToDelete in Platform.EnumerateOutputFiles(TargetLib, TargetConfiguration).Distinct())
{
FilesToReconcile.Add(FileToDelete);
// Also clean the output files
InternalUtils.SafeDeleteFile(FileToDelete.FullName);
}
}
foreach (string TargetConfiguration in TargetConfigurations)
{
Platform.BuildTargetLib(TargetLib, TargetConfiguration);
}
Platform.CleanupTargetLib(TargetLib, null);
const int InvalidChangeList = -1;
int P4ChangeList = InvalidChangeList;
if (bAutoCreateChangelist)
{
string LibDeploymentDesc = TargetLib.Name + " " + Platform.FriendlyName;
var Builder = new StringBuilder();
Builder.AppendFormat("BuildCMakeLib.Automation: Deploying {0} libs.{1}", LibDeploymentDesc, Environment.NewLine);
Builder.AppendLine("#rb none");
Builder.AppendLine("#lockdown Nick.Penwarden");
Builder.AppendLine("#tests none");
Builder.AppendLine("#jira none");
Builder.AppendLine("#okforgithub ignore");
if (!string.IsNullOrEmpty(RobomergeCommand))
{
Builder.AppendLine(RobomergeCommand);
}
P4ChangeList = P4.CreateChange(P4Env.Client, Builder.ToString());
}
if (P4ChangeList != InvalidChangeList)
{
foreach (FileReference FileToReconcile in FilesToReconcile)
{
P4.Reconcile(P4ChangeList, FileToReconcile.FullName);
}
if (bAutoSubmit)
{
if (!P4.TryDeleteEmptyChange(P4ChangeList))
{
LogInformation("Submitting changelist " + P4ChangeList.ToString());
int SubmittedChangeList = InvalidChangeList;
P4.Submit(P4ChangeList, out SubmittedChangeList);
}
else
{
LogInformation("Nothing to submit!");
}
}
}
}
public virtual string GetAdditionalCMakeArguments(TargetLib TargetLib, string TargetConfiguration) => " " + TargetLib.CMakeAdditionalArguments;
public virtual string GetToolchainName(TargetLib TargetLib, string TargetConfiguration) => FriendlyName + ".cmake";
private DirectoryReference GetTargetLibRootDirectory(TargetLib TargetLib)
{
return(DirectoryReference.Combine(PlatformEngineRoot, "Source", "ThirdParty", TargetLib.Name, TargetLib.Version));
}
public virtual IEnumerable <FileReference> EnumerateOutputFiles(DirectoryReference BaseDir, string SearchPrefix, TargetLib TargetLib)
{
if (!DirectoryReference.Exists(BaseDir))
{
yield break;
}
foreach (FileReference File in DirectoryReference.EnumerateFiles(BaseDir, SearchPrefix))
{
var FileNameUpper = File.GetFileName().ToUpper();
if (FileNameUpper.Contains(TargetLib.Name.ToUpper()))
{
yield return(File);
}
}
}
