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 static bool ChangeToNewCurrentDirectory(DirectoryDto targetDirDto)
{
if (targetDirDto?.DirInfo == null)
{
return false;
}
try
{
Directory.SetCurrentDirectory(targetDirDto.DirInfo.FullName);
}
catch (Exception ex)
{
var err = new FileOpsErrorMessageDto
{
DirectoryPath = String.Empty,
ErrId = 4,
ErrorMessage = "Directory Deletion Failed!",
ErrSourceMethod = "ChangeToNewCurrentDirectory()",
ErrException = ex,
FileName = "Target Dir: " + targetDirDto.DirInfo.FullName,
LoggerLevel = LogLevel.FATAL
};
ErrorMgr.LoggingStatus = ErrorLoggingStatus.On;
ErrorMgr.WriteErrorMsg(err);
return false;
}
var newCurrentDirectory = new DirectoryDto(Directory.GetCurrentDirectory());
return targetDirDto == newCurrentDirectory;
}
public StreamWriterDto(FileDto swFile, Encoding streamWriterEncoding)
{
if (!FileHelper.IsFileDtoValid(swFile))
{
var ex = new Exception("Invalid FileDto Passed to StreamWriter!");
var err = new FileOpsErrorMessageDto
{
DirectoryPath = string.Empty,
ErrId = 2,
ErrorMessage = ex.Message,
ErrSourceMethod = "SetStreamWriter()",
ErrException = ex,
FileName = string.Empty,
LoggerLevel = LogLevel.FATAL
};
ErrorMgr.LoggingStatus = ErrorLoggingStatus.On;
ErrorMgr.WriteErrorMsg(err);
throw ex;
}
_streamWriterEncoding = streamWriterEncoding;
CreateStreamWriter(swFile.FileXinfo.FullName);
}
public ParseExecuteElements(XmlElementType elementType)
{
if (elementType != XmlElementType.ExecuteCommand)
{
var ex = new ArgumentException("Invalid XmlElement Type For this Xml Parser!");
var err = new FileOpsErrorMessageDto
{
DirectoryPath = string.Empty,
ErrId = 1,
ErrorMessage = ex.Message,
ErrSourceMethod = "Constructor()",
ErrException = ex,
FileName = string.Empty,
LoggerLevel = LogLevel.FATAL
};
ErrorMgr.LoggingStatus = ErrorLoggingStatus.On;
ErrorMgr.WriteErrorMsg(err);
throw ex;
}
ElementType = elementType;
}
public ExecuteConsoleCommand(ConsoleCommandDto cmdDto,
ConsoleCommandLogMgr logMgr,
ConsoleCommandLogMgr errLogMgr,
WorkingDirectoryMgr wrkDirectoryMgr)
{
if (cmdDto == null)
{
var msg = "Console Command Dto is NULL!";
var err = new FileOpsErrorMessageDto
{
DirectoryPath = string.Empty,
ErrId = 1,
ErrorMessage = msg,
ErrSourceMethod = "Constructor",
LoggerLevel = LogLevel.FATAL
};
ErrorMgr.LoggingStatus = ErrorLoggingStatus.On;
ErrorMgr.WriteErrorMsg(err);
throw new ArgumentException(msg);
}
_executeCommand = cmdDto;
_logMgr = logMgr;
_errLogMgr = errLogMgr;
_wrkDirectoryMgr = wrkDirectoryMgr;
}
public WorkingDirectoryMgr(string targetDir)
{
SetCurrentWorkingDirectory();
if (string.IsNullOrWhiteSpace(targetDir) || !SetTargetDirectory(targetDir))
{
TargetWorkingDirectory = new DirectoryDto(OriginalCurrentWorkingDirectory.DirInfo.FullName);
}
if (!DirectoryHelper.IsDirectoryDtoValid(TargetWorkingDirectory))
{
var ex = new Exception("TargetWorkingDirectory Dto Invalid!");
var err = new FileOpsErrorMessageDto
{
DirectoryPath = OriginalCurrentWorkingDirectory.DirInfo.FullName,
ErrId = 1,
ErrorMessage = "Directory Deletion Failed!",
ErrSourceMethod = "Constructor()",
ErrException = ex,
FileName = string.Empty,
LoggerLevel = LogLevel.FATAL
};
ErrorMgr.LoggingStatus = ErrorLoggingStatus.On;
ErrorMgr.WriteErrorMsg(err);
throw ex;
}
}
public ApplicationLogger(
string defaultApplicationLogPathFileName,
string logFileTimeStamp)
{
_logfileTimeStamp = StringHelper.TrimStringEnds(logFileTimeStamp);
_defautlLogFileDto = ExtractLogFileDto(defaultApplicationLogPathFileName,
_logfileTimeStamp);
_defaultApplicationLogPathFileBaseName = defaultApplicationLogPathFileName;
if (!FileHelper.IsFileDtoValid(_defautlLogFileDto))
{
var msg = "Default Command Console Log File is INVALID!";
var err = new FileOpsErrorMessageDto
{
DirectoryPath = string.Empty,
ErrId = 1,
ErrorMessage = msg,
ErrSourceMethod = "Constructor()",
FileName = defaultApplicationLogPathFileName,
LoggerLevel = LogLevel.FATAL
};
ErrorMgr.LoggingStatus = ErrorLoggingStatus.On;
ErrorMgr.WriteErrorMsg(err);
throw new Exception(msg);
}
try
{
FileHelper.DeleteAFile(_defautlLogFileDto);
_currentApplicationLogPathFileBaseName = defaultApplicationLogPathFileName;
_currentLogfileDto = new FileDto(_defautlLogFileDto.FileXinfo.FullName);
}
catch (Exception ex)
{
var msg = "Consold Command Log Setup Failed! " + ex.Message;
var err = new FileOpsErrorMessageDto
{
DirectoryPath = string.Empty,
ErrId = 3,
ErrorMessage = msg,
ErrSourceMethod = "Constructor()",
FileName = defaultApplicationLogPathFileName,
LoggerLevel = LogLevel.FATAL
};
ErrorMgr.LoggingStatus = ErrorLoggingStatus.On;
ErrorMgr.WriteErrorMsg(err);
throw;
}
}
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 DirectoryDto(string directoryPath)
{
if (!ValidateInputDirString(directoryPath))
{
var err = new FileOpsErrorMessageDto
{
DirectoryPath = directoryPath,
ErrId = 10,
ErrorMessage = "Directory Path Invalid! Dto set to empty.",
ErrSourceMethod = "ValidateInputDirString()",
FileName = string.Empty,
LoggerLevel = LogLevel.ERROR
};
ErrorMgr.LoggingStatus = ErrorLoggingStatus.On;
ErrorMgr.WriteErrorMsg(err);
SetDirectoryEmpty();
return;
}
SetDirectory(AnalyzeRawDirectoryPath(directoryPath));
}
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 void SetDirectory(string directoryPath)
{
try
{
var formattedDir = PathHelper.RemoveTrailingDelimiter(directoryPath);
DirInfo = new DirectoryInfo(formattedDir);
DirInfoIsValid = DirInfo.Exists;
DirectoryName = GetBaseDirectoryName(directoryPath);
}
catch (Exception ex)
{
var err = new FileOpsErrorMessageDto
{
DirectoryPath = directoryPath,
ErrId = 20,
ErrorMessage = "Exception thrown while setting Directory Path",
ErrSourceMethod = "SetDirectory()",
ErrException = ex,
FileName = string.Empty,
LoggerLevel = LogLevel.ERROR
};
ErrorMgr.LoggingStatus = ErrorLoggingStatus.On;
ErrorMgr.WriteErrorMsg(err);
SetDirectoryEmpty();
}
}
public bool CreateApplicaitonLogDirectory()
{
if (!DirectoryHelper.IsDirectoryDtoValid(LogDirectoryDto))
{
var msg = "Application Log Directory Dto Invalid!";
var ex = new ArgumentException(msg);
var err = new FileOpsErrorMessageDto
{
ErrId = 5,
ErrorMessage = "Application Log Directory Dto Invalid!",
ErrSourceMethod = "CreateApplicaitonLogDirectory()",
ErrException = ex,
DirectoryPath = string.Empty,
LoggerLevel = LogLevel.FATAL
};
ErrorMgr.LoggingStatus = ErrorLoggingStatus.On;
ErrorMgr.WriteErrorMsg(err);
throw ex;
}
if (LogDirectoryDto.DirInfo.Exists)
{
return true;
}
DirectoryHelper.CreateDirectoryIfNecessary(LogDirectoryDto);
LogDirectoryDto.DirInfo.Refresh();
if (!LogDirectoryDto.DirInfo.Exists)
{
var msg = "Application Log Directory Creation Failed!";
var ex = new Exception(msg);
var err = new FileOpsErrorMessageDto
{
ErrId = 8,
ErrorMessage = msg,
ErrSourceMethod = "CreateApplicaitonLogDirectory()",
ErrException = ex,
DirectoryPath = LogDirectoryDto.DirInfo.FullName,
LoggerLevel = LogLevel.FATAL
};
ErrorMgr.LoggingStatus = ErrorLoggingStatus.On;
ErrorMgr.WriteErrorMsg(err);
throw ex;
}
return true;
}
public static bool DeleteADirectory(string dir)
{
if (string.IsNullOrEmpty(dir))
{
return true;
}
try
{
if (!Directory.Exists(dir))
{
return true;
}
Directory.Delete(dir, true);
if (Directory.Exists(dir))
{
return false;
}
}
catch (Exception ex)
{
var err = new FileOpsErrorMessageDto
{
DirectoryPath = dir,
ErrId = 2,
ErrorMessage = "Directory Deletion Failed!",
ErrSourceMethod = "DeleteADirectory",
ErrException = ex,
FileName = string.Empty,
LoggerLevel = LogLevel.FATAL
};
ErrorMgr.LoggingStatus = ErrorLoggingStatus.On;
ErrorMgr.WriteErrorMsg(err);
return false;
}
return true;
}
private void ConfigureDto(string fileName)
{
var fName = StringHelper.TrimStringEnds(fileName);
if (!ValidateFileInputString(fName))
{
var err = new FileOpsErrorMessageDto
{
DirectoryPath = string.Empty,
ErrId = 10,
ErrorMessage = "Validation failed on FileDto input file path!",
ErrSourceMethod = "ValidateFileInputString()",
FileName = fileName,
LoggerLevel = LogLevel.ERROR
};
ErrorMgr.LoggingStatus = ErrorLoggingStatus.On;
ErrorMgr.WriteErrorMsg(err);
SetDtoToEmpty();
return;
}
try
{
FileXinfo = new FileInfo(fName);
DirDto = new DirectoryDto(FileXinfo.DirectoryName);
}
catch(Exception ex)
{
var err = new FileOpsErrorMessageDto
{
DirectoryPath = string.Empty,
ErrId = 30,
ErrorMessage = "Failue creating FileInfo and DirectoryInfo objects!",
ErrSourceMethod = "ConfigureDto()",
ErrException = ex,
FileName = fileName,
LoggerLevel = LogLevel.ERROR
};
ErrorMgr.LoggingStatus = ErrorLoggingStatus.On;
ErrorMgr.WriteErrorMsg(err);
SetDtoToEmpty();
return;
}
FileExtension = FileXinfo.Extension;
FileNameAndExtension = FileXinfo.Name;
FilePath = FileXinfo.DirectoryName;
FullPathAndFileName = FileXinfo.FullName;
IsFileDtoEmpty = false;
}
public DirectoryDto SetCurrentWorkingDirectory()
{
OriginalCurrentWorkingDirectory = DirectoryHelper.GetCurrentDirectory();
if (!DirectoryHelper.IsDirectoryDtoValid(OriginalCurrentWorkingDirectory))
{
var ex = new Exception("OriginalCurrentWorkingDirectory Dto Invalid!");
var err = new FileOpsErrorMessageDto
{
DirectoryPath = string.Empty,
ErrId = 50,
ErrorMessage = ex.Message,
ErrSourceMethod = "SetCurrentWorkingDirectory()",
ErrException = ex,
FileName = string.Empty,
LoggerLevel = LogLevel.FATAL
};
ErrorMgr.LoggingStatus = ErrorLoggingStatus.On;
ErrorMgr.WriteErrorMsg(err);
throw ex;
}
return OriginalCurrentWorkingDirectory;
}
private bool DeleteOldLogFiles(string[] logFiles)
{
if (logFiles == null || logFiles.Length < 1)
{
return true;
}
TimeSpan dif = new TimeSpan(_logRetentionInDays, 0, 0, 0);
DateTime threshold = DateTime.Now.Subtract(dif);
foreach (var logFile in logFiles)
{
try
{
var fileDto = new FileDto(logFile);
if (fileDto.FileXinfo.CreationTime < threshold)
{
FileHelper.DeleteAFile(fileDto);
}
}
catch (Exception ex)
{
var err = new FileOpsErrorMessageDto
{
DirectoryPath = string.Empty,
ErrId = 79,
ErrorMessage = "Exception Thrown While Deleting Log File!",
ErrSourceMethod = "PurgeOldLogs",
ErrException = ex,
FileName = logFile,
LoggerLevel = LogLevel.INFO
};
ErrorMgr.WriteErrorMsg(err);
}
}
return true;
}
public void SetDefaultCommandExeDirectory(string dir)
{
if (string.IsNullOrWhiteSpace(dir))
{
DefaultCommandExeDirectoryDto = DirectoryHelper.GetCurrentDirectory();
if (!DirectoryHelper.IsDirectoryDtoValid(DefaultCommandExeDirectoryDto))
{
var ex = new Exception("Default Command Execution Directory Dto is INVALID!");
var err = new FileOpsErrorMessageDto
{
DirectoryPath = string.Empty,
ErrId = 1,
ErrorMessage = ex.Message,
ErrSourceMethod = "SetDefaultCommandExeDirectory()",
ErrException = ex,
FileName = string.Empty,
LoggerLevel = LogLevel.FATAL
};
ErrorMgr.LoggingStatus = ErrorLoggingStatus.On;
ErrorMgr.WriteErrorMsg(err);
throw ex;
}
}
DefaultCommandExeDirectoryDto?.Dispose();
DefaultCommandExeDirectoryDto = new DirectoryDto(dir);
if (!DirectoryHelper.IsDirectoryDtoValid(DefaultCommandExeDirectoryDto))
{
DefaultCommandExeDirectoryDto = DirectoryHelper.GetCurrentDirectory();
if (!DirectoryHelper.IsDirectoryDtoValid(DefaultCommandExeDirectoryDto))
{
var ex = new Exception("Default Command Execution Directory Dto is INVALID!");
var err = new FileOpsErrorMessageDto
{
DirectoryPath = string.Empty,
ErrId = 2,
ErrorMessage = ex.Message,
ErrSourceMethod = "SetDefaultCommandExeDirectory()",
ErrException = ex,
FileName = string.Empty,
LoggerLevel = LogLevel.FATAL
};
ErrorMgr.LoggingStatus = ErrorLoggingStatus.On;
ErrorMgr.WriteErrorMsg(err);
throw ex;
}
}
}
public void SetNewLogFileDirectory(string dirPath)
{
LogDirectoryDto?.Dispose();
LogDirectoryDto = new DirectoryDto(dirPath);
if (!DirectoryHelper.IsDirectoryDtoValid(LogDirectoryDto))
{
var msg = "Application Log Directory Dto Invalid!";
var ex = new ArgumentException(msg);
var err = new FileOpsErrorMessageDto
{
ErrId = 35,
ErrorMessage = "Application Log Directory Dto Invalid!",
ErrSourceMethod = "CreateApplicaitonLogDirectory()",
ErrException = ex,
DirectoryPath = dirPath,
LoggerLevel = LogLevel.FATAL
};
ErrorMgr.LoggingStatus = ErrorLoggingStatus.On;
ErrorMgr.WriteErrorMsg(err);
throw ex;
}
SetLogFileDto();
}
//System.Diagnostics.Process process = new System.Diagnostics.Process();
//System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo();
//startInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
//startInfo.FileName = "cmd.exe";
//startInfo.Arguments = _executeCommand.CommandLineExecutionSyntax;
//process.StartInfo = startInfo;
//process.Start();
// http://www.codeproject.com/Articles/25983/How-to-Execute-a-Command-in-C
public void Execute()
{
_logMgr.InitializeCmdConsoleLog(_executeCommand.CommandOutputLogFilePathBaseName);
_errLogMgr.InitializeCmdConsoleLog(_executeCommand.CommandOutputLogFilePathBaseName);
if (_executeCommand.NumberOfCommandElements == 0)
{
var msg = "Console Command Execution Syntax Is Empty! Command Display Name: " + _executeCommand.CommandDisplayName + " - Skipping this command.";
var err = new FileOpsErrorMessageDto
{
JobName = _executeCommand.CommandDisplayName,
DirectoryPath = string.Empty,
ErrId = 21,
ErrorMessage = msg,
ErrSourceMethod = "Execute()",
CommandName = _executeCommand.CommandDisplayName,
LoggerLevel = LogLevel.WARN
};
ErrorMgr.LoggingStatus = ErrorLoggingStatus.On;
ErrorMgr.WriteErrorMsg(err);
}
_wrkDirectoryMgr.SetTargetDirectory(_executeCommand.ExecuteInDir);
ExecuteCommand(_executeCommand);
}
private void ExecuteCommand(ConsoleCommandDto cmdDto)
{
var thisMethod = "ExecuteCommand()";
bool procStatus = false;
var proc = new Process();
try
{
// No window will be displayed to the user
proc.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
// Commands are set on the following two lines
proc.StartInfo.FileName = _executeCommand.ProcFileNameCommand;
proc.StartInfo.Arguments = _executeCommand.ProcFileArguments;
// Shell Execute must be false in order to
// set the Working directory below
proc.StartInfo.UseShellExecute = false;
// Do not create the black window.
proc.StartInfo.CreateNoWindow = true;
/* startInfo.WorkingDirectory
When the UseShellExecute property is false, gets or sets the working directory
for the process to be started. When UseShellExecute is true, gets or sets the
directory that contains the process to be started.
*/
proc.StartInfo.WorkingDirectory = _wrkDirectoryMgr.TargetWorkingDirectory.DirInfo.FullName;
// The following commands are needed to redirect the standard output.
// This means that it will be redirected to the Process.StandardOutput StreamReader.
proc.StartInfo.RedirectStandardOutput = true;
proc.OutputDataReceived += CmdOutputDataHandler;
// The following commands are needed to redirect standard error output.
proc.StartInfo.RedirectStandardError = true;
proc.ErrorDataReceived += CmdErrorDataHandler;
// Start Process
proc.Start();
// Start the asynchronous read of the standard output stream.
proc.BeginOutputReadLine();
// Start the asynchronous read of the standard
// error stream.
proc.BeginErrorReadLine();
procStatus = proc.WaitForExit(_executeCommand.CommandTimeOutInMiliseconds);
_executeCommand.CommandExitCode = proc.ExitCode;
_executeCommand.CommandExitTime = DateTime.Now;
}
catch (Exception ex)
{
var msg = "Console Command Execution Failed!";
var err = new FileOpsErrorMessageDto
{
DirectoryPath = string.Empty,
ErrId = 10,
ErrorMessage = msg,
ErrSourceMethod = thisMethod,
ErrException = ex,
CommandName = cmdDto.CommandDisplayName,
LoggerLevel = LogLevel.FATAL
};
ErrorMgr.LoggingStatus = ErrorLoggingStatus.On;
ErrorMgr.WriteErrorMsg(err);
throw new ArgumentException(msg);
}
finally
{
try
{
if (!procStatus)
{
proc.Kill();
}
}
catch
{
// ReSharper disable once EmptyStatement
;
}
proc.Close();
proc.Dispose();
// ReSharper disable once RedundantAssignment
proc = null;
}
}
public bool ExecuteCommands()
{
bool result;
int jobNo = 0;
Console.WriteLine("CmdrX.exe: Starting Job Execution...");
try
{
foreach (var job in _commandJobs.Jobs)
{
jobNo++;
job.JobNumber = jobNo;
job.CommandStartTime = DateTime.Now;
LogUtil.WriteLogJobStartUpMessage(job, _consoleExecutor);
_cmdLogMgr.LogWriteStartJobHeader(job);
_errLogMgr.LogWriteStartJobHeader(job);
var exeCmd = new ExecuteConsoleCommand(job, _cmdLogMgr, _errLogMgr, _wrkDirMgr);
exeCmd.Execute();
_cmdLogMgr.LogWriteEndJobFooter(job);
_errLogMgr.LogWriteEndJobFooter(job);
Console.WriteLine($"Completed Job No. {jobNo,4:###0} Exit Code: {job.CommandExitCode} Job Name: {job.CommandDisplayName}" );
if (job.CommandExitCode > job.KillJobsRunOnExitCodeGreaterThan
|| job.CommandExitCode < job.KillJobsRunOnExitCodeLessThan)
{
var msg = $"Job No. {job.JobNumber} Job Name: {job.CommandDisplayName}"
+ Environment.NewLine
+ $"Command Exit Code Is Out-Of-Bounds! Job Exit Code = {job.CommandExitCode} "
+ Environment.NewLine
+ $"Maximum Exit Code = {job.KillJobsRunOnExitCodeGreaterThan} "
+ $"Mininimum Exit Code = {job.KillJobsRunOnExitCodeLessThan} "
+ Environment.NewLine
+ "Terminating Job Group Command Execution!";
Environment.ExitCode = job.CommandExitCode;
var err = new FileOpsErrorMessageDto
{
JobName = job.CommandDisplayName,
DirectoryPath = string.Empty,
ErrId = 10,
ErrorMessage = msg,
ErrSourceMethod = "ExecuteCommands()",
FileName = string.Empty,
LoggerLevel = LogLevel.FATAL
};
_consoleExecutor.ApplicationExitStatus.OpsError =
ErrorMgr.FormatErrorDto(err);
_consoleExecutor.ApplicationExitStatus.IsFatalError = true;
ErrorMgr.LoggingStatus = ErrorLoggingStatus.On;
ErrorMgr.WriteErrorMsg(err);
LogUtil.WriteLogJobEndMessage(job, _consoleExecutor);
return false;
}
LogUtil.WriteLogJobEndMessage(job, _consoleExecutor);
_wrkDirMgr.ChangeBackToOriginalWorkingDirectory();
}
Environment.ExitCode = 0;
_consoleExecutor.ApplicationExitStatus.IsSuccessfulCompletion = true;
result = true;
}
catch (Exception ex)
{
var err = new FileOpsErrorMessageDto
{
DirectoryPath = string.Empty,
ErrId = 20,
ErrorMessage = "Exception thrown while executing commands! ",
ErrSourceMethod = "ExecuteCommands()",
ErrException = ex,
FileName = string.Empty,
LoggerLevel = LogLevel.FATAL
};
ErrorMgr.LoggingStatus = ErrorLoggingStatus.On;
ErrorMgr.WriteErrorMsg(err);
_consoleExecutor.ApplicationExitStatus.IsExceptionThrown = true;
_consoleExecutor.ApplicationExitStatus.OpsError = ErrorMgr.FormatErrorDto(err);
if (Environment.ExitCode == 0)
{
Environment.ExitCode = -8;
}
result = false;
}
finally
{
_wrkDirMgr.ChangeBackToOriginalWorkingDirectory();
_wrkDirMgr.Dispose();
_wrkDirMgr = null;
_commandJobs.Dispose();
_commandJobs = null;
_cmdLogMgr.Dispose();
_cmdLogMgr = null;
_errLogMgr.Dispose();
_errLogMgr = null;
}
return result;
}
public static void WriteLog(FileOpsErrorMessageDto err)
{
if (!IsLoggerConfigured)
{
return;
}
JobGroupMessageCnt++;
var sb = new StringBuilder();
if (err.LoggerLevel == LogLevel.FATAL
|| err.LoggerLevel == LogLevel.ERROR)
{
err.ErrId = (err.ErrId * -1);
}
sb.Append($"Msg Id: {err.ErrId} MsgType: {err.LoggerLevel} ");
if (!string.IsNullOrWhiteSpace(err.JobName))
{
sb.Append("Job Name: " + err.JobName);
}
sb.Append(NewLine);
sb.Append($"Class: {err.ErrSourceClass} Method: {err.ErrSourceMethod}" + NewLine);
if (!string.IsNullOrWhiteSpace(err.ErrorMessage))
{
sb = StringHelper.AddBreakLinesAtIndex("Error Message: " + err.ErrorMessage, MaxBannerLen - 1, sb, true);
}
if (err.ErrException != null)
{
sb = StringHelper.AddBreakLinesAtIndex("Exception: " + err.ErrException.Message, MaxBannerLen - 1, sb, true);
if (err.ErrException.InnerException != null)
{
sb = StringHelper.AddBreakLinesAtIndex("Inner Exception: " + err.ErrException.InnerException.Message, MaxBannerLen - 1, sb, true);
}
}
if (!string.IsNullOrWhiteSpace(err.DirectoryPath))
{
sb.Append($"-- Directory: {err.DirectoryPath}" + NewLine);
}
if (!string.IsNullOrWhiteSpace(err.DirectoryPath2))
{
sb.Append($"-- Directory2: {err.DirectoryPath2}" + NewLine);
}
if (!string.IsNullOrWhiteSpace(err.FileName))
{
sb.Append($"-- File Name: {err.FileName}" + NewLine);
}
if (!string.IsNullOrWhiteSpace(err.CommandName))
{
sb.Append($"-- Command Name: {err.FileName}" + NewLine);
}
WriteLog(err.LoggerLevel, sb.ToString());
}
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;
}
public bool ConfigureLogger()
{
if (_disposed)
{
return false;
}
if (!FileHelper.IsFileDtoValid(_currentLogfileDto))
{
var ex = new Exception("Current Log File Dto is INVALID! - " + _currentLogfileDto.DirDto.DirInfo.FullName);
var err = new FileOpsErrorMessageDto
{
DirectoryPath = _currentLogfileDto.FileXinfo.DirectoryName,
ErrId = 24,
ErrorMessage = ex.Message,
ErrSourceMethod = "ConfigureLogger()",
FileName = _currentLogfileDto.FileXinfo.FullName,
LoggerLevel = LogLevel.FATAL
};
ErrorMgr.LoggingStatus = ErrorLoggingStatus.On;
ErrorMgr.WriteErrorMsg(err);
throw ex;
}
if (!DirectoryHelper.CreateDirectoryIfNecessary(_currentLogfileDto.DirDto))
{
var ex = new Exception("Failure Creating Command Console Log File Directory: " + _currentLogfileDto.DirDto.DirInfo.FullName);
var err = new FileOpsErrorMessageDto
{
DirectoryPath = _currentLogfileDto.FileXinfo.DirectoryName,
ErrId = 25,
ErrorMessage = ex.Message,
ErrSourceMethod = "ConfigureLogger()",
FileName = _currentLogfileDto.FileXinfo.FullName,
LoggerLevel = LogLevel.FATAL
};
ErrorMgr.LoggingStatus = ErrorLoggingStatus.On;
ErrorMgr.WriteErrorMsg(err);
throw ex;
}
CreateNewStreamWriter(_currentLogfileDto);
NumberOfLogLinesWritten = 0;
return true;
}
public bool CreateStreamWriter(string swFileName)
{
Close();
StreamWriterFile = new FileDto(swFileName);
if (!FileHelper.IsFileDtoValid(StreamWriterFile))
{
var ex = new Exception("Invalid FileDto Passed to StreamWriter!");
var err = new FileOpsErrorMessageDto
{
DirectoryPath = string.Empty,
ErrId = 30,
ErrorMessage = ex.Message,
ErrSourceMethod = "CreateStreamWriter()",
ErrException = ex,
FileName = string.Empty,
LoggerLevel = LogLevel.FATAL
};
ErrorMgr.LoggingStatus = ErrorLoggingStatus.On;
ErrorMgr.WriteErrorMsg(err);
throw ex;
}
try
{
StreamWriterFile.DirDto.DirInfo.Refresh();
if (!StreamWriterFile.DirDto.DirInfo.Exists)
{
if (!DirectoryHelper.CreateDirectoryIfNecessary(StreamWriterFile))
{
var ex = new Exception("Failed to create directory for StreamWriter!");
var err = new FileOpsErrorMessageDto
{
DirectoryPath = string.Empty,
ErrId = 30,
ErrorMessage = ex.Message,
ErrSourceMethod = "CreateStreamWriter()",
ErrException = ex,
FileName = string.Empty,
LoggerLevel = LogLevel.FATAL
};
ErrorMgr.LoggingStatus = ErrorLoggingStatus.On;
ErrorMgr.WriteErrorMsg(err);
throw ex;
}
}
_fStream = new FileStream(StreamWriterFile.FileXinfo.FullName,
FileMode.Append,
FileAccess.Write,
FileShare.ReadWrite);
_swWriter = new StreamWriter(_fStream,_streamWriterEncoding);
}
catch(Exception ex)
{
var err = new FileOpsErrorMessageDto
{
DirectoryPath = string.Empty,
ErrId = 32,
ErrorMessage = "Failed To Create StreamWriter! " + ex.Message,
ErrSourceMethod = "SetStreamWriter()",
ErrException = ex,
FileName = string.Empty,
LoggerLevel = LogLevel.FATAL
};
ErrorMgr.LoggingStatus = ErrorLoggingStatus.On;
ErrorMgr.WriteErrorMsg(err);
throw;
}
return true;
}
public void LogWriteLine(string outputLine)
{
if (!IsStreamWriterValid())
{
var msg = "Stream Writer Dto Invalid!";
var err = new FileOpsErrorMessageDto
{
DirectoryPath = string.Empty,
ErrId = 30,
ErrorMessage = msg,
ErrSourceMethod = "LogWriteLine()",
FileName = _currentLogfileDto.FileXinfo.FullName,
LoggerLevel = LogLevel.FATAL
};
ErrorMgr.LoggingStatus = ErrorLoggingStatus.On;
ErrorMgr.WriteErrorMsg(err);
throw new Exception(msg);
}
if (string.IsNullOrWhiteSpace(outputLine))
{
return;
}
NumberOfLogLinesWritten++;
_swDto.GetStreamWriter().WriteLine(outputLine);
}
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;
}
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);
}
}
public void ConfigureParameters()
{
if (string.IsNullOrWhiteSpace(DefaultCommandOutputLogFilePathName))
{
var ex = new Exception("DefaultCommandOutputLogFilePathName = Empty!");
var err = new FileOpsErrorMessageDto
{
DirectoryPath = string.Empty,
ErrId = 1,
ErrorMessage = ex.Message,
ErrSourceMethod = "ConfigureParameters()",
ErrException = ex,
FileName = string.Empty,
LoggerLevel = LogLevel.FATAL
};
ErrorMgr.LoggingStatus = ErrorLoggingStatus.On;
ErrorMgr.WriteErrorMsg(err);
throw ex;
}
AppLogDirectory = PathHelper.ExtractDirectoryComponent(DefaultCommandOutputLogFilePathName);
AppLogMgr = new ApplicationLogMgr(AppLogDirectory,
AppLogFileBaseNameOnly,
AppLogFileExtensionWithoutLeadingDot,
AppLogFileTimeStamp);
}
private void SetLogFileDto()
{
LogPathFileNameDto?.Dispose();
var fName = LogFileNameOnly + "_" + LogFileTimeStamp + "." + LogFileExtensionWithNoLeadingDot;
var fileDto = new FileDto(LogDirectoryDto, fName);
if (!FileHelper.IsFileDtoValid(fileDto))
{
var msg = "Application Log Directory Dto Invalid!";
var ex = new ArgumentException(msg);
var err = new FileOpsErrorMessageDto
{
ErrId = 35,
ErrorMessage = "Application Log Directory Dto Invalid!",
ErrSourceMethod = "CreateApplicaitonLogDirectory()",
ErrException = ex,
FileName = fName,
DirectoryPath = LogDirectoryDto?.DirInfo?.FullName,
LoggerLevel = LogLevel.FATAL
};
ErrorMgr.LoggingStatus = ErrorLoggingStatus.On;
ErrorMgr.WriteErrorMsg(err);
throw ex;
}
LogPathFileNameDto = fileDto;
}
