private static int ProgramExecutionResultHandler(ExternalProgramExecutor externalProgramExecutor, Options options, Guid executionId, string commandLineExecutionAsString)
{
try
{
int result;
if (externalProgramExecutor.ProcessWasAbortedDueToTimeout)
{
result = ExitCodeTimeout;
}
else
{
result = externalProgramExecutor.ExitCode;
}
WriteToFile(options.StdOutFile, externalProgramExecutor.AllStdOutLines);
WriteToFile(options.StdErrFile, externalProgramExecutor.AllStdErrLines);
WriteNumberToFile(options.Verbosity, executionId, _Title, commandLineExecutionAsString, result, "exit-code", options.ExitCodeFile);
return(result);
}
finally
{
externalProgramExecutor.Dispose();
}
}
internal static int Main(string[] args)
{
int exitCode = -1;
new Parser(settings => settings.CaseInsensitiveEnumValues = true).ParseArguments <Options>(args).WithParsed(options =>
{
string line = "--------------------------------------------------------------------";
string version = Assembly.GetExecutingAssembly().GetName().Version.ToString();
Guid executionId = Guid.NewGuid();
GRYLibrary.Core.Log.GRYLog log = GRYLibrary.Core.Log.GRYLog.Create();
log.Configuration.ResetToDefaultValues();
ExternalProgramExecutor externalProgramExecutor = null;
try
{
string argument;
if (options.ArgumentIsBase64Encoded)
{
argument = new UTF8Encoding(false).GetString(Convert.FromBase64String(options.Argument));
}
else
{
argument = options.Argument;
}
string commandLineExecutionAsString = $"'{options.Workingdirectory}>{options.Program} {argument}'";
string title;
string shortTitle;
if (string.IsNullOrWhiteSpace(options.Title))
{
title = nameof(ExternalProgramExecutor) + ": " + commandLineExecutionAsString;
shortTitle = string.Empty;
}
else
{
title = options.Title;
shortTitle = title;
}
TrySetTitle(title);
log.Configuration.Name = shortTitle;
if (options.LogFile != null)
{
log.Configuration.GetLogTarget <LogFile>().Enabled = true;
log.Configuration.GetLogTarget <LogFile>().File = options.LogFile;
}
if (options.AddLogOverhead)
{
log.Configuration.Format = GRYLibrary.Core.Log.GRYLogLogFormat.GRYLogFormat;
}
else
{
log.Configuration.Format = GRYLibrary.Core.Log.GRYLogLogFormat.OnlyMessage;
}
log.Configuration.SetEnabledOfAllLogTargets(options.Verbosity != Verbosity.Quiet);
if (options.Verbosity == Verbosity.Verbose)
{
foreach (GRYLibrary.Core.Log.GRYLogTarget target in log.Configuration.LogTargets)
{
log.Configuration.GetLogTarget <GRYLibrary.Core.Log.ConcreteLogTargets.Console>().LogLevels.Add(Microsoft.Extensions.Logging.LogLevel.Debug);
log.Configuration.GetLogTarget <GRYLibrary.Core.Log.ConcreteLogTargets.Console>().LogLevels.Add(Microsoft.Extensions.Logging.LogLevel.Debug);
}
}
string commandLineArguments = Utilities.GetCommandLineArguments();
log.Log(line, Microsoft.Extensions.Logging.LogLevel.Debug);
DateTime startTime = DateTime.Now;
string startTimeAsString = startTime.ToString(log.Configuration.DateFormat);
log.Log($"{nameof(ExternalProgramExecutor)} v{version} started at " + startTimeAsString, Microsoft.Extensions.Logging.LogLevel.Debug);
log.Log($"Execution-Id: {executionId}", Microsoft.Extensions.Logging.LogLevel.Debug);
log.Log($"Argument: '{commandLineArguments}'", Microsoft.Extensions.Logging.LogLevel.Debug);
log.Log($"Start executing {commandLineExecutionAsString}", Microsoft.Extensions.Logging.LogLevel.Debug);
externalProgramExecutor = ExternalProgramExecutor.CreateByGRYLog(options.Program, argument, log, options.Workingdirectory, shortTitle, options.PrintErrorsAsInformation, options.TimeoutInMilliseconds);
externalProgramExecutor.RunAsAdministrator = options.RunAsAdministrator;
externalProgramExecutor.ThrowErrorIfExitCodeIsNotZero = false;
exitCode = externalProgramExecutor.StartConsoleApplicationInCurrentConsoleWindow();
WriteToFile(options.StdOutFile, externalProgramExecutor.AllStdOutLines);
WriteToFile(options.StdErrFile, externalProgramExecutor.AllStdErrLines);
List <string> exitCodeFileContent = new List <string>();
if (options.Verbosity == Verbosity.Verbose)
{
exitCodeFileContent.Add($"{startTimeAsString}: Started {commandLineExecutionAsString} with exitcode");
}
exitCodeFileContent.Add(externalProgramExecutor.ExitCode.ToString());
WriteToFile(options.ExitCodeFile, exitCodeFileContent.ToArray());
}
catch (Exception exception)
{
log.Log("Error in " + nameof(ExternalProgramExecutor), exception);
}
if (externalProgramExecutor != null)
{
log.Log(nameof(ExternalProgramExecutor) + " finished", Microsoft.Extensions.Logging.LogLevel.Debug);
log.Log($"Execution-Id: {executionId}", Microsoft.Extensions.Logging.LogLevel.Debug);
if (externalProgramExecutor.ExecutionState == ExecutionState.Terminated)
{
log.Log($"Exit-code: {exitCode}", Microsoft.Extensions.Logging.LogLevel.Debug);
log.Log($"Duration: {Utilities.DurationToUserFriendlyString(externalProgramExecutor.ExecutionDuration)}", Microsoft.Extensions.Logging.LogLevel.Debug);
}
log.Log(line, Microsoft.Extensions.Logging.LogLevel.Debug);
}
});
return(exitCode);
}
private static string GetMessage(ExternalProgramExecutor externalProgramExecutor)
{
return($"'{externalProgramExecutor.Title}' had exitcode {externalProgramExecutor.ExitCode}.{Environment.NewLine}{Environment.NewLine}{externalProgramExecutor.GetSummaryOfExecutedProgram()}");
}
public UnexpectedExitCodeException(ExternalProgramExecutor externalProgramExecutor) : base(GetMessage(externalProgramExecutor))
{
this.ExecutedProgram = externalProgramExecutor;
}
private static int ProcessArguments(Options options, int initialExitCodeValue)
{
Guid executionId = Guid.NewGuid();
int result = initialExitCodeValue;
try
{
RemoveQuotes(options);
string argumentForExecution;
if (options.ArgumentIsBase64Encoded)
{
argumentForExecution = new UTF8Encoding(false).GetString(Convert.FromBase64String(options.Argument));
}
else
{
if (string.IsNullOrWhiteSpace(options.Argument))
{
argumentForExecution = string.Empty;
}
else
{
argumentForExecution = options.Argument;
}
}
string workingDirectory;
if (string.IsNullOrWhiteSpace(options.Workingdirectory))
{
workingDirectory = Directory.GetCurrentDirectory();
}
else
{
if (Directory.Exists(options.Workingdirectory))
{
workingDirectory = options.Workingdirectory;
}
else
{
throw new ArgumentException($"The specified workingdirectory '{options.Workingdirectory}' does not exist.");
}
}
if (string.IsNullOrWhiteSpace(options.Program))
{
throw new ArgumentException($"No program to execute specified.");
}
string commandLineExecutionAsString = $"'{workingDirectory}>{options.Program} {argumentForExecution}'";
if (string.IsNullOrWhiteSpace(options.Title))
{
_Title = $"{ProgramName}: {commandLineExecutionAsString}";
}
else
{
_Title = options.Title;
}
if (!string.IsNullOrWhiteSpace(options.LogFile))
{
_Log.Configuration.GetLogTarget <LogFile>().Enabled = true;
_Log.Configuration.GetLogTarget <LogFile>().File = options.LogFile;
}
foreach (GRYLogTarget target in _Log.Configuration.LogTargets)
{
target.Format = options.AddLogOverhead ? GRYLogLogFormat.GRYLogFormat : GRYLogLogFormat.OnlyMessage;
}
string commandLineArguments = Utilities.GetCommandLineArguments();
_ExternalProgramExecutor = new ExternalProgramExecutor(options.Program, argumentForExecution, workingDirectory)
{
LogObject = _Log,
LogNamespace = options.LogNamespace,
PrintErrorsAsInformation = options.PrintErrorsAsInformation,
TimeoutInMilliseconds = options.TimeoutInMilliseconds,
ThrowErrorIfExitCodeIsNotZero = false,
Verbosity = options.Verbosity
};
if (options.NotSynchronous)
{
_ExternalProgramExecutor.StartAsynchronously();
new Task(() =>
{
_ExternalProgramExecutor.WaitUntilTerminated();
ProgramExecutionResultHandler(_ExternalProgramExecutor, options, executionId, commandLineExecutionAsString);
}).Start();
result = _ExternalProgramExecutor.ProcessId;
}
else
{
_ExternalProgramExecutor.StartSynchronously();
result = ProgramExecutionResultHandler(_ExternalProgramExecutor, options, executionId, commandLineExecutionAsString);
}
WriteNumberToFile(options.Verbosity, executionId, _Title, commandLineExecutionAsString, _ExternalProgramExecutor.ProcessId, "process-id", options.ProcessIdFile);
}
catch (Exception exception)
{
_Log.Log($"Error in {ProgramName}.", exception);
}
return(result);
}
private int HandleSuccessfullyParsedArguments(EpewOptions options)
{
Guid executionId = Guid.NewGuid();
int result = ExitCodeNoProgramExecuted;
try
{
RemoveQuotes(options);
string argumentForExecution;
if (options.ArgumentIsBase64Encoded)
{
argumentForExecution = new UTF8Encoding(false).GetString(Convert.FromBase64String(options.Argument));
}
else
{
if (string.IsNullOrWhiteSpace(options.Argument))
{
argumentForExecution = string.Empty;
}
else
{
argumentForExecution = options.Argument;
}
}
string workingDirectory;
if (string.IsNullOrWhiteSpace(options.Workingdirectory))
{
workingDirectory = Directory.GetCurrentDirectory();
}
else
{
if (Directory.Exists(options.Workingdirectory))
{
workingDirectory = options.Workingdirectory;
}
else
{
throw new ArgumentException($"The specified workingdirectory '{options.Workingdirectory}' does not exist.");
}
}
if (string.IsNullOrWhiteSpace(options.Program))
{
throw new ArgumentException($"No program to execute specified.");
}
string commandLineExecutionAsString = $"'{workingDirectory}>{options.Program} {argumentForExecution}'";
if (string.IsNullOrWhiteSpace(options.Title))
{
_Title = $"{ProgramName}: {commandLineExecutionAsString}";
}
else
{
_Title = options.Title;
}
if (!string.IsNullOrWhiteSpace(options.LogFile))
{
_Log.Configuration.GetLogTarget <LogFile>().Enabled = true;
_Log.Configuration.GetLogTarget <LogFile>().File = options.LogFile;
}
foreach (GRYLogTarget target in _Log.Configuration.LogTargets)
{
target.Format = options.AddLogOverhead ? GRYLogLogFormat.GRYLogFormat : GRYLogLogFormat.OnlyMessage;
}
string commandLineArguments = Utilities.GetCommandLineArguments();
_ExternalProgramExecutor = new ExternalProgramExecutor(new ExternalProgramExecutorConfiguration()
{
Program = options.Program,
Argument = argumentForExecution,
WorkingDirectory = workingDirectory,
Verbosity = options.Verbosity,
User = options.User,
Password = options.Password,
});
_ExternalProgramExecutor.Run();
WriteNumberToFile(options.Verbosity, executionId, _Title, commandLineExecutionAsString, _ExternalProgramExecutor.ProcessId, "process-id", options.ProcessIdFile);
if (options.NotSynchronous)
{
return(2147393804);
}
else
{
new Task(() =>
{
_ExternalProgramExecutor.WaitUntilTerminated();
ProgramExecutionResultHandler(_ExternalProgramExecutor, options, executionId, commandLineExecutionAsString);
}).Start();
result = _ExternalProgramExecutor.ExitCode;
}
}
catch (Exception exception)
{
_Log.Log($"Error in {ProgramName}.", exception);
}
return(result);
}
