private static void ExecuteConsoleCommands(JobsGroupDto cmdJobs, ConsoleExecutorDto cmdExeDto)
{
try
{
var mgr = new CommandExecutionMgr(cmdJobs,cmdExeDto);
mgr.ExecuteCommands();
}
catch(Exception ex)
{
var err = new FileOpsErrorMessageDto
{
DirectoryPath = string.Empty,
ErrId = 345,
ErrorMessage = "Command Job Execution Failed!",
ErrSourceMethod = "ExecuteConsoleCommands()",
ErrException = ex,
FileName = string.Empty,
LoggerLevel = LogLevel.FATAL
};
Environment.ExitCode = -4;
_errorMgr.LoggingStatus = ErrorLoggingStatus.On;
_errorMgr.WriteErrorMsg(err);
cmdExeDto.ApplicationExitStatus.OpsError = _errorMgr.FormatErrorDto(err);
cmdExeDto.ApplicationExitStatus.IsExceptionThrown = true;
cmdExeDto.ApplicationExitStatus.WriteExitConsoleMessage();
}
}
public void ExtractElementInfo(XmlTextReader reader,
ref ConsoleCommandDto consoleCommand,
ref ConsoleExecutorDto cmdExeDto)
{
if (reader.Name == "DefaultLogFileRetentionInDays")
{
cmdExeDto.AppLogRetentionInDays = _xmlHlpr.ExtractIntValue(reader, -1);
return;
}
if (reader.Name == "DefaultCommandExeDirectory")
{
var dir = _xmlHlpr.ExtractStringValue(reader);
cmdExeDto.SetDefaultCommandExeDirectory(dir);
return;
}
if (reader.Name == "DefaultCommandOutputLogFilePathName")
{
var filePath = _xmlHlpr.ExtractStringValue(reader);
cmdExeDto.SetDefaultCommandOutputLogFilePathName(filePath);
}
}
public XmlParameterBuilder(ConsoleExecutorDto cmdExeDto)
{
if (cmdExeDto?.XmlCmdFileDto?.FileXinfo == null || !cmdExeDto.XmlCmdFileDto.FileXinfo.Exists)
{
var err = new FileOpsErrorMessageDto
{
DirectoryPath = String.Empty,
ErrId = 1,
ErrorMessage = "Xml Command File is Invalid!",
ErrSourceMethod = "Constructor()",
FileName = string.Empty,
LoggerLevel = LogLevel.FATAL
};
ErrorMgr.LoggingStatus = ErrorLoggingStatus.On;
ErrorMgr.WriteErrorMsg(err);
throw new ArgumentException("Invalid Xml Command File!");
}
try
{
_xmlReader = new XmlTextReader(cmdExeDto.XmlCmdFileDto.FileXinfo.FullName);
}
catch (Exception e)
{
var err = new FileOpsErrorMessageDto
{
DirectoryPath = String.Empty,
ErrId = 1,
ErrorMessage = "Xml Command File threw exception while opening!",
ErrSourceMethod = "Constructor()",
ErrException = e,
FileName = string.Empty,
LoggerLevel = LogLevel.FATAL
};
ErrorMgr.LoggingStatus = ErrorLoggingStatus.On;
ErrorMgr.WriteErrorMsg(err);
throw new ArgumentException("Xml Command File Failed To Open!");
}
_jobsGroupDto = new JobsGroupDto(cmdExeDto.XmlCmdFileDto.FileXinfo.Name + " Commands");
_cmdExeDto = cmdExeDto;
}
public CommandExecutionMgr(JobsGroupDto jobsGroup,
ConsoleExecutorDto consoleCmdDto)
{
_commandJobs = jobsGroup;
_consoleExecutor = consoleCmdDto;
_cmdLogMgr = new ConsoleCommandLogMgr(consoleCmdDto.DefaultCommandOutputLogFilePathName,
consoleCmdDto.CmdConsoleLogFileTimeStamp,
string.Empty);
_errLogMgr = new ConsoleCommandLogMgr(consoleCmdDto.DefaultCommandOutputLogFilePathName,
consoleCmdDto.CmdConsoleLogFileTimeStamp,
consoleCmdDto.CmdConsoleLogFileErrorSuffix);
_wrkDirMgr = new WorkingDirectoryMgr(_consoleExecutor.DefaultCommandExeDirectoryDto);
}
private static void AppShutdownAndCleanUp(JobsGroupDto jobs, ConsoleExecutorDto cmdExeDto)
{
try
{
LogUtil.WriteLogJobGroupCompletionMessage(jobs);
}
// ReSharper disable once EmptyGeneralCatchClause
catch
{
}
finally
{
jobs?.Dispose();
cmdExeDto?.ApplicationExitStatus.WriteExitConsoleMessage();
cmdExeDto?.Dispose();
}
}
public void ShouldExecuteCommandsCorrectly()
{
var exeDir = TestDirectories.GetTestExeDir();
var logDir = new DirectoryDto(exeDir.DirInfo.FullName + "\\logdir");
DirectoryHelper.DeleteADirectory(logDir);
var dirT3 = TestDirectories.GetTestDirectory003();
FileHelper.DeleteAllFilesInDirectoryTree(dirT3);
var consoleExeDto = new ConsoleExecutorDto
{
DefaultConsoleCommandExecutor = TestDirectories.GetConsoleCommandExecutor(),
DefaultConsoleCommandExeArgs = TestDirectories.GetConsoleCommandExeArguments(),
CmdConsoleLogFileErrorSuffix = "Error",
CmdConsoleLogFileTimeStamp = DateHelper.NowYearMthDayHrsSecs(),
CommandDefaultTimeOutInMinutes = 5.0M,
CommandMaxTimeOutInMinutes = 45.0M,
CommandMinTimeOutInMinutes = 1.0M,
DefaultCommandOutputLogFilePathName = ".\\logdir\\installLog.log",
XmlCmdFileDto = TestDirectories.GetXmlCmdTest002FileDto(),
DefaultConsoleCommandType = ConsoleCommandType.Console
};
var jobs = TestDirectories.GetTestJobGroup();
var cmdExeMgr = new CommandExecutionMgr(jobs,consoleExeDto);
var result = cmdExeMgr.ExecuteCommands();
Assert.IsTrue(result);
var files = dirT3.DirInfo.GetFiles();
FileHelper.DeleteAllFilesInDirectoryTree(dirT3);
Assert.IsTrue(files.Length == 4);
}
public void ExtractElementInfo(XmlTextReader reader,
ref ConsoleCommandDto consoleCommand,
ref ConsoleExecutorDto cmdExeDto)
{
var parmHlpr = new XmlParameterConverter(cmdExeDto);
if (reader.Name == "CommandDisplayName")
{
consoleCommand.CommandDisplayName = _xmlHlpr.ExtractStringValue(reader);
return;
}
if (reader.Name == "ConsoleCommandType")
{
consoleCommand.CommandType = _xmlHlpr.ExtractConsoleCommandType(reader);
return;
}
if (reader.Name == "KillJobsRunOnExitCodeGreaterThan")
{
var userEntry = _xmlHlpr.ExtractStringValue(reader);
int exitCodeLimit;
if (string.IsNullOrWhiteSpace(userEntry) || !int.TryParse(userEntry, out exitCodeLimit))
{
return;
}
consoleCommand.KillJobsRunOnExitCodeGreaterThan = exitCodeLimit;
return;
}
if (reader.Name == "KillJobsRunOnExitCodeLessThan")
{
var userEntry = _xmlHlpr.ExtractStringValue(reader);
int exitCodeLimit;
if (string.IsNullOrWhiteSpace(userEntry) || !int.TryParse(userEntry, out exitCodeLimit))
{
return;
}
consoleCommand.KillJobsRunOnExitCodeLessThan = exitCodeLimit;
return;
}
if (reader.Name == "CommandOutputLogFilePathBaseName")
{
consoleCommand.CommandOutputLogFilePathBaseName = _xmlHlpr.ExtractStringValue(reader);
return;
}
if (reader.Name == "CommandTimeOutInMinutes")
{
consoleCommand.CommandTimeOutInMinutes = _xmlHlpr.ExtractDecimalValue(reader, 0.0M);
return;
}
if (reader.Name == "DefaultConsoleCommandExecutor")
{
consoleCommand.ConsoleCommandExecutor = parmHlpr.RunConversion(_xmlHlpr.ExtractStringValue(reader));
return;
}
if (reader.Name == "ConsoleCommandExeArguments")
{
consoleCommand.ConsoleCommandExeArguments = parmHlpr.RunConversion(_xmlHlpr.ExtractStringValue(reader));
return;
}
if (reader.Name == "ExecuteInDir")
{
consoleCommand.ExecuteInDir = _xmlHlpr.ExtractStringValue(reader);
return;
}
if (reader.Name == "ExecutableTarget")
{
consoleCommand.ExecutableTarget = parmHlpr.RunConversion(_xmlHlpr.ExtractStringValue(reader));
return;
}
if (reader.Name == "CommandToExecute")
{
consoleCommand.CommandToExecute = parmHlpr.RunConversion(_xmlHlpr.ExtractStringValue(reader));
return;
}
if (reader.Name == "CommandModifier")
{
consoleCommand.CommandModifier = parmHlpr.RunConversion(_xmlHlpr.ExtractStringValue(reader));
return;
}
if (reader.Name == "CommandArguments")
{
consoleCommand.CommandArguments = parmHlpr.RunConversion(_xmlHlpr.ExtractStringValue(reader));
}
}
public XmlParameterConverter(ConsoleExecutorDto cmDto)
{
_xmlParms[0, 1] = cmDto.CmdConsoleLogFileTimeStamp;
}
public static void WriteLogJobStartUpMessage(ConsoleCommandDto job, ConsoleExecutorDto consoleExecutor)
{
if (!IsLoggerConfigured)
{
return;
}
var jobName = job.CommandDisplayName;
JobNumber = job.JobNumber;
CurrentJobNo = "Starting Job No: " + JobNumber;
if(!string.IsNullOrEmpty(jobName))
{
CurrentJobName = "Job Name: " + jobName;
}
else
{
CurrentJobName = string.Empty;
}
IsFirstJobLogMsg = false;
IsAnyLoggingActive = true;
var banner = StringHelper.MakeSingleCharString('=', MaxBannerLen);
var subbanner = StringHelper.MakeSingleCharString('-', MaxBannerLen);
var now = job.CommandStartTime;
var sb = new StringBuilder();
sb.Append(NewLine);
sb.Append(banner + NewLine);
sb.Append(banner + NewLine);
var s = "CmdrX Assembly Version " + ExeAssemblyVersionNo;
var cStr = StringHelper.CenterString(s, banner.Length);
sb.Append(cStr);
sb.Append(NewLine);
cStr = StringHelper.CenterString(CurrentJobNo, banner.Length);
sb.Append(cStr);
sb.Append(NewLine);
sb.Append(subbanner);
sb.Append(NewLine);
if(!string.IsNullOrWhiteSpace(CurrentJobName))
{
cStr = StringHelper.CenterString(CurrentJobName, banner.Length);
sb.Append(cStr);
sb.Append(NewLine);
}
sb.Append($"Started Job: {now.ToLongDateString()} {now.ToLongTimeString()}" + NewLine);
sb.Append(subbanner);
sb.Append(NewLine);
sb.Append("Process StartInfo FileName: " + job.ProcFileNameCommand);
sb.Append(NewLine);
var args = StringHelper.BreakLineAtIndex(StringHelper.RemoveCarriageReturns(job.ProcFileArguments), 65);
sb.Append("Process StartInfo Arguments: ");
if (args.Length > 0)
{
sb.Append(NewLine);
for (int i = 0; i < args.Length; i++)
{
sb.Append(" " + args[i] + NewLine);
}
}
else
{
sb.Append("<NO ARGUMENTS>" + NewLine);
}
sb.Append(subbanner + NewLine);
WriteLog(LogLevel.MESSAGE, sb.ToString());
}
public static void WriteLogJobEndMessage(ConsoleCommandDto job, ConsoleExecutorDto consoleExecutor)
{
if (!IsLoggerConfigured)
{
return;
}
var banner = StringHelper.MakeSingleCharString('=', MaxBannerLen);
var subbanner = StringHelper.MakeSingleCharString('-', MaxBannerLen);
var startTime = job.CommandStartTime;
var endTime = job.CommandExitTime;
var ts = job.CommandElapsedTime;
var sb = new StringBuilder();
sb.Append(NewLine);
sb.Append(NewLine);
sb.Append(subbanner + NewLine);
var cStr = StringHelper.CenterString("Job Completed: " + job.CommandDisplayName, banner.Length);
sb.Append(cStr);
sb.Append(NewLine);
sb.Append(subbanner + NewLine);
sb.Append("Job Number: " + job.JobNumber + NewLine);
sb.Append("Job Start Time: " + DateHelper.DateTimeToDayMilliseconds(startTime) + NewLine);
sb.Append("Job End Time: " + DateHelper.DateTimeToDayMilliseconds(endTime) + NewLine);
sb.Append("Job Elapsed Time: " + DateHelper.TimeSpanDetailToMiliseconds(ts) + NewLine);
sb.Append("Job Exit Code: " + job.CommandExitCode + NewLine);
sb.Append(banner);
sb.Append(NewLine);
sb.Append(banner);
sb.Append(NewLine);
WriteLog(LogLevel.MESSAGE, sb.ToString());
_logger.LogFlushStreamWriter();
}
public CommandLineParameterBuilder(ConsoleExecutorDto cmdExeDto)
{
_cmdExeDto = cmdExeDto;
}
static void Main(string[] args)
{
_errorMgr = new
ErrorLogger(1000,
"Program",
AppConstants.LoggingStatus,
AppConstants.LoggingMode,
false);
AppConstants.LoggingStatus = ErrorLoggingStatus.On;
AppConstants.LoggingMode = ErrorLoggingMode.Verbose;
JobsGroupDto cmdJobs = null;
var nowTimeStamp = DateHelper.NowYearMthDayHrsSecs();
var cmdExeDto = new ConsoleExecutorDto()
{ AppLogFileBaseNameOnly =
PathHelper.ExtractFileNameOnlyComponent(AppConstants.AppLogFileNameExtension),
AppLogFileExtensionWithoutLeadingDot =
PathHelper.ExtractFileExtensionComponentWithoutLeadingDot(AppConstants.AppLogFileNameExtension),
AppLogDirectory = PathHelper.ExtractDirectoryComponent(AppConstants.DefaultCommandOutputLogFilePathName),
AppLogFileTimeStamp = nowTimeStamp,
DefaultConsoleCommandExecutor = AppConstants.DefaultConsoleCommandExecutor,
DefaultConsoleCommandExeArgs = AppConstants.DefaultConsoleCommandExeArgs,
CmdConsoleLogFileErrorSuffix = AppConstants.ConsoleErrorLogFileNameSuffix,
CmdConsoleLogFileTimeStamp = nowTimeStamp,
CommandDefaultTimeOutInMinutes = AppConstants.CommandDefaultTimeOutInMinutes,
CommandMaxTimeOutInMinutes = AppConstants.CommandMaxTimeOutInMinutes,
CommandMinTimeOutInMinutes = AppConstants.CommandMinTimeOutInMinutes,
DefaultKillJobsRunOnExitCodeGreaterThan = AppConstants.DefaultKillJobsRunOnExitCodeGreaterThan,
DefaultKillJobsRunOnExitCodeLessThan = AppConstants.DefaultKillJobsRunOnExitCodeLessThan,
DefaultCommandOutputLogFilePathName = AppConstants.DefaultCommandOutputLogFilePathName,
XmlCmdFileDto = AppInfoHelper.GetDefaultXmlCommandFile(),
DefaultConsoleCommandType = AppConstants.DefaultConsoleCommandType
};
try
{
if (!ProcessCmdArgs(cmdExeDto, args))
{
}
if (!ValidateXmlCommandFile(cmdExeDto))
{
return;
}
if (!ParseCommandJobsFromXml(cmdExeDto, out cmdJobs))
{
return;
}
if (!SetUpLogging(cmdExeDto, cmdJobs))
{
return;
}
}
catch(Exception ex)
{
if (Environment.ExitCode == 0)
{
Environment.ExitCode = -50;
}
var err = new FileOpsErrorMessageDto
{
DirectoryPath = string.Empty,
ErrId = 10,
ErrorMessage = "Exception Thrown On Setup",
ErrSourceMethod = "Main()",
ErrException = ex,
FileName = string.Empty,
LoggerLevel = LogLevel.FATAL
};
cmdExeDto.ApplicationExitStatus.IsExceptionThrown = true;
cmdExeDto.ApplicationExitStatus.OpsError = _errorMgr.FormatErrorDto(err);
cmdExeDto.ApplicationExitStatus.WriteExitConsoleMessage();
return;
}
try
{
ExecuteConsoleCommands(cmdJobs, cmdExeDto);
}
catch (Exception ex)
{
if (Environment.ExitCode == 0)
{
Environment.ExitCode = -50;
}
var err = new FileOpsErrorMessageDto
{
DirectoryPath = string.Empty,
ErrId = 150,
ErrorMessage = "Command Execution Exception Thrown: ",
ErrSourceMethod = "SetUpLogging()",
ErrException = ex,
FileName = string.Empty,
LoggerLevel = LogLevel.ERROR
};
cmdExeDto.ApplicationExitStatus.IsExceptionThrown = true;
cmdExeDto.ApplicationExitStatus.OpsError = _errorMgr.FormatErrorDto(err);
}
finally
{
AppShutdownAndCleanUp(cmdJobs, cmdExeDto);
}
}
private static bool ValidateXmlCommandFile(ConsoleExecutorDto cmdExeDto)
{
if (!FileHelper.DoesFileExist(cmdExeDto.XmlCmdFileDto))
{
var err = new FileOpsErrorMessageDto
{
DirectoryPath = string.Empty,
ErrId = 3,
ErrorMessage = "Could Not Locate a valid Xml Commands file!",
ErrSourceMethod = "ValidateXmlCommandFile()",
FileName = string.Empty,
LoggerLevel = LogLevel.FATAL
};
cmdExeDto.ApplicationExitStatus.IsFatalError = true;
cmdExeDto.ApplicationExitStatus.OpsError = _errorMgr.FormatErrorDto(err);
Environment.ExitCode = -5;
cmdExeDto.ApplicationExitStatus.WriteExitConsoleMessage();
return false;
}
return true;
}
private static bool SetUpLogging(ConsoleExecutorDto cmdExeDto, JobsGroupDto jobsGroup)
{
try
{
// Setup Application Logging
cmdExeDto.AppLogMgr.PurgeOldLogFiles();
LogUtil.ConfigureLogger(cmdExeDto.AppLogMgr.ConfigureLogger());
_errorMgr.IsLoggingConfigured = true;
LogUtil.ExeAssemblyVersionNo = AppInfoHelper.GetThisAssemblyVersion();
LogUtil.WriteLogJobGroupStartUpMessage(jobsGroup);
cmdExeDto.ErrorMgr.IsLoggingConfigured = true;
}
catch (Exception ex)
{
Environment.ExitCode = -2;
var err = new FileOpsErrorMessageDto
{
DirectoryPath = string.Empty,
ErrId = 10,
ErrorMessage = "Application Log Setup Failure!",
ErrSourceMethod = "SetUpLogging()",
ErrException = ex,
FileName = string.Empty,
LoggerLevel = LogLevel.ERROR
};
cmdExeDto.ApplicationExitStatus.IsExceptionThrown = true;
cmdExeDto.ApplicationExitStatus.OpsError = _errorMgr.FormatErrorDto(err);
cmdExeDto.ApplicationExitStatus.WriteExitConsoleMessage();
return false;
}
return true;
}
private static bool ProcessCmdArgs(ConsoleExecutorDto cmdExeDto, string[] args)
{
if (args == null || args.Length < 1)
{
return true;
}
var cmdLineParser = new CommandLineParameterBuilder(cmdExeDto);
if (!cmdLineParser.BuildFileInfoParamters(args))
{
return false;
}
return true;
}
private static bool ParseCommandJobsFromXml(ConsoleExecutorDto cmdExeDto, out JobsGroupDto jobsGroupDto)
{
jobsGroupDto = null;
try
{
var xmlParser = new XmlParameterBuilder(cmdExeDto);
jobsGroupDto = xmlParser.BuildParmsFromXml();
if (jobsGroupDto == null || jobsGroupDto.NumberOfJobs < 1)
{
var err = new FileOpsErrorMessageDto
{
DirectoryPath = string.Empty,
ErrId = 35,
ErrorMessage = "Zero jobs were extracted from the XmlCommands file!",
ErrSourceMethod = "ParseCommandJobsFromXml()",
FileName = string.Empty,
LoggerLevel = LogLevel.FATAL
};
cmdExeDto.ApplicationExitStatus.OpsError = _errorMgr.FormatErrorDto(err);
cmdExeDto.ApplicationExitStatus.IsTerminateApp = true;
cmdExeDto.ApplicationExitStatus.WriteExitConsoleMessage();
Environment.ExitCode = -3;
return false;
}
}
catch(Exception ex)
{
var err = new FileOpsErrorMessageDto
{
DirectoryPath = string.Empty,
ErrId = 137,
ErrorMessage = ex.Message,
ErrSourceMethod = "ParseCommandJobsFromXml()",
ErrException = ex,
FileName = string.Empty,
LoggerLevel = LogLevel.FATAL
};
_errorMgr.LoggingStatus = ErrorLoggingStatus.On;
_errorMgr.WriteErrorMsg(err);
Environment.ExitCode = -3;
cmdExeDto.ApplicationExitStatus.OpsError = _errorMgr.FormatErrorDto(err);
cmdExeDto.ApplicationExitStatus.IsExceptionThrown = true;
cmdExeDto.ApplicationExitStatus.WriteExitConsoleMessage();
return false;
}
return true;
}
