Hugging Face's logo

Datasets:
Alexhas2
/
unitysamples

Modalities:
3D
Image
Text
Formats:
imagefolder
Size:
< 1K
Libraries:
Datasets
Dataset card Data Studio Files
xet
 Community
1
unitysamples / LyraStarterGame /Build /Scripts /Automation /LyraTest.ContentValidation.cs
Alexhas2's picture
Alexhas2
Add files using upload-large-folder tool
de0d85f verified
Raw History Blame Contribute Delete
12.7 kB
// Copyright Epic Games, Inc.All Rights Reserved.
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using AutomationTool;
using EpicGame;
using EpicGames.Core;
using Microsoft.Extensions.Logging;
using static AutomationTool.CommandUtils;
namespace LyraTest
{
[Help("Commandlet for checking content to know if passes all the existing UEditorValidators.")]
[Help("Branch=<Name>", "Branch to use")]
[Help("CL=<value>", "Check file changes in the range LastCL,CL")]
[Help("p4shelved", "If specified, treat CL as a shelved file to check the contents")]
[Help("p4opened", "Check currently opened files instead of using CL ranged")]
[Help("MaxPackagesToLoad=<value>", "Maximum number of recent changes to check")]
[Help("LastGoodContentCLPath=<value>", "A directory location to store the 'last good' CL so we can determine CLs between runs.")]
[Help("SkipPrevCLFileExport", "Skip exporting the 'last good' CL.")]
public class LyraContentValidation : BuildCommand
{
public override void ExecuteBuild()
{
int ThisCLInt = 0;
int PrevCL = 0;
bool CheckOpenedFiles = ParseParam("opened");
bool CheckShelvedFiles = ParseParam("shelved");
string CommandletArgs = "";
bool RunCommandlet = false;
string PrevCLFilePath = "";
bool SkipPrevCLFileExport = ParseParam("SkipPrevCLFileExport");
//@TODO: Should derive these, otherwise it will break as soon as someone clones the projects
string GameProjectDirectory = "Samples/Games/Lyra";
string GameProject = "Lyra.uproject";
string ExtensionTypeListParam = ParseParamValue("ExtTypeList", ".uasset,.umap,.cpp,.c,.h,.inl,.ini,.uproject,.uplugin,.json");
List<string> ExtensionTypeList = new List<string>();
if (string.IsNullOrEmpty(ExtensionTypeListParam))
{
Logger.LogInformation("No extensions were passed in, defaulting to always run. Set -ExtTypeList to the extension typelist for triggering the commandlet");
RunCommandlet = true;
}
else
{
ExtensionTypeList = ExtensionTypeListParam.Split(',').ToList();
}
// if not checking open files, use CL ranges
if (CheckOpenedFiles)
{
// Quickly check if the CL has any files we're interested in. This is significantly faster than firing up the editor to do
// nothing
RunCommandlet = AreFileTypesModifiedInOpenChangelists(ExtensionTypeList);
// save anyone who forgot to run this without -p4
if (!P4Enabled)
{
throw new AutomationException("This script must be executed with -p4");
}
CommandletArgs = "-P4Opened -P4Client=" + P4Env.Client;
}
else
{
string ThisCL = ParseParamValue("CL");
if (string.IsNullOrEmpty(ThisCL))
{
throw new AutomationException("-CL=<num> or -opened must be specified.");
}
if (!int.TryParse(ThisCL, out ThisCLInt))
{
throw new AutomationException("-CL must be a number.");
}
if (CheckShelvedFiles)
{
// Quickly check if the CL has any files we're interested in. This is significantly faster than firing up the editor to do
// nothing
RunCommandlet = AreFileTypesModifiedInShelvedChangelist(ThisCL, ExtensionTypeList);
// filter is what's passed to p4 files. If shelved we'll use the syntax that pulls the shelved file list
CommandletArgs = String.Format("-P4Filter=@={0}", ThisCL);
}
else
{
string Branch = ParseParamValue("Branch");
if (string.IsNullOrEmpty(Branch))
{
throw new AutomationException("-Branch must be specified to check a CL range when -opened or -shelved are not present");
}
string LastGoodContentCLPath = ParseParamValue("LastGoodContentCLPath");
if (string.IsNullOrEmpty(LastGoodContentCLPath))
{
// Default to local storage for this file (Legacy behavior)
LastGoodContentCLPath = CombinePaths(CmdEnv.LocalRoot, "Engine", "Saved");
}
string PrevCLFileName = "PrevCL_" + Branch.Replace("/", "+") + ".txt";
PrevCLFilePath = CombinePaths(LastGoodContentCLPath, PrevCLFileName);
PrevCL = ReadPrevCLFile(PrevCLFilePath);
if (PrevCL <= 0)
{
Logger.LogInformation("Previous CL file didn't exist. Defaulting to none!");
RunCommandlet = true;
}
else if (PrevCL >= ThisCLInt)
{
Logger.LogInformation("Previous CL file shows a CL equal or newer than the current CL. This content was already checked. Skipping.");
RunCommandlet = false;
}
else
{
// +1 to the previous cl so it won't use content from the previous change
PrevCL++;
CommandletArgs = String.Format("-P4Filter={0}/{1}/...@{2},{3}", Branch, GameProjectDirectory, PrevCL, ThisCL);
Logger.LogInformation("Generated Filter: {CommandletArgs}", CommandletArgs);
RunCommandlet = WereFileTypesModifiedInChangelistRange(Branch, PrevCL, ThisCL, ExtensionTypeList);
}
if (!RunCommandlet)
{
Logger.LogInformation("No files in CL Range {PrevCL} -> {ThisCL} contained any files ending with extensions {ExtensionTypeListParam}, or they were already checked in a previous job, skipping commandlet run", PrevCL, ThisCL, ExtensionTypeListParam);
}
}
}
if (RunCommandlet)
{
string EditorExe = "UnrealEditor.exe";
EditorExe = AutomationTool.HostPlatform.Current.GetUnrealExePath(EditorExe);
string PerforceToken = P4.GetAuthenticationToken();
CommandletArgs += " -ini:Engine:[Core.System]:AssetLogShowsDiskPath=True -LogCmds=\"LogHttp Error\" ";
// Do we have a valid perforce token?
//if (!string.IsNullOrEmpty(PerforceToken))
{
CommandletArgs += String.Format(" -SCCProvider={0} -P4Port={1} -P4User={2} -P4Client={3} -P4Passwd={4}", "Perforce", P4Env.ServerAndPort, P4Env.User, P4Env.Client, PerforceToken);
// If skip export was specified (e.g. a preflight) don't export anything
}
string MaxPackagesToLoad = ParseParamValue("MaxPackagesToLoad", "2000");
CommandletArgs += String.Format(" -MaxPackagesToLoad={0}", MaxPackagesToLoad);
CommandUtils.RunCommandlet(new FileReference(CombinePaths(CmdEnv.LocalRoot, GameProjectDirectory, GameProject)), EditorExe, "ContentValidationCommandlet", CommandletArgs);
}
// Read the previous CL file one more time before writing to it, in case it changed while we were running
if (SkipPrevCLFileExport)
{
Logger.LogInformation("Not writing PrevCLFile as -SkipPrevCLFileExport was specified");
}
else
{
ExportPrevCL(PrevCL, ThisCLInt, PrevCLFilePath);
}
}
/// <summary>
/// Exports 'last good' CL information by reading the previous CL file before writing the current CL to it, in case it changed while we were running
/// </summary>
/// <param name="PrevCL"></param>
/// <param name="ThisCL"></param>
/// <param name="PrevCLFilePath"></param>
private void ExportPrevCL(int PrevCL, int ThisCL, string PrevCLFilePath)
{
if (ThisCL > 0)
{
if (PrevCL < ThisCL)
{
PrevCL = ReadPrevCLFile(PrevCLFilePath);
}
if (PrevCL < ThisCL)
{
Logger.LogInformation("Writing PrevCLFile {PrevCLFilePath}...", PrevCLFilePath);
WritePrevCLFile(PrevCLFilePath, ThisCL.ToString());
}
else
{
Logger.LogInformation("Not writing PrevCLFile {PrevCLFilePath}. The current CL was not newer", PrevCLFilePath);
}
}
else
{
Logger.LogInformation("Not writing PrevCLFile {PrevCLFilePath} as the current CL {ThisCL} was invalid", PrevCLFilePath, ThisCL);
}
}
private int ReadPrevCLFile(string PrevCLFilePath)
{
int RetVal = 0;
if (File.Exists(PrevCLFilePath))
{
string PrevCLString = "";
int RetryCount = 10;
bool bProceed = false;
do
{
try
{
PrevCLString = File.ReadAllText(PrevCLFilePath);
bProceed = true;
}
catch (Exception Ex)
{
if (RetryCount > 0)
{
Logger.LogInformation("Failed to read PrevCLFilePath {PrevCLFilePath}. Retrying in a few seconds. Ex:{Arg1}", PrevCLFilePath, Ex.Message);
RetryCount--;
Thread.Sleep(TimeSpan.FromSeconds(5));
}
else
{
Logger.LogError("Failed to read PrevCLFilePath {PrevCLFilePath}. All Retries exhausted, skipping. Ex:{Arg1}", PrevCLFilePath, Ex.Message);
bProceed = true;
}
}
} while (!bProceed);
if (int.TryParse(PrevCLString, out RetVal))
{
// Read the file successfully, and it was a number
}
else
{
Logger.LogWarning("{Text}", "Couldn't parse out the changelist number from the saved PrevCLFilePath file. " + PrevCLFilePath);
}
}
return RetVal;
}
private void WritePrevCLFile(string PrevCLFilePath, string ThisCL)
{
int RetryCount = 10;
bool bProceed = false;
do
{
try
{
Directory.CreateDirectory(Path.GetDirectoryName(PrevCLFilePath));
File.WriteAllText(PrevCLFilePath, ThisCL);
bProceed = true;
}
catch (Exception Ex)
{
if (RetryCount > 0)
{
Logger.LogInformation("Failed to write PrevCLFilePath {PrevCLFilePath}. Retrying in a few seconds. Ex:{Arg1}", PrevCLFilePath, Ex.Message);
RetryCount--;
Thread.Sleep(TimeSpan.FromSeconds(5));
}
else
{
Logger.LogError("Failed to write PrevCLFilePath {PrevCLFilePath}. All Retries exhausted, skipping. Ex:{Arg1}", PrevCLFilePath, Ex.Message);
bProceed = true;
}
}
} while (!bProceed);
}
/// <summary>
/// Returns true if files with extensions in the provided list were modified in the specified changelist range
/// </summary>
/// <param name="Branch"></param>
/// <param name="PrevCL"></param>
/// <param name="ThisCL"></param>
/// <param name="ExtensionTypeList"></param>
/// <returns></returns>
private bool WereFileTypesModifiedInChangelistRange(string Branch, int PrevCL, string ThisCL, List<string> ExtensionTypeList)
{
// we don't need to do any of this if there was no extensions typelist passed in
if (ExtensionTypeList.Count != 0)
{
// check all the changes in FN from PrevCL to now
List<P4Connection.ChangeRecord> ChangeRecords;
CommandUtils.P4.Changes(out ChangeRecords, string.Format("{0}/...@{1},{2}", Branch, PrevCL, ThisCL), false);
foreach (P4Connection.ChangeRecord Record in ChangeRecords)
{
P4Connection.DescribeRecord DescribeRecord;
CommandUtils.P4.DescribeChangelist(Record.CL, out DescribeRecord, false);
// check all the files in each cl record
foreach (P4Connection.DescribeRecord.DescribeFile File in DescribeRecord.Files)
{
// if any of them end in extensions in our typelist, we need to build
foreach (string Extension in ExtensionTypeList)
{
if (File.File.EndsWith(Extension))
{
return true;
}
}
}
}
}
return false;
}
/// <summary>
/// Returns true if files with extensions in the provided list are in the specified shelved changelist
/// </summary>
/// <param name="ShelvedChangelist"></param>
/// <param name="ExtensionTypeList"></param>
/// <returns></returns>
private bool AreFileTypesModifiedInShelvedChangelist(string ShelvedChangelist, List<string> ExtensionTypeList)
{
// we don't need to do any of this if there was no extensions typelist passed in
if (ExtensionTypeList.Count != 0)
{
// Get all files in this changelist
IEnumerable<string> FileList = CommandUtils.P4.Files("@=" + ShelvedChangelist);
return FileList.Any(F => ExtensionTypeList.Contains(Path.GetExtension(F), StringComparer.OrdinalIgnoreCase));
}
return false;
}
/// <summary>
/// Returns true if files with extensions in the provided list are open locally
/// </summary>
/// <param name="ExtensionTypeList"></param>
/// <returns></returns>
private bool AreFileTypesModifiedInOpenChangelists(List<string> ExtensionTypeList)
{
// we don't need to do any of this if there was no extensions typelist passed in
if (ExtensionTypeList.Count != 0)
{
// Get all files in this changelist
IEnumerable<string> FileList = CommandUtils.P4.Opened("");
return FileList.Any(F => ExtensionTypeList.Contains(Path.GetExtension(F), StringComparer.OrdinalIgnoreCase));
}
return false;
}
}
}