public static int Main()
{
var CommandLine = SharedUtils.ParseCommandLine();
LogUtils.InitLogging(CommandLine);
ExitCode ReturnCode = ExitCode.Success;
try
{
// ensure we can resolve any external assemblies as necessary.
AssemblyUtils.InstallAssemblyResolver(Path.GetDirectoryName(Assembly.GetEntryAssembly().GetOriginalLocation()));
HostPlatform.Initialize();
Log.TraceVerbose("{2}: Running on {0} as a {1}-bit process.", HostPlatform.Current.GetType().Name, Environment.Is64BitProcess ? 64 : 32, DateTime.UtcNow.ToString("o"));
XmlConfigLoader.Init();
// Log if we're running from the launcher
var ExecutingAssemblyLocation = Assembly.GetExecutingAssembly().Location;
if (string.Compare(ExecutingAssemblyLocation, Assembly.GetEntryAssembly().GetOriginalLocation(), StringComparison.OrdinalIgnoreCase) != 0)
{
Log.TraceVerbose("Executed from AutomationToolLauncher ({0})", ExecutingAssemblyLocation);
}
Log.TraceVerbose("CWD={0}", Environment.CurrentDirectory);
// Hook up exit callbacks
var Domain = AppDomain.CurrentDomain;
Domain.ProcessExit += Domain_ProcessExit;
Domain.DomainUnload += Domain_ProcessExit;
HostPlatform.Current.SetConsoleCtrlHandler(CtrlHandlerDelegateInstance);
var Version = AssemblyUtils.ExecutableVersion;
Log.TraceVerbose("{0} ver. {1}", Version.ProductName, Version.ProductVersion);
// Don't allow simultaneous execution of AT (in the same branch)
ReturnCode = InternalUtils.RunSingleInstance(MainProc, CommandLine);
}
catch (AutomationException Ex)
{
Log.TraceError("AutomationTool terminated with exception: {0}", Ex);
ReturnCode = Ex.ErrorCode;
}
catch (Exception Ex)
{
// Catch all exceptions and propagate the ErrorCode if we are given one.
Log.TraceError("AutomationTool terminated with exception: {0}", Ex);
ReturnCode = ExitCode.Error_Unknown;
}
finally
{
// In all cases, do necessary shut down stuff, but don't let any additional exceptions leak out while trying to shut down.
// Make sure there's no directories on the stack.
NoThrow(() => CommandUtils.ClearDirStack(), "Clear Dir Stack");
// Try to kill process before app domain exits to leave the other KillAll call to extreme edge cases
NoThrow(() => { if (ShouldKillProcesses && !Utils.IsRunningOnMono)
{
ProcessManager.KillAll();
}
}, "Kill All Processes");
Log.TraceInformation("AutomationTool exiting with ExitCode={0} ({1})", (int)ReturnCode, ReturnCode);
// Can't use NoThrow here because the code logs exceptions. We're shutting down logging!
LogUtils.ShutdownLogging();
}
// STOP: No code beyond the return statement should go beyond this point!
// Nothing should happen after the finally block above is finished.
return((int)ReturnCode);
}
public static int Main(string[] Arguments)
{
// Ensure UTF8Output flag is respected, since we are initializing logging early in the program.
if (CommandUtils.ParseParam(Arguments, "-Utf8output"))
{
Console.OutputEncoding = new System.Text.UTF8Encoding(false, false);
}
// Parse the log level argument
if (CommandUtils.ParseParam(Arguments, "-Verbose"))
{
Log.OutputLevel = LogEventType.Verbose;
}
if (CommandUtils.ParseParam(Arguments, "-VeryVerbose"))
{
Log.OutputLevel = LogEventType.VeryVerbose;
}
// Initialize the log system, buffering the output until we can create the log file
StartupTraceListener StartupListener = new StartupTraceListener();
Trace.Listeners.Add(StartupListener);
// Configure log timestamps
Log.IncludeTimestamps = CommandUtils.ParseParam(Arguments, "-Timestamps");
// Enter the main program section
ExitCode ReturnCode = ExitCode.Success;
try
{
// Set the working directory to the UE4 root
Environment.CurrentDirectory = Path.GetFullPath(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().GetOriginalLocation()), "..", "..", ".."));
// Ensure we can resolve any external assemblies as necessary.
string PathToBinariesDotNET = Path.GetDirectoryName(Assembly.GetEntryAssembly().GetOriginalLocation());
AssemblyUtils.InstallAssemblyResolver(PathToBinariesDotNET);
AssemblyUtils.InstallRecursiveAssemblyResolver(PathToBinariesDotNET);
// Initialize the host platform layer
HostPlatform.Initialize();
// Log the operating environment. Since we usually compile to AnyCPU, we may be executed using different system paths under WOW64.
Log.TraceVerbose("{2}: Running on {0} as a {1}-bit process.", HostPlatform.Current.GetType().Name, Environment.Is64BitProcess ? 64 : 32, DateTime.UtcNow.ToString("o"));
// Log if we're running from the launcher
string ExecutingAssemblyLocation = Assembly.GetExecutingAssembly().Location;
if (string.Compare(ExecutingAssemblyLocation, Assembly.GetEntryAssembly().GetOriginalLocation(), StringComparison.OrdinalIgnoreCase) != 0)
{
Log.TraceVerbose("Executed from AutomationToolLauncher ({0})", ExecutingAssemblyLocation);
}
Log.TraceVerbose("CWD={0}", Environment.CurrentDirectory);
// Hook up exit callbacks
AppDomain Domain = AppDomain.CurrentDomain;
Domain.ProcessExit += Domain_ProcessExit;
Domain.DomainUnload += Domain_ProcessExit;
HostPlatform.Current.SetConsoleCtrlHandler(CtrlHandlerDelegateInstance);
// Log the application version
FileVersionInfo Version = AssemblyUtils.ExecutableVersion;
Log.TraceVerbose("{0} ver. {1}", Version.ProductName, Version.ProductVersion);
// Don't allow simultaneous execution of AT (in the same branch)
ReturnCode = InternalUtils.RunSingleInstance(() => MainProc(Arguments, StartupListener));
}
catch (AutomationException Ex)
{
// Output the message in the desired format
if (Ex.OutputFormat == AutomationExceptionOutputFormat.Silent)
{
Log.TraceLog("{0}", ExceptionUtils.FormatExceptionDetails(Ex));
}
else if (Ex.OutputFormat == AutomationExceptionOutputFormat.Minimal)
{
Log.TraceInformation("{0}", Ex.ToString().Replace("\n", "\n "));
Log.TraceLog("{0}", ExceptionUtils.FormatExceptionDetails(Ex));
}
else
{
Log.WriteException(Ex, LogUtils.FinalLogFileName);
}
// Take the exit code from the exception
ReturnCode = Ex.ErrorCode;
}
catch (Exception Ex)
{
// Use a default exit code
Log.WriteException(Ex, LogUtils.FinalLogFileName);
ReturnCode = ExitCode.Error_Unknown;
}
finally
{
// In all cases, do necessary shut down stuff, but don't let any additional exceptions leak out while trying to shut down.
// Make sure there's no directories on the stack.
NoThrow(() => CommandUtils.ClearDirStack(), "Clear Dir Stack");
// Try to kill process before app domain exits to leave the other KillAll call to extreme edge cases
NoThrow(() => { if (ShouldKillProcesses && !Utils.IsRunningOnMono)
{
ProcessManager.KillAll();
}
}, "Kill All Processes");
// Write the exit code
Log.TraceInformation("AutomationTool exiting with ExitCode={0} ({1})", (int)ReturnCode, ReturnCode);
// Can't use NoThrow here because the code logs exceptions. We're shutting down logging!
Trace.Close();
}
return((int)ReturnCode);
}
/// <summary>
/// Constructor. Derives the Perforce environment settings.
/// </summary>
internal P4Environment(CommandEnvironment CmdEnv)
{
// Get the Perforce port setting
ServerAndPort = CommandUtils.GetEnvVar(EnvVarNames.P4Port);
if (String.IsNullOrEmpty(ServerAndPort))
{
ServerAndPort = DetectP4Port();
CommandUtils.SetEnvVar(EnvVarNames.P4Port, ServerAndPort);
}
// Get the Perforce user setting
User = CommandUtils.GetEnvVar(EnvVarNames.User);
if (String.IsNullOrEmpty(User))
{
P4Connection DefaultConnection = new P4Connection(User: null, Client: null, ServerAndPort: ServerAndPort);
User = DetectUserName(DefaultConnection);
CommandUtils.SetEnvVar(EnvVarNames.User, User);
}
// Get the Perforce client setting
Client = CommandUtils.GetEnvVar(EnvVarNames.Client);
if (String.IsNullOrEmpty(Client))
{
P4Connection DefaultConnection = new P4Connection(User: User, Client: null, ServerAndPort: ServerAndPort);
P4ClientInfo ThisClient = DetectClient(DefaultConnection, User, Environment.MachineName.ToLower(), CmdEnv.UATExe);
Log.TraceInformation("Using user {0} clientspec {1} {2}", User, ThisClient.Name, ThisClient.RootPath);
string BranchPath;
string ClientRootPath;
P4Connection ClientConnection = new P4Connection(User: User, Client: ThisClient.Name, ServerAndPort: ServerAndPort);
DetectRootPaths(ClientConnection, CmdEnv.LocalRoot, ThisClient, out BranchPath, out ClientRootPath);
Client = ThisClient.Name;
CommandUtils.SetEnvVar(EnvVarNames.Client, Client);
Branch = BranchPath;
CommandUtils.SetEnvVar(EnvVarNames.BuildRootP4, Branch);
ClientRoot = ClientRootPath;
CommandUtils.SetEnvVar(EnvVarNames.ClientRoot, ClientRootPath);
}
else
{
Branch = CommandUtils.GetEnvVar(EnvVarNames.BuildRootP4);
ClientRoot = CommandUtils.GetEnvVar(EnvVarNames.ClientRoot);
if (String.IsNullOrEmpty(Branch) || String.IsNullOrEmpty(ClientRoot))
{
throw new AutomationException("{0} and {1} must also be set with {2}", EnvVarNames.ClientRoot, EnvVarNames.BuildRootP4, EnvVarNames.Client);
}
}
// We expect the build root to not end with a path separator
if (Branch.EndsWith("/"))
{
Branch = Branch.TrimEnd('/');
CommandUtils.SetEnvVar(EnvVarNames.BuildRootP4, Branch);
}
// Set the current changelist
string ChangelistString = CommandUtils.GetEnvVar(EnvVarNames.Changelist, null);
if (String.IsNullOrEmpty(ChangelistString) && CommandUtils.P4CLRequired)
{
P4Connection Connection = new P4Connection(User, Client, ServerAndPort);
ChangelistString = DetectCurrentCL(Connection, ClientRoot);
CommandUtils.SetEnvVar(EnvVarNames.Changelist, ChangelistString);
}
if (!String.IsNullOrEmpty(ChangelistString))
{
Changelist = int.Parse(ChangelistString);
}
// Set the current code changelist
string CodeChangelistString = CommandUtils.GetEnvVar(EnvVarNames.CodeChangelist);
if (String.IsNullOrEmpty(CodeChangelistString) && CommandUtils.P4CLRequired)
{
P4Connection Connection = new P4Connection(User, Client, ServerAndPort);
CodeChangelistString = DetectCurrentCodeCL(Connection, ClientRoot);
CommandUtils.SetEnvVar(EnvVarNames.CodeChangelist, CodeChangelistString);
}
if (!String.IsNullOrEmpty(CodeChangelistString))
{
CodeChangelist = int.Parse(CodeChangelistString);
}
// Set the standard environment variables based on the values we've found
CommandUtils.SetEnvVar("P4PORT", ServerAndPort);
CommandUtils.SetEnvVar("P4USER", User);
CommandUtils.SetEnvVar("P4CLIENT", Client);
// Write a summary of the settings to the output window
if (!CommandUtils.CmdEnv.IsChildInstance)
{
Log.TraceInformation("Detected Perforce Settings:");
Log.TraceInformation(" Server: {0}", ServerAndPort);
Log.TraceInformation(" User: {0}", User);
Log.TraceInformation(" Client: {0}", Client);
Log.TraceInformation(" Branch: {0}", Branch);
if (ChangelistInternal != -1)
{
Log.TraceInformation(" Last Change: {0}", Changelist);
}
if (CodeChangelistInternal != -1)
{
Log.TraceInformation(" Last Code Change: {0}", CodeChangelist);
}
}
// Write all the environment variables to the log
Log.TraceLog("Perforce Environment Variables:");
Log.TraceLog(" {0}={1}", EnvVarNames.P4Port, InternalUtils.GetEnvironmentVariable(EnvVarNames.P4Port, "", true));
Log.TraceLog(" {0}={1}", EnvVarNames.User, InternalUtils.GetEnvironmentVariable(EnvVarNames.User, "", true));
Log.TraceLog(" {0}={1}", EnvVarNames.Client, InternalUtils.GetEnvironmentVariable(EnvVarNames.Client, "", true));
Log.TraceLog(" {0}={1}", EnvVarNames.BuildRootP4, InternalUtils.GetEnvironmentVariable(EnvVarNames.BuildRootP4, "", true));
Log.TraceLog(" {0}={1}", EnvVarNames.BuildRootEscaped, InternalUtils.GetEnvironmentVariable(EnvVarNames.BuildRootEscaped, "", true));
Log.TraceLog(" {0}={1}", EnvVarNames.ClientRoot, InternalUtils.GetEnvironmentVariable(EnvVarNames.ClientRoot, "", true));
Log.TraceLog(" {0}={1}", EnvVarNames.Changelist, InternalUtils.GetEnvironmentVariable(EnvVarNames.Changelist, "", true));
Log.TraceLog(" {0}={1}", EnvVarNames.CodeChangelist, InternalUtils.GetEnvironmentVariable(EnvVarNames.CodeChangelist, "", true));
Log.TraceLog(" {0}={1}", "P4PORT", InternalUtils.GetEnvironmentVariable("P4PORT", "", true));
Log.TraceLog(" {0}={1}", "P4USER", InternalUtils.GetEnvironmentVariable("P4USER", "", true));
Log.TraceLog(" {0}={1}", "P4CLIENT", InternalUtils.GetEnvironmentVariable("P4CLIENT", "", true));
}
public static int Main()
{
var CommandLine = SharedUtils.ParseCommandLine();
HostPlatform.Initialize();
LogUtils.InitLogging(CommandLine);
Log.WriteLine(TraceEventType.Information, "Running on {0}", HostPlatform.Current.GetType().Name);
XmlConfigLoader.Init();
// Log if we're running from the launcher
var ExecutingAssemblyLocation = CommandUtils.CombinePaths(Assembly.GetExecutingAssembly().Location);
if (String.Compare(ExecutingAssemblyLocation, CommandUtils.CombinePaths(InternalUtils.ExecutingAssemblyLocation), true) != 0)
{
Log.WriteLine(TraceEventType.Information, "Executed from AutomationToolLauncher ({0})", ExecutingAssemblyLocation);
}
Log.WriteLine(TraceEventType.Information, "CWD={0}", Environment.CurrentDirectory);
// Hook up exit callbacks
var Domain = AppDomain.CurrentDomain;
Domain.ProcessExit += Domain_ProcessExit;
Domain.DomainUnload += Domain_ProcessExit;
HostPlatform.Current.SetConsoleCtrlHandler(ProgramCtrlHandler);
var Version = InternalUtils.ExecutableVersion;
Log.WriteLine(TraceEventType.Verbose, "{0} ver. {1}", Version.ProductName, Version.ProductVersion);
try
{
// Don't allow simultaneous execution of AT (in the same branch)
ReturnCode = InternalUtils.RunSingleInstance(MainProc, CommandLine);
}
catch (Exception Ex)
{
Log.WriteLine(TraceEventType.Error, "AutomationTool terminated with exception:");
Log.WriteLine(TraceEventType.Error, LogUtils.FormatException(Ex));
Log.WriteLine(TraceEventType.Error, Ex.Message);
if (ReturnCode == 0)
{
ReturnCode = (int)ErrorCodes.Error_Unknown;
}
}
// Make sure there's no directiories on the stack.
CommandUtils.ClearDirStack();
Environment.ExitCode = ReturnCode;
// Try to kill process before app domain exits to leave the other KillAll call to extreme edge cases
if (ShouldKillProcesses)
{
ProcessManager.KillAll();
}
Log.WriteLine(TraceEventType.Information, "AutomationTool exiting with ExitCode={0}", ReturnCode);
LogUtils.CloseFileLogging();
return(ReturnCode);
}