/// <summary>
/// Constructor
/// </summary>
/// <param name="logLevel"></param>
/// <param name="message"></param>
/// <param name="ex"></param>
public LogMessage(BaseLogger.LogLevels logLevel, string message, Exception ex = null)
{
LogLevel = logLevel;
Message = message;
MessageException = ex;
MessageDateUTC = DateTime.UtcNow;
}
public void TestFileLogger(
string logDirectory,
string logFileNameBase,
string message,
BaseLogger.LogLevels entryType,
int logCount,
int logDelayMilliseconds)
{
FileLogger.ResetLogFileName();
var logFilePath = Path.Combine(logDirectory, logFileNameBase);
var logger = new FileLogger(logFilePath);
var randGenerator = new Random();
for (var i = 0; i < logCount; i++)
{
var logMessage = message + " " + i;
switch (entryType)
{
case BaseLogger.LogLevels.DEBUG:
logger.Debug(logMessage);
break;
case BaseLogger.LogLevels.INFO:
logger.Info(logMessage);
break;
case BaseLogger.LogLevels.WARN:
logger.Warn(logMessage);
break;
case BaseLogger.LogLevels.ERROR:
logger.Error(logMessage);
break;
case BaseLogger.LogLevels.FATAL:
logger.Fatal(logMessage);
break;
default:
logger.Fatal("Unrecognized log type: " + entryType);
break;
}
ProgRunner.SleepMilliseconds(logDelayMilliseconds + randGenerator.Next(0, logDelayMilliseconds / 10));
}
var expectedName = logFileNameBase + "_" + DateTime.Now.ToString("MM-dd-yyyy") + FileLogger.LOG_FILE_EXTENSION;
if (!FileLogger.LogFilePath.EndsWith(expectedName))
{
Assert.Fail("Log file name was not in the expected format of " + expectedName + "; see " + FileLogger.LogFilePath);
}
Console.WriteLine("Log entries written to " + FileLogger.LogFilePath);
}
private void MessageLoggedHandler(string message, BaseLogger.LogLevels logLevel)
{
var timeStamp = DateTime.Now.ToString("MM/dd/yyyy HH:mm:ss");
// Update the status file data
clsStatusData.MostRecentLogMessage = timeStamp + "; " + message + "; " + logLevel;
if (logLevel <= BaseLogger.LogLevels.ERROR)
{
clsStatusData.AddErrorMessage(timeStamp + "; " + message + "; " + logLevel);
}
}
private void ReportMessage(string message, BaseLogger.LogLevels logLevel = BaseLogger.LogLevels.INFO, bool logToDB = false)
{
if (logToDB)
{
LogTools.WriteLog(LogTools.LoggerTypes.LogDb, logLevel, message);
}
else
{
LogTools.WriteLog(LogTools.LoggerTypes.LogFile, logLevel, message);
}
OnStatusEvent(message);
}
public void TestFileLoggerStaticDefaultName(
string message,
BaseLogger.LogLevels entryType,
int logCount,
int logDelayMilliseconds)
{
var logFileNameBase = "PRISM_log";
FileLogger.ResetLogFileName();
TestStaticLogging(
message, entryType, logCount, logDelayMilliseconds,
logFileNameBase + "_" + DateTime.Now.ToString("MM-dd-yyyy") + FileLogger.LOG_FILE_EXTENSION);
}
/// <summary>
/// Write a message and possibly an exception to the logging system
/// </summary>
/// <param name="loggerType">Type of logger to use</param>
/// <param name="logLevel">Level of log reporting</param>
/// <param name="message">Message to be logged</param>
/// <param name="ex">Exception to be logged; null if no exception</param>
/// <remarks>Log message will not be written if logLevel is LogLevel or higher)</remarks>
private static void WriteLogWork(LoggerTypes loggerType, BaseLogger.LogLevels logLevel, string message, Exception ex)
{
if (OfflineMode && loggerType == LoggerTypes.LogDb)
{
loggerType = LoggerTypes.LogFile;
}
BaseLogger myLogger;
// Establish which logger will be used
switch (loggerType)
{
case LoggerTypes.LogDb:
// Note that the Database logger will (by default) also echo messages to the file logger
myLogger = mDbLogger;
message = System.Net.Dns.GetHostName() + ": " + message;
break;
case LoggerTypes.LogFile:
myLogger = mFileLogger;
if (!string.IsNullOrWhiteSpace(FileLogger.LogFilePath) &&
!FileLogger.LogFilePath.Contains(Path.DirectorySeparatorChar.ToString()))
{
var logFileName = Path.GetFileName(FileLogger.LogFilePath);
string workDirLogPath;
if (string.IsNullOrEmpty(WorkDirPath))
{
workDirLogPath = Path.Combine(".", logFileName);
}
else
{
workDirLogPath = Path.Combine(WorkDirPath, logFileName);
}
ChangeLogFileBaseName(workDirLogPath, FileLogger.AppendDateToBaseFileName);
}
break;
default:
throw new Exception("Invalid logger type specified");
}
MessageLogged?.Invoke(message, logLevel);
// Send the log message
myLogger?.LogMessage(logLevel, message, ex);
}
public void TestFileLoggerRelativePath(
string logFileNameBase,
string message,
BaseLogger.LogLevels entryType,
int logCount,
int logDelayMilliseconds)
{
const bool appendDateToBaseName = true;
FileLogger.ChangeLogFileBaseName(logFileNameBase, appendDateToBaseName);
TestStaticLogging(
message, entryType, logCount, logDelayMilliseconds,
logFileNameBase + "_" + DateTime.Now.ToString("MM-dd-yyyy") + FileLogger.LOG_FILE_EXTENSION);
}
/// <summary>
/// Configures the file logger
/// </summary>
/// <param name="logFileNameBase">Base name for log file</param>
/// <param name="logLevel">Log threshold level</param>
/// <param name="traceMode">When true, show additional debug messages at the console</param>
public static void CreateFileLogger(
string logFileNameBase,
BaseLogger.LogLevels logLevel = BaseLogger.LogLevels.INFO,
bool traceMode = false)
{
if (traceMode && !BaseLogger.TraceMode)
{
BaseLogger.TraceMode = true;
}
BaseLogger.TimestampFormat = Logging.LogMessage.TimestampFormatMode.YearMonthDay24hr;
mFileLogger.LogLevel = logLevel;
FileLogger.ChangeLogFileBaseName(logFileNameBase, appendDateToBaseName: true);
}
/// <summary>
/// Configures the database logger
/// </summary>
/// <param name="connStr">System.Data.SqlClient style connection string</param>
/// <param name="moduleName">Module name used by logger</param>
/// <param name="logLevel">Log threshold level</param>
/// <param name="traceMode">When true, show additional debug messages at the console</param>
public static void CreateDbLogger(
string connStr,
string moduleName,
BaseLogger.LogLevels logLevel = BaseLogger.LogLevels.INFO,
bool traceMode = false)
{
if (traceMode && !BaseLogger.TraceMode)
{
BaseLogger.TraceMode = true;
}
mDbLogger.EchoMessagesToFileLogger = true;
mDbLogger.LogLevel = logLevel;
mDbLogger.ChangeConnectionInfo(moduleName, connStr, "PostLogEntry", "type", "message", "postedBy");
}
public void TestFileLoggerFixedLogFileNameWithExtension(
string logDirectory,
string logFileNameBase,
string message,
BaseLogger.LogLevels entryType,
int logCount,
int logDelayMilliseconds)
{
var logFilePath = Path.Combine(logDirectory, logFileNameBase);
const bool appendDateToBaseName = false;
FileLogger.ChangeLogFileBaseName(logFilePath, appendDateToBaseName);
TestStaticLogging(
message, entryType, logCount, logDelayMilliseconds,
logFileNameBase);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="serverName"></param>
/// <param name="logLevel"></param>
/// <param name="logDbConnectionString"></param>
/// <remarks>If "serverName" is blank, will auto-set Perspective to PerspectiveTypes.Server</remarks>
public clsMyEMSLMTSFileCacher(string serverName, BaseLogger.LogLevels logLevel, string logDbConnectionString)
{
if (string.IsNullOrWhiteSpace(serverName))
{
Perspective = PerspectiveTypes.Server;
MTSServer = Environment.MachineName;
}
else
{
Perspective = PerspectiveTypes.Client;
MTSServer = serverName;
}
LogLevel = logLevel;
mLogDBConnectionString = logDbConnectionString;
Initialize();
}
public void TestLogTools(string logDirectory, string logFileNameBase, BaseLogger.LogLevels entryType, BaseLogger.LogLevels logThresholdLevel)
{
var logFilePath = Path.Combine(logDirectory, logFileNameBase);
LogTools.CreateFileLogger(logFilePath, logThresholdLevel);
Console.WriteLine("Log file; " + LogTools.CurrentLogFilePath);
var message = "Test log " + entryType + " via LogTools (log threshold is " + logThresholdLevel + ")";
switch (entryType)
{
case BaseLogger.LogLevels.DEBUG:
LogTools.LogDebug(message);
break;
case BaseLogger.LogLevels.INFO:
LogTools.LogMessage(message);
break;
case BaseLogger.LogLevels.WARN:
LogTools.LogWarning(message);
break;
case BaseLogger.LogLevels.ERROR:
LogTools.LogError(message);
break;
case BaseLogger.LogLevels.FATAL:
LogTools.LogFatalError(message);
break;
default:
LogTools.LogError("Unrecognized log type: " + entryType);
break;
}
ProgRunner.SleepMilliseconds(100);
LogTools.FlushPendingMessages();
}
private void TestStaticLogging(
string message,
BaseLogger.LogLevels entryType,
int logCount,
int logDelayMilliseconds,
string expectedLogFileName)
{
var randGenerator = new Random();
string formatString;
if (logCount < 10)
{
formatString = "{0} {1}/{2}";
}
else
{
formatString = "{0} {1,2}/{2}";
}
for (var i = 0; i < logCount; i++)
{
FileLogger.WriteLog(entryType, string.Format(formatString, message, i + 1, logCount));
ProgRunner.SleepMilliseconds(logDelayMilliseconds + randGenerator.Next(0, logDelayMilliseconds / 10));
}
if (!FileLogger.LogFilePath.EndsWith(expectedLogFileName))
{
var errMsg = "Log file name was not in the expected format of " + expectedLogFileName + "; see " + FileLogger.LogFilePath;
Assert.Fail(errMsg);
}
FileLogger.FlushPendingMessages();
Console.WriteLine("Log entries written to " + FileLogger.LogFilePath);
}
/// <summary>
/// Main entry method
/// </summary>
public static int Main()
{
var commandLineParser = new clsParseCommandLine();
mLogLevel = BaseLogger.LogLevels.INFO;
mMTSServer = string.Empty;
mLogDBConnectionString = clsMyEMSLMTSFileCacher.LOG_DB_CONNECTION_STRING;
mMinimumCacheFreeSpaceGB = clsMyEMSLMTSFileCacher.DEFAULT_MINIMUM_CACHE_FREE_SPACE_GB;
mLocalServerMode = false;
mPreviewMode = false;
mTraceMode = false;
try
{
var success = false;
if (commandLineParser.ParseCommandLine())
{
if (SetOptionsUsingCommandLineParameters(commandLineParser))
{
success = true;
}
}
if (!success ||
commandLineParser.NeedToShowHelp ||
commandLineParser.ParameterCount + commandLineParser.NonSwitchParameterCount == 0 ||
mMTSServer.Length == 0 && !mLocalServerMode)
{
ShowProgramHelp();
return(-1);
}
if (mLocalServerMode)
{
mMTSServer = string.Empty;
}
else
{
var updatesArePending = WindowsUpdateStatus.UpdatesArePending(out var pendingWindowsUpdateMessage);
if (updatesArePending)
{
Console.WriteLine(pendingWindowsUpdateMessage);
Console.WriteLine("Will not contact the MTS server to process cache requests");
return(0);
}
}
var downloader = new clsMyEMSLMTSFileCacher(mMTSServer, mLogLevel, mLogDBConnectionString)
{
MinimumCacheFreeSpaceGB = mMinimumCacheFreeSpaceGB,
TraceMode = mTraceMode
};
// Attach the events
downloader.DebugEvent += Downloader_DebugEvent;
downloader.ErrorEvent += Downloader_ErrorEvent;
downloader.StatusEvent += Downloader_StatusEvent;
downloader.WarningEvent += Downloader_WarningEvent;
downloader.ProgressUpdate += Downloader_ProgressUpdate;
mPercentComplete = 0;
mLastProgressUpdateTime = DateTime.UtcNow;
// Initiate processing, which will contact the MTS Server to see if any files need to be cached
success = downloader.Start(mPreviewMode);
LogTools.FlushPendingMessages();
if (!success)
{
ShowErrorMessage("Error processing cache requests for MTS server " + mMTSServer + ": " + downloader.ErrorMessage);
return(-3);
}
}
catch (Exception ex)
{
LogTools.FlushPendingMessages();
Console.WriteLine("Error occurred in Program->Main: " + Environment.NewLine + ex.Message);
Console.WriteLine(ex.StackTrace);
Thread.Sleep(1500);
return(-1);
}
return(0);
}
/// <summary>
/// Write a message and exception to the logging system
/// </summary>
/// <param name="loggerType">Type of logger to use</param>
/// <param name="logLevel">Level of log reporting</param>
/// <param name="message">Message to be logged</param>
/// <param name="ex">Exception to be logged</param>
public static void WriteLog(LoggerTypes loggerType, BaseLogger.LogLevels logLevel, string message, Exception ex)
{
WriteLogWork(loggerType, logLevel, message, ex);
}
/// <summary>
/// Write a message to the logging system
/// </summary>
/// <param name="loggerType">Type of logger to use</param>
/// <param name="logLevel">Level of log reporting</param>
/// <param name="message">Message to be logged</param>
public static void WriteLog(LoggerTypes loggerType, BaseLogger.LogLevels logLevel, string message)
{
WriteLogWork(loggerType, logLevel, message, null);
}
/// <summary>
/// Sets the file logging log threshold via an enum
/// </summary>
/// <param name="logLevel">LogLevels value defining log threshold level (Debug is most verbose)</param>
public static void SetFileLogLevel(BaseLogger.LogLevels logLevel)
{
mFileLogger.LogLevel = logLevel;
}
