static int Main(string[] args)
{
// get verbose level to determine how much to print in console
VerboseLevel verboseLevel = ArgumentsHelper.GetVerboseLevel(args);
if (verboseLevel == VerboseLevel.All)
{
Console.WriteLine("verbose level set to \"{0}\".", verboseLevel);
}
if (args.Length < 2)
{
Console.WriteLine(usageText);
return(1);
}
//foreach (string s in args)
//{
// Console.WriteLine(s);
//}
string inputFile = ArgumentsHelper.GetInputFile(args);
if (verboseLevel == VerboseLevel.All)
{
Console.WriteLine("reading log file \"{0}\".", inputFile);
}
return(0);
}
public void Print(string text, VerboseLevel verbosity = VerboseLevel.REGULAR)
{
if ((int)Verbosity >= (int)verbosity)
{
System.Console.Write(text);
}
}
/// <summary>
/// Creates a LogFileWriter that initially queues message
/// </summary>
public LogSubscriptionConsole()
{
m_verbose = VerboseLevel.None;
m_subscriber = Logger.CreateSubscriber(m_verbose);
m_subscriber.SubscribeToAll(m_verbose);
m_subscriber.NewLogMessage += SubscriberNewLogMessage;
}
/// <summary>
/// Creates a <see cref="LogSubscriber"/>
/// </summary>
/// <returns></returns>
public static LogSubscriber CreateSubscriber(VerboseLevel level = VerboseLevel.None)
{
var subscriber = new LogSubscriber(s_logger.CreateSubscriber());
subscriber.SubscribeToAll(level);
return(subscriber);
}
public void ShouldWrite_TrueIfLevelMatches(VerboseLevel levelToSet)
{
// *** Setup
_logger.LogLevel = levelToSet;
foreach (VerboseLevel level in AllLevels)
{
int intLevel = (int)level;
int intLevelToSet = (int)levelToSet;
// The level being requested should be contained in the level that was set.
bool shouldWrite = ((intLevel & intLevelToSet) == intLevel);
// If either level is set to NONE, then nothing should be written.
if ((level == VerboseLevel.NONE) || (levelToSet == VerboseLevel.NONE))
{
shouldWrite = false;
}
// *** Execute
bool returnedValue = _logger.ShouldWrite(level);
// *** Assert
Assert.AreEqual(returnedValue, shouldWrite,
"ShouldWrite({0}) returned false with the log level set to {1}!", level.ToString(), levelToSet.ToString());
}
}
/// <summary>
/// Creates a LogFileWriter that initially queues message
/// </summary>
public LogSubscriptionConsole()
{
m_verbose = VerboseLevel.None;
m_subscriber = Logger.CreateSubscriber(m_verbose);
m_subscriber.SubscribeToAll(m_verbose);
m_subscriber.NewLogMessage += SubscriberNewLogMessage;
}
internal static void LogMessage(string message, VerboseLevel level)
{
if (VerboseLevel >= level && LoggingMethod != null)
{
LoggingMethod(message, level);
}
}
/// <summary>
/// Returns whether or not a message should be logged based on the current logging level.
/// </summary>
protected bool ShouldWrite(VerboseLevel mode)
{
int intLevel = (int)LogLevel;
int intMode = (int)mode;
int andResult = (intLevel & intMode);
return((andResult > 0) && (andResult == intMode));
}
public static MessageAttributeFilter Create(VerboseLevel level)
{
if (level == VerboseLevel.None)
{
return(null);
}
return(new MessageAttributeFilter(level));
}
/// <summary>
/// Subscribes to the publisher of the specified assembly with the specified verbose level.
/// </summary>
public void SubscribeToAssembly(Assembly assembly, VerboseLevel level)
{
if (assembly == null)
{
throw new ArgumentNullException(nameof(assembly));
}
m_subscriber.Subscribe(PublisherFilter.CreateAssembly(assembly), MessageAttributeFilter.Create(level), false);
}
/// <summary>
/// Ignore all messages of this verbose level.
/// </summary>
public void IgnoreType(Type type, VerboseLevel level)
{
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
m_subscriber.Subscribe(PublisherFilter.CreateType(type), MessageAttributeFilter.Create(level), true);
}
/// <summary>
/// Ignore all messages of this verbose level.
/// </summary>
public void IgnoreAssembly(string assemblyExpression, VerboseLevel level)
{
if (assemblyExpression == null)
{
throw new ArgumentNullException(nameof(assemblyExpression));
}
m_subscriber.Subscribe(PublisherFilter.CreateAssembly(assemblyExpression), MessageAttributeFilter.Create(level), true);
}
/// <summary>
/// Subscribes to the publisher of the specified type expression with the specified verbose level.
/// </summary>
/// <param name="typeExpression">An expression of the name of a type. Must include a * or ? to be considered an expression.</param>
/// <param name="level">The level</param>
public void SubscribeToType(string typeExpression, VerboseLevel level)
{
if (typeExpression == null)
{
throw new ArgumentNullException(nameof(typeExpression));
}
m_subscriber.Subscribe(PublisherFilter.CreateType(typeExpression), MessageAttributeFilter.Create(level), false);
}
public void WriteTraceWithArgs_PrintsToStdOutOnlyIfLogLevelIsTrace(VerboseLevel levelToSet)
{
const bool writeToStdErr = false;
var levelsToPrint = new List <VerboseLevel> {
VerboseLevel.TRACE
};
WriteFuncWithArgs_PrintsOnlyIfLogLevelIsInList(levelToSet, writeToStdErr, levelsToPrint, "WriteTrace", _logger.WriteTrace);
}
public void WriteWarningWithArgs_PrintsToStdOutUnlessLogLevelIsErrorOrNone(VerboseLevel levelToSet)
{
const bool writeToStdErr = true;
var levelsToPrint = new List <VerboseLevel> {
VerboseLevel.WARNING, VerboseLevel.INFO, VerboseLevel.DEBUG, VerboseLevel.TRACE
};
WriteFuncWithArgs_PrintsOnlyIfLogLevelIsInList(levelToSet, writeToStdErr, levelsToPrint, "WriteWarning", _logger.WriteWarning);
}
public void WriteDebug_PrintsToStdOutOnlyIfLogLevelIsDebugOrTrace(VerboseLevel levelToSet)
{
const bool writeToStdErr = false;
var levelsToPrint = new List <VerboseLevel> {
VerboseLevel.DEBUG, VerboseLevel.TRACE
};
WriteFunc_PrintsOnlyIfLogLevelIsInList(levelToSet, writeToStdErr, levelsToPrint, "WriteDebug", _logger.WriteDebug);
}
public void WriteError_PrintsToStdOutUnlessLogLevelIsNone(VerboseLevel levelToSet)
{
const bool writeToStdErr = true;
var levelsToPrint = new List <VerboseLevel> {
VerboseLevel.ERROR, VerboseLevel.WARNING, VerboseLevel.INFO, VerboseLevel.DEBUG, VerboseLevel.TRACE
};
WriteFunc_PrintsOnlyIfLogLevelIsInList(levelToSet, writeToStdErr, levelsToPrint, "WriteError", _logger.WriteError);
}
public FileLogger(string filename, int age, VerboseLevel level)
{
_logfile = filename;
_age = age;
VerboseLevel = level;
InitLogFile();
ExpireLogs();
}
/// <summary>
/// Sets log file writer path and optionally its verbosity level.
/// </summary>
public void SetPath(string logDirectory, VerboseLevel level)
{
FilePath.ValidatePathName(logDirectory);
lock (m_syncRoot)
{
Verbose = level;
m_path = logDirectory;
m_flushTask.Start(1000);
}
}
public static void LogError(object message, VerboseLevel verboseLevel = VerboseLevel.IMPORTANT)
{
if (instance != null)
{
if (instance.verboseLevel >= verboseLevel)
{
Debug.LogError(FormatMessage(message.ToString()));
}
}
}
public TestRun(string base_dir, VerboseLevel verbose_level, List <Test> tests, List <IReport> reports, LoggingServer logging_server, TestRunner runner)
{
start_time = DateTime.Now;
this.base_dir = base_dir;
this.verbose_level = verbose_level;
this.tests = tests;
this.reports = reports;
this.logging_server = logging_server;
this.runner = runner;
}
public TestRun (string base_dir, VerboseLevel verbose_level, List<Test> tests, List<IReport> reports, LoggingServer logging_server, TestRunner runner)
{
start_time = DateTime.Now;
this.base_dir = base_dir;
this.verbose_level = verbose_level;
this.tests = tests;
this.reports = reports;
this.logging_server = logging_server;
this.runner = runner;
}
/// <summary>
/// Instantiate a new message handler.
/// </summary>
/// <param name="shortAppName">Short application name; usually 4 uppercase characters.</param>
/// <param name="longAppName">Long application name; usually the executable name.</param>
public MessageHandler(string shortAppName, string longAppName)
{
this.shortAppName = shortAppName;
this.longAppName = longAppName;
this.lastErrorNumber = SuccessErrorNumber;
this.sourceTrace = false;
this.verbosityLevel = VerboseLevel.Off;
this.warningLevel = WarningLevel.Minor;
this.warningAsError = false;
this.suppressedWarnings = new Hashtable();
}
/// <summary>
/// Helper function that runs the multiple parameter Write function tests.
/// </summary>
/// <param name="levelToSet">The VerboseLevel to set before running the Write function.</param>
/// <param name="writeToStdErr">Pass true if the Write function should print to stderr, otherwise pass false.</param>
/// <param name="levelsToPrint">A list of VerboseLevels that (when set) should produce output given the Write function being tested.</param>
/// <param name="funcName">The name of the Write function being tested.</param>
/// <param name="function">The Write function to call.</param>
private void WriteFuncWithArgs_PrintsOnlyIfLogLevelIsInList(
VerboseLevel levelToSet,
bool writeToStdErr,
IList <VerboseLevel> levelsToPrint,
string funcName,
Action <string, Object[]> function)
{
const string FORMAT_STRING = "Level is {0}, which equals number {1}.";
// *** Setup
_logger.LogLevel = levelToSet;
_errorStringBuilder.Clear();
_outputStringBuilder.Clear();
StringBuilder targetStr = _outputStringBuilder;
StringBuilder emptyStr = _errorStringBuilder;
string targetStrName = "stdout";
string emptyStrName = "stderr";
Object[] args = { levelToSet, (int)levelToSet };
string stringToMatch = StringUtils.FormatInvariant(FORMAT_STRING, args);
if (writeToStdErr)
{
targetStr = _errorStringBuilder;
emptyStr = _outputStringBuilder;
targetStrName = "stderr";
emptyStrName = "stdout";
}
// *** Execute
function(FORMAT_STRING, args);
// *** Assert
if (levelsToPrint.Contains(levelToSet))
{
Assert.That(targetStr.ToString().Contains(stringToMatch),
"{0} didn't print to {1} with LogLevel set to {2}!", funcName, targetStrName, levelToSet.ToString());
}
else
{
Assert.IsEmpty(targetStr.ToString(),
"{0} wrote a string to {1} with LogLevel set to {2}!", funcName, targetStrName, levelToSet.ToString());
}
// Error & Warning should never print to stdout.
// The others should never print to stderr.
Assert.IsEmpty(emptyStr.ToString(),
"{0} wrote a string to {1}!", funcName, emptyStrName);
}
/// <summary>
/// Creates a LogFileWriter that initially queues message
/// </summary>
/// <param name="messageLimit">the number of messages to maintain</param>
public LogSubscriptionFileWriter(int messageLimit)
{
m_processName = Process.GetCurrentProcess().ProcessName;
m_fileSequenceNumber = 1;
m_syncRoot = new object();
m_maxQueue = messageLimit;
m_messageQueue = new ConcurrentQueue <LogMessage>();
m_flushTask = new ScheduledTask();
m_flushTask.Running += m_flushTask_Running;
m_verbose = VerboseLevel.High;
m_subscriber = Logger.CreateSubscriber(m_verbose);
m_subscriber.SubscribeToAll(m_verbose);
m_subscriber.NewLogMessage += SubscriberNewLogMessage;
}
/// does the logging.
/// @param str the string to log
/// @param category the category of the log
/// @param source the source of the log
/// @param logLevel what level to show and how to show it
public virtual void Log(string str, Categories category, Sources source, VerboseLevel logLevel)
{
if (logLevel < m_minLevelToShow)
{
return; // too low a level
}
/* if (m_categoriesToShow[(int)category] && m_sourcesToShow[(int)source])
* {
* if (logLevel == VerboseLevel.Verbose)
* Debug.Log(str);
* else if (logLevel == VerboseLevel.Warning)
* Debug.LogWarning(str);
* else Debug.LogError(str);
* }*/
}
/// <summary>
/// Creates a LogFileWriter that initially queues message
/// </summary>
/// <param name="messageLimit">the number of messages to maintain</param>
public LogSubscriptionFileWriter(int messageLimit)
{
m_processName = Process.GetCurrentProcess().ProcessName;
m_fileSequenceNumber = 1;
m_syncRoot = new object();
m_maxQueue = messageLimit;
m_messageQueue = new ConcurrentQueue<LogMessage>();
m_flushTask = new ScheduledTask();
m_flushTask.Running += m_flushTask_Running;
m_verbose = VerboseLevel.High;
m_subscriber = Logger.CreateSubscriber(m_verbose);
m_subscriber.SubscribeToAll(m_verbose);
m_subscriber.NewLogMessage += SubscriberNewLogMessage;
}
/// <summary>
/// Helper function that runs the single parameter Write function tests.
/// </summary>
/// <param name="levelToSet">The VerboseLevel to set before running the Write function.</param>
/// <param name="writeToStdErr">Pass true if the Write function should print to stderr, otherwise pass false.</param>
/// <param name="levelsToPrint">A list of VerboseLevels that (when set) should produce output given the Write function being tested.</param>
/// <param name="funcName">The name of the Write function being tested.</param>
/// <param name="function">The Write function to call.</param>
private void WriteFunc_PrintsOnlyIfLogLevelIsInList(
VerboseLevel levelToSet,
bool writeToStdErr,
IList <VerboseLevel> levelsToPrint,
string funcName,
Action <string> function)
{
// *** Setup
_logger.LogLevel = levelToSet;
_errorStringBuilder.Clear();
_outputStringBuilder.Clear();
StringBuilder targetStr = _outputStringBuilder;
StringBuilder emptyStr = _errorStringBuilder;
string targetStrName = "stdout";
string emptyStrName = "stderr";
if (writeToStdErr)
{
targetStr = _errorStringBuilder;
emptyStr = _outputStringBuilder;
targetStrName = "stderr";
emptyStrName = "stdout";
}
// *** Execute
function(STRING_TO_PRINT);
// *** Assert
if (levelsToPrint.Contains(levelToSet))
{
Assert.That(targetStr.ToString().Contains(STRING_TO_PRINT),
"{0} didn't print to {1} with LogLevel set to {2}!", funcName, targetStrName, levelToSet.ToString());
}
else
{
Assert.IsEmpty(targetStr.ToString(),
"{0} wrote a string to {1} with LogLevel set to {2}!", funcName, targetStrName, levelToSet.ToString());
}
// Error & Warning should never print to stdout.
// The others should never print to stderr.
Assert.IsEmpty(emptyStr.ToString(),
"{0} wrote a string to {1}!", funcName, emptyStrName);
}
public virtual AnsibleCommand Verbose(VerboseLevel level = VerboseLevel.Low)
{
switch (level)
{
case VerboseLevel.Low:
return(AddParameter("-v"));
case VerboseLevel.Medium:
return(AddParameter("-vv"));
case VerboseLevel.High:
return(AddParameter("-vvv"));
case VerboseLevel.Highest:
return(AddParameter("-vvvv"));
}
return(this);
}
public void CandidateExclusionSolve(VerboseLevel verboseLevel)
{
if (verboseLevel == VerboseLevel.StepByStep)
{
Console.Write(Print("At start of CandidateExclusionSolve"));
}
IEnumerable <PicrossActiveLine> solvableLines;
while (
(solvableLines = ActiveLines.Where(line => !line.IsSet && line.CandidateCount == 1)).Any() &&
IsValid)
{
var selectedLine = solvableLines.First();
selectedLine.ApplyLine(selectedLine.CandidateSolutions.First());
if (verboseLevel == VerboseLevel.StepByStep)
{
Console.Write(Print("After a CandidateExclusionStep"));
}
}
}
/// <summary>
/// Prints the specified message to the output stream if the current log level is >= level.
/// This method is thread-safe. All output is prepended with the date & time, and log level.
/// </summary>
/// <example>2016-05-21 19:10:01Z INFO: This is the message.</example>
/// <param name="level">The logging level of this message.</param>
/// <param name="writer">The stream to where the output is sent.</param>
/// <param name="format">The format string to be printed.</param>
/// <param name="args">(optional) The arguments for the format string.</param>
protected void Write(VerboseLevel level, TextWriter writer, string format, params Object[] args)
{
ThrowIf.ArgumentNull(writer, nameof(writer));
if (ShouldWrite(level))
{
string datetime = DateTime.Now.ToString("u", CultureInfo.InvariantCulture);
format = StringUtils.FormatInvariant("{0} {1}: {2}", datetime, level.ToString(), format);
lock (_lock)
{
if (args == null)
{
writer.WriteLine(format);
}
else
{
writer.WriteLine(format, args);
}
}
}
}
/// <summary>
/// Ignore all messages of this verbose level.
/// </summary>
public void IgnoreAll(VerboseLevel level)
{
m_subscriber.Subscribe(PublisherFilter.CreateUniversal(), MessageAttributeFilter.Create(level), true);
}
/// <summary>
/// Ignore all messages of this verbose level.
/// </summary>
public void IgnoreType(Type type, VerboseLevel level)
{
if (type == null)
throw new ArgumentNullException(nameof(type));
m_subscriber.Subscribe(PublisherFilter.CreateType(type), MessageAttributeFilter.Create(level), true);
}
/// <summary>
/// Ignore all messages of this verbose level.
/// </summary>
public void IgnoreAssembly(string assemblyExpression, VerboseLevel level)
{
if (assemblyExpression == null)
throw new ArgumentNullException(nameof(assemblyExpression));
m_subscriber.Subscribe(PublisherFilter.CreateAssembly(assemblyExpression), MessageAttributeFilter.Create(level), true);
}
/// <summary>
/// Subscribes to all publishers with the specified verbose level.
/// </summary>
public void SubscribeToAll(VerboseLevel level)
{
m_subscriber.Subscribe(PublisherFilter.CreateUniversal(), MessageAttributeFilter.Create(level), false);
}
/// <summary>
/// Subscribes to the publisher of the specified type expression with the specified verbose level.
/// </summary>
/// <param name="typeExpression">An expression of the name of a type. Must include a * or ? to be considered an expression.</param>
/// <param name="level">The level</param>
public void SubscribeToType(string typeExpression, VerboseLevel level)
{
if (typeExpression == null)
throw new ArgumentNullException(nameof(typeExpression));
m_subscriber.Subscribe(PublisherFilter.CreateType(typeExpression), MessageAttributeFilter.Create(level), false);
}
/// does the logging.
/// @param str the string to log
/// @param category the category of the log
/// @param source the source of the log
/// @param logLevel what level to show and how to show it
public virtual void Log(string str, Categories category, Sources source, VerboseLevel logLevel)
{
if (logLevel < m_minLevelToShow)
return; // too low a level
if (m_categoriesToShow[(int)category] && m_sourcesToShow[(int)source])
{
if (logLevel == VerboseLevel.Verbose)
Debug.Log(str);
else if (logLevel == VerboseLevel.Warning)
Debug.LogWarning(str);
else Debug.LogError(str);
}
}
/// <summary>
/// Sends a verbose message.
/// </summary>
/// <param name="sourceLineNumbers">Source line numbers.</param>
/// <param name="verboseLevel">Level of the verbose message.</param>
/// <param name="verboseMessage">Verbose message string.</param>
public void OnVerbose(SourceLineNumberCollection sourceLineNumbers, VerboseLevel verboseLevel, string verboseMessage)
{
this.messageHandler.OnExtensionVerbose(sourceLineNumbers, verboseLevel, verboseMessage);
}
/// <summary>
/// Instantiate a new message handler.
/// </summary>
/// <param name="shortAppName">Short application name; usually 4 uppercase characters.</param>
/// <param name="longAppName">Long application name; usually the executable name.</param>
public MessageHandler(string shortAppName, string longAppName)
{
this.shortAppName = shortAppName;
this.longAppName = longAppName;
this.lastErrorNumber = SuccessErrorNumber;
this.sourceTrace = false;
this.verbosityLevel = VerboseLevel.Off;
this.warningLevel = WarningLevel.Minor;
this.warningAsError = false;
this.suppressedWarnings = new Hashtable();
}
/// <summary>
/// Sets log file writer path and optionally its verbosity level.
/// </summary>
public void SetPath(string logDirectory, VerboseLevel level)
{
FilePath.ValidatePathName(logDirectory);
lock (m_syncRoot)
{
Verbose = level;
m_path = logDirectory;
m_flushTask.Start(1000);
}
}
/// <summary>
/// Subscribes to the publisher of the specified assembly with the specified verbose level.
/// </summary>
public void SubscribeToAssembly(Assembly assembly, VerboseLevel level)
{
if (assembly == null)
throw new ArgumentNullException(nameof(assembly));
m_subscriber.Subscribe(PublisherFilter.CreateAssembly(assembly), MessageAttributeFilter.Create(level), false);
}
/// <summary>
/// VerboseEventArgs Constructor.
/// </summary>
/// <param name="level">Level of the verbose message.</param>
/// <param name="message">Verbose message content.</param>
public VerboseEventArgs(VerboseLevel level, string message)
{
this.level = level;
this.message = message;
}
/// <summary>
/// Sends an error to the message delegate if there is one.
/// </summary>
/// <param name="sourceLineNumbers">Source line numbers.</param>
/// <param name="verboseLevel">Level of the verbose message.</param>
/// <param name="verboseMessage">Verbose message string.</param>
public void OnExtensionVerbose(SourceLineNumberCollection sourceLineNumbers, VerboseLevel verboseLevel, string verboseMessage)
{
this.OnMessage(WixVerboses.LinkerExtensionVerbose(sourceLineNumbers, verboseLevel, verboseMessage));
}
/// <summary>
/// Creates a <see cref="LogSubscriber"/>
/// </summary>
/// <returns></returns>
public static LogSubscriber CreateSubscriber(VerboseLevel level = VerboseLevel.None)
{
var subscriber = new LogSubscriber(s_logger.CreateSubscriber());
subscriber.SubscribeToAll(level);
return subscriber;
}
public MatchVerbose(LogMessageSerializable typeName)
{
m_typeName = typeName.Level;
}
/// <summary>
/// Sends a verbose message.
/// </summary>
/// <param name="verboseLevel">Level of the verbose message.</param>
/// <param name="verboseMessage">Verbose message string.</param>
public void OnExtensionVerbose(VerboseLevel verboseLevel, string verboseMessage)
{
this.OnMessage(WixVerboses.DecompilerExtensionVerbose(verboseLevel, verboseMessage));
}