public override void ExecuteBuild()
{
var bLayered = ParseParam("layered");
var SourceDirectory = ParseParamValue("sourcedirectory", null);
var TargetDirectory = ParseParamValue("targetdirectory", null);
var CryptoKeysFile = ParseParamValue("cryptokeysjson", null);
var Compressor = ParseParamValue("customcompressor", null);
var Project = ParseParamValue("project", null);
string ExtraArgs = "";
if (!string.IsNullOrEmpty(Compressor))
{
ExtraArgs += "-customcompressor=" + Compressor;
}
if (Params.Contains("passargs"))
{
IEnumerable <string> ExtraArgArray = Params.Where((arg, index) => index > Array.IndexOf(Params, "passargs"));
if (ExtraArgArray.Count() > 0)
{
ExtraArgs += " -" + string.Join(" -", ExtraArgArray);
}
}
if (String.IsNullOrEmpty(SourceDirectory))
{
throw new AutomationException("SourceDirectory is a required parameter");
}
if (String.IsNullOrEmpty(TargetDirectory))
{
throw new AutomationException("TargetDirectory is a required parameter");
}
if (String.IsNullOrEmpty(CryptoKeysFile))
{
throw new AutomationException("CryptoKeysJson is a required parameter");
}
DirectoryInfo SourceDirectoryInfo = new DirectoryInfo(SourceDirectory);
LogInformation("Extracting paks from {0} to {1}", SourceDirectory, TargetDirectory);
FileReference ProjectFile = null;
if (!string.IsNullOrEmpty(Project))
{
ProjectFile = ProjectUtils.FindProjectFileFromName(Project);
if (ProjectFile == null)
{
throw new AutomationException("Could not find project file based on {0}", Project);
}
}
PackageUtils.ExtractPakFiles(SourceDirectoryInfo, TargetDirectory, CryptoKeysFile, ExtraArgs, bLayered, ProjectFile);
}
/// <summary>
/// Called after command line params are applied. Perform any checks / fixup
/// </summary>
/// <param name="InParams"></param>
public virtual void ParametersWereApplied(string[] InParams)
{
// save params
this.Params = new Params(InParams);
if (string.IsNullOrEmpty(TempDir))
{
TempDir = Globals.TempDir;
}
else
{
Globals.TempDir = TempDir;
}
if (string.IsNullOrEmpty(LogDir))
{
LogDir = Globals.LogDir;
}
else
{
Globals.LogDir = LogDir;
}
// normalize the project name and get the path
if (File.Exists(Project))
{
ProjectPath = new FileReference(Project);
Project = ProjectPath.GetFileNameWithoutExtension();
}
else
{
if (!string.IsNullOrEmpty(Project))
{
ProjectPath = ProjectUtils.FindProjectFileFromName(Project);
if (ProjectPath == null)
{
throw new AutomationException("Could not find project file for {0}", Project);
}
Project = ProjectPath.GetFileNameWithoutExtension();
}
}
if (string.IsNullOrEmpty(Sandbox))
{
Sandbox = Project;
}
// parse platforms. These will be in the format of Win64(param1,param2='foo,bar') etc
// check for old-style -platform=Win64(params)
List <string> PlatformArgStrings = Params.ParseValues("Platform=");
// check for convenience flags of -Win64(params) (TODO - need to think about this..)
/*foreach (UnrealTargetPlatform Plat in UnrealTargetPlatform.GetValidPlatforms())
* {
* IEnumerable<string> RawPlatformArgs = InParams.Where(P => P.ToLower().StartsWith(Plat.ToString().ToLower()));
*
* PlatformArgStrings.AddRange(RawPlatformArgs);
* }*/
// now turn the Plat(param1,param2) etc into an argument/parm pair
PlatformList = PlatformArgStrings.SelectMany(P => ArgumentWithParams.CreateFromString(P)).ToList();
List <string> TestArgStrings = Params.ParseValues("test=");
// clear all tests incase this is called multiple times
TestList.Clear();
if (TestArgStrings.Count == 0)
{
TestArgStrings = Params.ParseValues("tests=");
}
foreach (string TestArg in TestArgStrings)
{
foreach (ArgumentWithParams TestWithParms in ArgumentWithParams.CreateFromString(TestArg))
{
TestRequest Test = new TestRequest()
{
TestName = TestWithParms.Argument, TestParams = new Params(TestWithParms.AllArguments)
};
// parse any specified platforms
foreach (string PlatformArg in Test.TestParams.ParseValues("Platform="))
{
List <ArgumentWithParams> PlatParams = ArgumentWithParams.CreateFromString(PlatformArg);
Test.Platforms.AddRange(PlatParams);
// register platform in test options
PlatParams.ForEach(TestPlat => { if (PlatformList.Where(Plat => Plat.Argument == TestPlat.Argument).Count() == 0)
{
PlatformList.Add(TestPlat);
}
});
}
TestList.Add(Test);
}
}
if (PlatformList.Count == 0)
{
// Default to local platform
PlatformList.Add(new ArgumentWithParams(BuildHostPlatform.Current.Platform.ToString(), new string[0]));
}
// do we have any tests? Need to check the global test list
bool HaveTests = TestList.Count > 0 || PlatformList.Where(Plat => Plat.ParseValues("test").Count() > 0).Count() > 0;
// turn -device=BobsKit,BobsKit(PS4) into a device list
List <string> DeviceArgStrings = Params.ParseValues("device=");
if (DeviceArgStrings.Count == 0)
{
DeviceArgStrings = Params.ParseValues("devices=");
}
DeviceList = DeviceArgStrings.SelectMany(D => ArgumentWithParams.CreateFromString(D)).ToList();
if (DeviceList.Count == 0)
{
// Add the default test
DeviceList.Add(new ArgumentWithParams("default", new string[0]));
}
// remote all -test and -platform arguments from our params. Nothing else should be looking at these now...
string[] CleanArgs = Params.AllArguments
.Where(Arg => !Arg.StartsWith("test=", StringComparison.OrdinalIgnoreCase) &&
!Arg.StartsWith("platform=", StringComparison.OrdinalIgnoreCase) &&
!Arg.StartsWith("device=", StringComparison.OrdinalIgnoreCase))
.ToArray();
Params = new Params(CleanArgs);
}
public override ExitCode Execute()
{
LogInformation("************************* SyncProject");
// These are files that should always be synced because tools update them
string[] ForceSyncFiles = new string[]
{
"Engine/Build/Build.version",
"Engine/Source/Programs/DotNETCommon/MetaData.cs"
};
// Parse the project filename (as a local path)
string ProjectArg = ParseParamValue("Project", null);
// Parse the changelist to sync to. -1 will sync to head.
int CL = ParseParamInt("CL", -1);
int Threads = ParseParamInt("threads", 2);
bool ForceSync = ParseParam("force");
bool PreviewOnly = ParseParam("preview");
bool ProjectOnly = ParseParam("projectonly");
int Retries = ParseParamInt("retries", 3);
bool Unversioned = ParseParam("unversioned");
bool BuildProject = ParseParam("build");
bool OpenProject = ParseParam("open");
bool GenerateProject = ParseParam("generate");
string PathArg = ParseParamValue("paths", "");
IEnumerable <string> ExplicitPaths = PathArg.Split(new char[] { ',', ';' }, StringSplitOptions.RemoveEmptyEntries).Select(S => S.Trim());
if (CL == 0)
{
if (!ForceSync)
{
throw new AutomationException("If using 0 CL to remove files -force must also be specified");
}
// Cannot unsync the engine folder
ProjectOnly = true;
}
else if (CL == -1)
{
// find most recent change
List <P4Connection.ChangeRecord> Records;
string Cmd = string.Format("-s submitted -m1 //{0}/...", P4Env.Client);
if (!P4.Changes(out Records, Cmd, false))
{
throw new AutomationException("p4 changes failed. Cannot find most recent CL");
}
CL = Records.First().CL;
}
bool EngineOnly = string.IsNullOrEmpty(ProjectArg);
// Will be the full local path to the project file once resolved
FileReference ProjectFile = null;
// Will be the full workspace path to the project in P4 (if a project was specified)
string P4ProjectPath = null;
// Will be the full workspace path to the engine in P4 (If projectonly wasn't specified);
string P4EnginePath = null;
// If we're syncing a project find where it is in P4
if (!EngineOnly)
{
ProjectFile = ProjectUtils.FindProjectFileFromName(ProjectArg);
if (ProjectFile != null)
{
// get the path in P4
P4WhereRecord Record = P4.Where(ProjectFile.FullName, AllowSpew: false).FirstOrDefault(x => x.DepotFile != null && !x.bUnmap);
P4ProjectPath = Record.ClientFile;
}
else
{
// if they provided a name and not a path then find the file (requires that it's synced).
string RelativePath = ProjectArg;
if (Path.GetExtension(RelativePath).Length == 0)
{
RelativePath = Path.ChangeExtension(RelativePath, "uproject");
}
if (!RelativePath.Contains(Path.DirectorySeparatorChar) && !RelativePath.Contains(Path.AltDirectorySeparatorChar))
{
RelativePath = CommandUtils.CombinePaths(PathSeparator.Slash, Path.GetFileNameWithoutExtension(RelativePath), RelativePath);
}
Log.TraceInformation("{0} not on disk. Searching P4 for {1}", ProjectArg, RelativePath);
List <string> SearchPaths = new List <string>();
SearchPaths.Add("");
string ProjectDirsFile = Directory.EnumerateFiles(CommandUtils.CombinePaths(CmdEnv.LocalRoot), "*.uprojectdirs").FirstOrDefault();
if (ProjectDirsFile != null)
{
foreach (string FilePath in File.ReadAllLines(ProjectDirsFile))
{
string Trimmed = FilePath.Trim();
if (!Trimmed.StartsWith("./", StringComparison.OrdinalIgnoreCase) &&
!Trimmed.StartsWith(";", StringComparison.OrdinalIgnoreCase) &&
Trimmed.IndexOfAny(Path.GetInvalidPathChars()) < 0)
{
SearchPaths.Add(Trimmed);
}
}
}
// Get the root of the branch containing the selected file
foreach (string SearchPath in SearchPaths)
{
string P4Path = CommandUtils.CombinePaths(PathSeparator.Slash, P4Env.ClientRoot, SearchPath, RelativePath);
if (P4.FileExistsInDepot(P4Path))
{
P4WhereRecord Record = P4.Where(P4Path, AllowSpew: false).FirstOrDefault(x => x.DepotFile != null && !x.bUnmap);
// make sure to sync with //workspace/path as it cleans up files if the user has stream switched
P4ProjectPath = Record.ClientFile;
Log.TraceInformation("Found project at {0}", P4ProjectPath);
break;
}
}
}
if (string.IsNullOrEmpty(P4ProjectPath))
{
throw new AutomationException("Could not find project file for {0} locally or in P4. Provide a full path or check the subdirectory is listed in UE4Games.uprojectdirs", ProjectArg);
}
Log.TraceVerbose("Resolved {0} to P4 Path {1}", ProjectArg, P4ProjectPath);
}
// Build the list of paths that need syncing
List <string> SyncPaths = new List <string>();
//
if (ExplicitPaths.Any())
{
// Add all explicit paths as <root>/Path/...
ExplicitPaths.ToList().ForEach(P => SyncPaths.Add(CommandUtils.CombinePaths(PathSeparator.Slash, P4Env.ClientRoot, P, "...")));
}
else
{
// See if the engine is in P4 too by checking the p4 location of a local file
string LocalEngineFile = CommandUtils.CombinePaths(CmdEnv.LocalRoot, "Engine", "Source", "UE4Editor.target.cs");
P4WhereRecord EngineRecord = P4.Where(LocalEngineFile, AllowSpew: false).FirstOrDefault(x => x.DepotFile != null && !x.bUnmap);
if (!ProjectOnly && P4.FileExistsInDepot(EngineRecord.DepotFile))
{
// make sure to sync with //workspace/path as it cleans up files if the user has stream switched
P4EnginePath = EngineRecord.ClientFile.Replace("Engine/Source/UE4Editor.target.cs", "");
SyncPaths.Add(CommandUtils.CombinePaths(PathSeparator.Slash, P4EnginePath + "*"));
SyncPaths.Add(CommandUtils.CombinePaths(PathSeparator.Slash, P4EnginePath, "Engine", "..."));
}
if (!string.IsNullOrEmpty(P4ProjectPath))
{
string P4ProjectDir = Regex.Replace(P4ProjectPath, @"[^/]+\.uproject", "...", RegexOptions.IgnoreCase);
SyncPaths.Add(P4ProjectDir);
}
}
// Force these files as they can be overwritten by tools
if (!PreviewOnly && !string.IsNullOrEmpty(P4EnginePath) && !ProjectOnly)
{
IEnumerable <string> ForceSyncList = ForceSyncFiles.Select(F => CommandUtils.CombinePaths(PathSeparator.Slash, P4EnginePath, F));
foreach (var F in ForceSyncList)
{
LogInformation("Force-updating {0}", F);
string SyncCommand = string.Format("-f {0}@{1}", F, CL);
// sync with retries
P4.Sync(SyncCommand, true, false, Retries);
}
}
// Sync all the things
foreach (string SyncPath in SyncPaths)
{
string SyncCommand = "";
if (Threads > 1)
{
SyncCommand = string.Format(" --parallel \"threads={0}\" {1}", Threads, SyncCommand);
}
if (ForceSync)
{
SyncCommand = SyncCommand + " -f";
}
SyncCommand += string.Format(" {0}@{1}", SyncPath, CL);
if (!PreviewOnly)
{
// sync with retries
P4.Sync(SyncCommand, true, false, Retries);
}
else
{
LogInformation("sync {0}", SyncCommand);
}
}
// P4 utils don't return errors :(
ExitCode ExitStatus = ExitCode.Success;
// Sync is complete so do the actions
if (!PreviewOnly && CL > 0)
{
// Argument to pass to the editor (could be null with no project).
string ProjectArgForEditor = "";
if (!string.IsNullOrEmpty(ProjectArg))
{
// If we synced the project from P4 we couldn't resolve this earlier
if (ProjectFile == null)
{
NativeProjects.ClearCache();
ProjectFile = ProjectUtils.FindProjectFileFromName(ProjectArg);
}
ProjectArgForEditor = ProjectFile.FullName;
}
if (GenerateProject)
{
Log.TraceVerbose("Generating project files for {0}", ProjectArgForEditor);
if (BuildHostPlatform.Current.Platform == UnrealTargetPlatform.Win64 ||
BuildHostPlatform.Current.Platform == UnrealTargetPlatform.Win32)
{
CommandUtils.Run("GenerateProjectFiles.bat", ProjectArgForEditor);
}
else
{
CommandUtils.Run("GenerateProjectFiles.sh", ProjectArgForEditor);
}
}
UE4Build Build = new UE4Build(this);
if (!Unversioned && !ProjectOnly)
{
Build.UpdateVersionFiles(ActuallyUpdateVersionFiles: true, ChangelistNumberOverride: CL, IsPromotedOverride: false);
}
// Build everything
if (BuildProject && ExitStatus == ExitCode.Success)
{
Log.TraceVerbose("Building Editor for {0}", ProjectArgForEditor);
BuildEditor BuildCmd = new BuildEditor();
BuildCmd.Clean = ParseParam("clean");
BuildCmd.ProjectName = ProjectArgForEditor;
ExitStatus = BuildCmd.Execute();
}
if (OpenProject && ExitStatus == ExitCode.Success)
{
Log.TraceVerbose("Opening Editor for {0}", ProjectArgForEditor);
OpenEditor OpenCmd = new OpenEditor();
OpenCmd.ProjectName = ProjectArgForEditor;
ExitStatus = OpenCmd.Execute();
}
}
return(ExitCode.Success);
}
public override ExitCode Execute()
{
// Parse the project filename (as a local path)
ProjectArg = ParseParamValue("Project", ProjectArg);
Preview = Preview || ParseParam("Preview");
// Will be the full local path to the project file once resolved
FileReference ProjectFile = ProjectUtils.FindProjectFileFromName(ProjectArg);
if (ProjectFile == null)
{
throw new AutomationException("Could not find project file for {0}. Provide a full path or check the subdirectory is listed in UE4Games.uprojectdirs", ProjectArg);
}
// Will be the full workspace path to the project in P4
P4WhereRecord ProjectRecord = GetP4RecordForPath(ProjectFile.FullName);
if (ProjectRecord == null)
{
throw new AutomationException("Could not find a P4 record for {0} with the current workspace settings. use RunUAT P4WriteConfig to write a config file with the relevant info", ProjectFile.FullName);
}
// get the path to binaries in the depot
string DepotBinaryPath = GetZippedBinaryPathFromUGSConfig(ProjectFile.Directory, ProjectRecord.DepotFile);
// get the CL
int CompatibleChangeList = 0;
int CurrentChangeList = 0;
GetCurrentAndCompatibleChangeLists(ProjectRecord.DepotFile, out CurrentChangeList, out CompatibleChangeList);
LogInformation("Current CL: {0}, Required Compatible CL: {1}", CurrentChangeList, CompatibleChangeList);
List <P4Connection.ChangeRecord> BinaryChanges;
P4.Changes(out BinaryChanges, DepotBinaryPath, AllowSpew: false);
// changes will be in ascending order, so pull out the CL's they were submitted for and return the first CL that is greater than
// the change we need. This lets people regress issues if needed.
int CheckedInBinaryCL = BinaryChanges.Where(R => {
// use a regex to pull the CL the binaries were built from. The description will be something like "[CL 21611] Updated..",
// where 21611 is the change they were generated from
Match M = Regex.Match(R.Summary, @"\[CL\s+(\d+)\]");
if (M == null)
{
LogWarning("Change description for {0} did not include expected format of [CL xxxx]", R.CL);
return(false);
}
int SourceCL = Convert.ToInt32(M.Groups[1].ToString());
// Only interested in records greater than the code CL
return(SourceCL >= CompatibleChangeList);
})
.Select(R => R.CL) // We want the CL of that record
.FirstOrDefault(); // And we only care about the first match
if (CheckedInBinaryCL == 0)
{
throw new AutomationException("Could not find a submitted CL for {0} that was for source code >= CL {1}", DepotBinaryPath, CompatibleChangeList);
}
string VersionedFile = string.Format("{0}@{1}", DepotBinaryPath, CheckedInBinaryCL);
LogInformation("Will sync and extract binaries from {0}", VersionedFile);
if (!Preview)
{
string TmpFile = Path.Combine(Path.GetTempPath(), "UGS.zip");
try
{
P4.PrintToFile(VersionedFile, TmpFile);
LogInformation("Unzipping to {0}", CommandUtils.RootDirectory);
// we can't use helpers as unlike UGS we don't want to extract anything for UAT, since that us running us....
// That should be fine since we are either being run from the source CL that has already been syned to, or the
// next time UAT is run we'll be rebuilt with that CL...
int FileCount = 0;
string UATDirectory = "Engine/Binaries/DotNET";
using (Ionic.Zip.ZipFile Zip = new Ionic.Zip.ZipFile(TmpFile))
{
foreach (Ionic.Zip.ZipEntry Entry in Zip.Entries.Where(x => !x.IsDirectory))
{
string OutputFileName = Path.Combine(CommandUtils.RootDirectory.FullName, Entry.FileName);
if (Entry.FileName.Replace("\\", "/").StartsWith(UATDirectory, StringComparison.OrdinalIgnoreCase))
{
LogInformation("Skipping {0} as UAT is running", OutputFileName);
}
else
{
Directory.CreateDirectory(Path.GetDirectoryName(OutputFileName));
using (FileStream OutputStream = new FileStream(OutputFileName, FileMode.Create, FileAccess.Write))
{
Entry.Extract(OutputStream);
}
LogInformation("Extracted {0}", OutputFileName);
FileCount++;
}
}
}
LogInformation("Unzipped {0} files", FileCount);
}
catch (Exception Ex)
{
throw new AutomationException("Failed to uinzip files: {0}", Ex.Message);
}
finally
{
try
{
if (File.Exists(TmpFile))
{
File.Delete(TmpFile);
}
}
catch
{
LogInformation("Failed to remove tmp file {0}", TmpFile);
}
}
// Update version files with our current and compatible CLs
LogInformation("Updating Version files to CL: {0} CompatibleCL: {1}", CurrentChangeList, CompatibleChangeList);
UE4Build Build = new UE4Build(this);
Build.UpdateVersionFiles(ActuallyUpdateVersionFiles: true, ChangelistNumberOverride: CurrentChangeList, CompatibleChangelistNumberOverride: CompatibleChangeList, IsPromotedOverride: false);
}
return(ExitCode.Success);
}
public override ExitCode Execute()
{
BenchmarkOptions Options = new BenchmarkOptions();
Options.ParseParams(this.Params);
List <BenchmarkTaskBase> Tasks = new List <BenchmarkTaskBase>();
Dictionary <BenchmarkTaskBase, List <TimeSpan> > Results = new Dictionary <BenchmarkTaskBase, List <TimeSpan> >();
for (int ProjectIndex = 0; ProjectIndex < Options.ProjectsToTest.Count(); ProjectIndex++)
{
string Project = Options.ProjectsToTest.ElementAt(ProjectIndex);
FileReference ProjectFile = ProjectUtils.FindProjectFileFromName(Project);
if (ProjectFile == null && !Project.Equals("UE4", StringComparison.OrdinalIgnoreCase))
{
throw new AutomationException("Could not find project file for {0}", Project);
}
if (Options.DoBuildEditorTests)
{
Tasks.AddRange(AddBuildTests(ProjectFile, BuildHostPlatform.Current.Platform, "Editor", Options));
}
// do startup tests
if (Options.DoPIETests)
{
Tasks.AddRange(AddPIETests(ProjectFile, Options));
}
foreach (var ClientPlatform in Options.PlatformsToTest)
{
// build a client if the project supports it
string TargetName = ProjectSupportsClientBuild(ProjectFile) ? "Client" : "Game";
if (Options.DoBuildClientTests)
{
// do build tests
Tasks.AddRange(AddBuildTests(ProjectFile, ClientPlatform, TargetName, Options));
}
// do cook tests
if (Options.DoCookTests)
{
Tasks.AddRange(AddCookTests(ProjectFile, ClientPlatform, Options));
}
}
}
Log.TraceInformation("Will execute tests:");
foreach (var Task in Tasks)
{
Log.TraceInformation("{0}", Task.GetFullTaskName());
}
if (!Options.Preview)
{
// create results lists
foreach (var Task in Tasks)
{
Results.Add(Task, new List <TimeSpan>());
}
DateTime StartTime = DateTime.Now;
for (int i = 0; i < Options.Iterations; i++)
{
foreach (var Task in Tasks)
{
Log.TraceInformation("Starting task {0} (Pass {1})", Task.GetFullTaskName(), i + 1);
Task.Run();
Log.TraceInformation("Task {0} took {1}", Task.GetFullTaskName(), Task.TaskTime.ToString(@"hh\:mm\:ss"));
Results[Task].Add(Task.TaskTime);
// write results so far
WriteCSVResults(Options.FileName, Tasks, Results);
Log.TraceInformation("Waiting {0} secs until next task", Options.TimeBetweenTasks);
Thread.Sleep(Options.TimeBetweenTasks * 1000);
}
}
Log.TraceInformation("**********************************************************************");
Log.TraceInformation("Test Results:");
foreach (var Task in Tasks)
{
string TimeString = "";
IEnumerable <TimeSpan> TaskTimes = Results[Task];
foreach (var TaskTime in TaskTimes)
{
if (TimeString.Length > 0)
{
TimeString += ", ";
}
if (TaskTime == TimeSpan.Zero)
{
TimeString += "Failed";
}
else
{
TimeString += TaskTime.ToString(@"hh\:mm\:ss");
}
}
var AvgTimeString = "";
if (TaskTimes.Count() > 1)
{
var AvgTime = new TimeSpan(TaskTimes.Sum(T => T.Ticks) / TaskTimes.Count());
AvgTimeString = string.Format(" (Avg: {0})", AvgTime.ToString(@"hh\:mm\:ss"));
}
Log.TraceInformation("Task {0}:\t{1}{2}", Task.GetFullTaskName(), TimeString, AvgTimeString);
}
Log.TraceInformation("**********************************************************************");
TimeSpan Elapsed = DateTime.Now - StartTime;
Log.TraceInformation("Total benchmark time: {0}", Elapsed.ToString(@"hh\:mm\:ss"));
WriteCSVResults(Options.FileName, Tasks, Results);
}
return(ExitCode.Success);
}
protected bool FindProjectFileAndP4Path(string InProjectArgument, out FileReference OutProjectFile, out string OutP4ProjectPath)
{
OutProjectFile = null;
OutP4ProjectPath = null;
OutProjectFile = ProjectUtils.FindProjectFileFromName(InProjectArgument);
if (OutProjectFile != null)
{
// get the path in P4
P4WhereRecord Record = GetP4RecordForPath(OutProjectFile.FullName);
OutP4ProjectPath = Record.ClientFile;
}
else
{
// if they provided a name and not a path then find the file (requires that it's synced).
string RelativePath = InProjectArgument;
if (Path.GetExtension(RelativePath).Length == 0)
{
RelativePath = Path.ChangeExtension(RelativePath, "uproject");
}
if (!RelativePath.Contains(Path.DirectorySeparatorChar) && !RelativePath.Contains(Path.AltDirectorySeparatorChar))
{
RelativePath = CommandUtils.CombinePaths(PathSeparator.Slash, Path.GetFileNameWithoutExtension(RelativePath), RelativePath);
}
Log.TraceInformation("{0} not on disk. Searching P4 for {1}", InProjectArgument, RelativePath);
List <string> SearchPaths = new List <string>();
SearchPaths.Add("");
string ProjectDirsFile = Directory.EnumerateFiles(CommandUtils.CombinePaths(CmdEnv.LocalRoot), "*.uprojectdirs").FirstOrDefault();
if (ProjectDirsFile != null)
{
foreach (string FilePath in File.ReadAllLines(ProjectDirsFile))
{
string Trimmed = FilePath.Trim();
if (!Trimmed.StartsWith("./", StringComparison.OrdinalIgnoreCase) &&
!Trimmed.StartsWith(";", StringComparison.OrdinalIgnoreCase) &&
Trimmed.IndexOfAny(Path.GetInvalidPathChars()) < 0)
{
SearchPaths.Add(Trimmed);
}
}
}
// Get the root of the branch containing the selected file
foreach (string SearchPath in SearchPaths)
{
string P4Path = CommandUtils.CombinePaths(PathSeparator.Slash, P4Env.ClientRoot, SearchPath, RelativePath);
if (P4.FileExistsInDepot(P4Path))
{
P4WhereRecord Record = GetP4RecordForPath(P4Path);
// make sure to sync with //workspace/path as it cleans up files if the user has stream switched
OutP4ProjectPath = Record.ClientFile;
Log.TraceInformation("Found project at {0}", OutP4ProjectPath);
break;
}
}
}
Log.TraceVerbose("Resolved {0} to P4 Path {1}", InProjectArgument, OutP4ProjectPath);
return(OutP4ProjectPath != null && OutProjectFile != null);
}
