private static void ParseAppender(int appendersCount, ICollection <IAppender> appenders)
{
var appenderFActory = new AppenderFactory();
for (int i = 0; i < appendersCount; i++)
{
var appenderArgs = ConsoleReader.ReadLine().Split(' ', StringSplitOptions.RemoveEmptyEntries);
var appenderType = appenderArgs[0];
var layoutType = appenderArgs[1];
var level = "Info";
if (appenderArgs.Length == 3)
{
level = appenderArgs[2];
}
try
{
var appender = appenderFActory.ProduceAppednder(appenderType, layoutType, level);
appenders.Add(appender);
}
catch (Exception ex)
{
ConsoleWriter.WriteLine(ex.Message);
}
}
}
private static ILogger CreateLogger()
{
ICollection <IAppender> appenders = new List <IAppender>();
LayoutFactory layoutFactory = new LayoutFactory();
FileFactory fileFactory = new FileFactory();
AppenderFactory appenderFactory = new AppenderFactory(layoutFactory, fileFactory);
int appendersCount = int.Parse(Console.ReadLine());
for (int i = 0; i < appendersCount; i++)
{
string[] args = Console.ReadLine().Split();
string appenderType = args[0];
string layoutType = args[1];
string level = "";
if (args.Length == 3)
{
level = args[2];
}
IAppender appender = appenderFactory.Create(appenderType, layoutType, level);
appenders.Add(appender);
}
ILogger logger = new Logger(appenders);
return(logger);
}
static ILogger InstalizeLogger()
{
ICollection <IAppender> appenders = new List <IAppender>();
LayoutFactory layoutFactory = new LayoutFactory();
AppenderFactory appenderFactory = new AppenderFactory(layoutFactory);
var nunberOfAppenders = int.Parse(Console.ReadLine());
for (int i = 0; i < nunberOfAppenders; i++)
{
string[] args = Console.ReadLine().Split();
string appenderType = args[0];
string layoutType = args[1];
string errorLevel = "INFO";
if (args.Length == 3)
{
errorLevel = args[2];
}
IAppender appender = appenderFactory.CreateAppender(appenderType, errorLevel, layoutType);
appenders.Add(appender);
}
ILogger logger = new Logger(appenders);
return(logger);
}
static void Main(string[] args)
{
int appenderCount = int.Parse(Console.ReadLine());
IAppender[] appenders = new IAppender[appenderCount];
for (int i = 0; i < appenderCount; i++)
{
string[] appenderInfo = Console.ReadLine().Split();
ILayout currentLayout = LayoutFactory.GetInstance(appenderInfo[1]);
IAppender currentAppender = AppenderFactory.GetInstance(appenderInfo[0], currentLayout);
if (appenderInfo.Length > 2)
{
string enumName = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(appenderInfo[2].ToLower());
currentAppender.ReportLevel = (ReportLevel)Enum.Parse(typeof(ReportLevel), enumName);
}
appenders[i] = currentAppender;
}
ILogger logger = new Log(appenders);
string input;
while ((input = Console.ReadLine()) != "END")
{
string[] messageParts = input.Split('|');
string methodName = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(messageParts[0].ToLower());
MethodInfo currentMethod = typeof(Log).GetMethod(methodName);
currentMethod.Invoke(logger, new string[] { messageParts[1], messageParts[2] });
}
Console.WriteLine(logger);
Console.ReadLine();
}
static ILogger InitializeLogger()
{
ICollection <IAppender> appenders = new List <IAppender>();
LayoutFactory layoutFactory = new LayoutFactory();
AppenderFactory appenderFactory = new AppenderFactory(layoutFactory);
int numberOfAppenders = int.Parse(Console.ReadLine());
for (int i = 0; i < numberOfAppenders; i++)
{
string[] tokens = Console.ReadLine().Split();
string appenderType = tokens[0];
string layoutType = tokens[1];
//Default ErrorLevel => INFO
string levelOfError = "INFO";
if (tokens.Length == 3)
{
levelOfError = tokens[2];
}
IAppender appender = appenderFactory.CreateAppender(appenderType, layoutType, levelOfError);
appenders.Add(appender);
}
ILogger logger = new Logger(appenders);
return(logger);
}
public static Logger CreateLogger(int appenderNum)
{
for (int i = 0; i < appenderNum; i++)
{
//TODO: Have this read from the CommandInterpreter rather than the Console
string[] appenderInfo = Console.ReadLine().Split();
string appenderType = appenderInfo[0];
string layoutType = appenderInfo[1];
ReportLevel reportLevel = 0;
if (appenderInfo.Length == 3)
{
reportLevel = (ReportLevel)ReportLevel.Parse(typeof(ReportLevel), appenderInfo[2]);
}
//Creates the layout
ILayout layout = LayoutFactory.CreateLayout(layoutType);
//Creates the appender with the corresponding layout
IAppender appender = AppenderFactory.CreateAppender(appenderType, layout, reportLevel);
appenders.Add(appender);
}
//Returns the logger, with all the appenders from the list
var logger = new Logger(appenders.ToArray());
return(logger);
}
public ILogger InitializeLogger()
{
var appenders = new List <IAppender>();
var layoutFactory = new LayoutFactory();
var appenderFactory = new AppenderFactory(layoutFactory);
int appenderCount = int.Parse(Console.ReadLine());
for (int i = 0; i < appenderCount; i++)
{
var input = Console.ReadLine().Split();
var appenderType = input[0];
var layoutType = input[1];
var reportLevel = "INFO";
if (input.Length == 3)
{
reportLevel = input[2];
}
var appender = appenderFactory.CreateAppender(appenderType, layoutType);
bool isValidReportLevel = Enum.TryParse(typeof(ReportLevel), reportLevel, out object repLevel);
if (isValidReportLevel)
{
appender.ReportLevel = (ReportLevel)repLevel;
}
appenders.Add(appender);
}
var logger = new Logger(appenders);
return(logger);
}
static ILogger InitializeLogger()
{
LayoutFactory layoutFactory = new LayoutFactory();
ICollection <IAppender> appenders = new List <IAppender>();
AppenderFactory appenderFactory = new AppenderFactory(layoutFactory);
int appenderCount = int.Parse(Console.ReadLine());
for (int i = 0; i < appenderCount; i++)
{
string[] args = Console.ReadLine().Split();
string errorLevel = "INFO";
if (args.Length == 3)
{
errorLevel = args[2];
}
IAppender appender = appenderFactory.CreateAppender(args[0], errorLevel, args[1]);
appenders.Add(appender);
}
ILogger logger = new Logger(appenders);
return(logger);
}
static ILogger InitializeLogger()
{
ICollection <IAppender> appenders = new List <IAppender>();
LayoutFactory layoutFactory = new LayoutFactory();
AppenderFactory appenderFactory = new AppenderFactory(layoutFactory);
int appendersCount = int.Parse(Console.ReadLine());
for (int i = 0; i < appendersCount; i++)
{
string[] inputArgs = Console.ReadLine().Split();
string appenderType = inputArgs[0];
string layoutType = inputArgs[1];
string stringReportLevel = "INFO";
if (inputArgs.Length == 3)
{
stringReportLevel = inputArgs[2];
}
IAppender appender = appenderFactory.CreateApender(appenderType, stringReportLevel, layoutType);
appenders.Add(appender);
}
ILogger logger = new Logger(appenders);
return(logger);
}
public static void Main()
{
var appendersCount = int.Parse(Console.ReadLine());
IAppender[] appenders = new IAppender[appendersCount];
for (int i = 0; i < appendersCount; i++)
{
var appenderInfo = Console.ReadLine().Split();
ILayout currentLayout = LayoutFactory.GetInstance(appenderInfo[1]);
var currAppender = AppenderFactory.GetAppender(appenderInfo[0], currentLayout);
if (appenderInfo.Length > 2)
{
string enumName = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(appenderInfo[2].ToLower());
currAppender.ReportLevel = (ReportLevel)Enum.Parse(typeof(ReportLevel), enumName);
}
appenders[i] = currAppender;
}
var myLogger = new Entities.Logger(appenders);
string input;
while ((input = Console.ReadLine()) != "END")
{
var tokens = input.Split('|');
var methodName = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(tokens[0].ToLower());
MethodInfo currentMethod = typeof(Entities.Logger).GetMethod(methodName);
currentMethod.Invoke(myLogger, new object[] { tokens[1], tokens[2] });
}
Console.WriteLine(myLogger);
}
static ILogger InitializeLogger()
{
ICollection <IAppender> appenders = new List <IAppender>();
LayoutFactory layoutFactory = new LayoutFactory();
AppenderFactory appenderFactory = new AppenderFactory(layoutFactory);
var appendersCount = int.Parse(Console.ReadLine());
for (int i = 0; i < appendersCount; i++)
{
var input = Console.ReadLine().Split(" ");
var appenderType = input[0];
var layoutType = input[1];
string errorLevel = "INFO";
if (input.Length == 3)
{
errorLevel = input[2];
}
IAppender newAppender = appenderFactory.GetAppender(appenderType, errorLevel, layoutType);
appenders.Add(newAppender);
}
ILogger logger = new Logger(appenders);
return(logger);
}
static ILogger CreateLogger()
{
var appenders = new List <IAppender>();
var amountOfAppenders = int.Parse(Console.ReadLine());
var layoutFactory = new LayoutFactory();
var appenderFacotry = new AppenderFactory(layoutFactory);
for (int i = 0; i < amountOfAppenders; i++)
{
var dataArgs = Console.ReadLine().Split();
var appenderType = dataArgs[0];
var layoutType = dataArgs[1];
var errorLevel = "INFO";
if (dataArgs.Length == 3)
{
errorLevel = dataArgs[2];
}
var appender = appenderFacotry.CreateAppender(appenderType, errorLevel, layoutType);
appenders.Add(appender);
}
var logger = new Logger(appenders);
return(logger);
}
public void Run()
{
var numberOfAppenders = int.Parse(Console.ReadLine());
var appenderFactory = new AppenderFactory();
var logger = new Logger.Logger(appenderFactory.CreateAppenders(numberOfAppenders));
while (true)
{
var input = Console.ReadLine();
if (input == "END")
{
break;
}
var logArgs = input.Split("|");
var errorLevel = (ReportLevel)Enum.Parse(typeof(ReportLevel), logArgs[0], true);
var time = DateTime.ParseExact(logArgs[1], "M/dd/yyyy h:mm:ss tt", CultureInfo.InvariantCulture);
var message = logArgs[2];
logger.CallAppenders(new Error(time, errorLevel, message));
}
foreach (var appender in logger.Appenders)
{
Console.WriteLine(appender);
}
}
private static void ReadAppendersData(int appendersCount,
ICollection <IAppender> appenders,
AppenderFactory appenderFactory)
{
for (int i = 0; i < appendersCount; i++)
{
string[] appendersInfo = Console.ReadLine()
.Split(" ")
.ToArray();
string appenderType = appendersInfo[0];
string layoutType = appendersInfo[1];
string levelStr = "INFO";
if (appendersInfo.Length == 3)
{
levelStr = appendersInfo[2];
}
try
{
IAppender appender = appenderFactory.GetAppender(appenderType, layoutType, levelStr);
appenders.Add(appender);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
continue;
}
}
}
private static ILogger SetUpLogger(int appendersCount, IReader reader, IWriter writer, IFile file
, LayoutFactory layoutFactory, AppenderFactory appenderFactory)
{
ICollection <IAppender> appenders = new HashSet <IAppender>();
for (int i = 0; i < appendersCount; i++)
{
string[] appArg = reader.ReadLine().Split(" ", StringSplitOptions.RemoveEmptyEntries);
string appenderType = appArg[0];
string layoutType = appArg[1];
bool hasError = false;
Level level = ParseLevel(appArg, writer, ref hasError);
if (hasError)
{
continue;
}
try
{
ILayout layout = layoutFactory.CreateLayout(layoutType);
IAppender appender = appenderFactory.CreaterAppender(appenderType, layout, level, file);
appenders.Add(appender);
}
catch (InvalidOperationException ex)
{
writer.WriteLine(ex.Message);
}
}
ILogger logger = new Logger(appenders);
return(logger);
}
private static void ParseAppendersInput(int appendersCount, ICollection <IAppender> appenders)
{
AppenderFactory appenderFacotry = new AppenderFactory();
for (int i = 0; i < appendersCount; i++)
{
string[] appendersArgs = Console.ReadLine().Split(' ', StringSplitOptions.RemoveEmptyEntries).ToArray();
string appenderType = appendersArgs[0];
string layoutType = appendersArgs[1];
string reportLevel = "INFO";
if (appendersArgs.Length == 3)
{
reportLevel = appendersArgs[2];
}
try
{
IAppender appender = appenderFacotry.ProduceAppender(appenderType, layoutType, reportLevel);
appenders.Add((appender));
}
catch (ArgumentException ae)
{
Console.WriteLine(ae.Message);
}
}
}
private static List <IAppender> CreateAppenders()
{
var appenders = new List <IAppender>();
var layoutFactory = new LayoutFactory();
var appenderFactory = new AppenderFactory();
int appendCount = int.Parse(Console.ReadLine());
for (int i = 0; i < appendCount; i++)
{
var tokens = Console.ReadLine().Split();
var appenderType = tokens[0];
var layoutType = tokens[1];
var errorStr = "INFO";
if (tokens.Length == 3)
{
errorStr = tokens[2];
}
ILayout layout = layoutFactory.Create(layoutType);
IAppender appender = appenderFactory.Create(layout, errorStr, appenderType);
appenders.Add(appender);
}
return(appenders);
}
public void should_load_configuration()
{
var appenderAConfig = new DefaultAppenderConfig {
PrefixPattern = "[%level] @ %time - %logger: "
};
var appenderBConfig = new DateAndSizeRollingFileAppenderConfig {
FilePathRoot = "totopath "
};
var appenderA = new AppenderDefinition {
Name = "A", AppenderTypeName = nameof(ConsoleAppender), AppenderJsonConfig = appenderAConfig
};
var appenderB = new AppenderDefinition {
Name = "B", AppenderTypeName = nameof(DateAndSizeRollingFileAppender), AppenderJsonConfig = appenderBConfig
};
var config = new ZeroLogJsonConfiguration
{
LogEventBufferSize = 5,
LogEventQueueSize = 7,
RootLogger = new LoggerDefinition
{
Level = Level.Warn,
LogEventPoolExhaustionStrategy = LogEventPoolExhaustionStrategy.DropLogMessage,
AppenderReferences = new[] { "A" },
},
Appenders = new[] { appenderA, appenderB },
Loggers = new[] { new LoggerDefinition {
Name = "Abc.Zebus", Level = Level.Debug, AppenderReferences = new[] { "B" }
} }
};
var configJson = JsonConvert.SerializeObject(config);
var loadedConfig = JsonConfigurator.DeserializeConfiguration(configJson);
Check.That(loadedConfig.LogEventBufferSize).Equals(config.LogEventBufferSize);
Check.That(loadedConfig.LogEventQueueSize).Equals(config.LogEventQueueSize);
Check.That(loadedConfig.RootLogger.Level).Equals(config.RootLogger.Level);
Check.That(loadedConfig.RootLogger.AppenderReferences.Single()).Equals(config.RootLogger.AppenderReferences.Single());
Check.That(loadedConfig.Appenders.Single(a => a.Name == "A").Name).Equals(appenderA.Name);
Check.That(loadedConfig.Appenders.Single(a => a.Name == "A").AppenderTypeName).Equals(appenderA.AppenderTypeName);
Check.That(loadedConfig.Appenders.Single(a => a.Name == "B").Name).Equals(appenderB.Name);
Check.That(loadedConfig.Appenders.Single(a => a.Name == "B").AppenderTypeName).Equals(appenderB.AppenderTypeName);
var appenderALoadedConfig = (DefaultAppenderConfig)AppenderFactory.GetAppenderParameters(loadedConfig.Appenders.Single(a => a.Name == "A"), typeof(DefaultAppenderConfig));
Check.That(appenderALoadedConfig.PrefixPattern).IsEqualTo(appenderAConfig.PrefixPattern);
var appenderBLoadedConfig = (DateAndSizeRollingFileAppenderConfig)AppenderFactory.GetAppenderParameters(loadedConfig.Appenders.Single(a => a.Name == "B"), typeof(DateAndSizeRollingFileAppenderConfig));
Check.That(appenderBLoadedConfig.Extension).IsEqualTo(appenderBConfig.Extension);
Check.That(appenderBLoadedConfig.PrefixPattern).IsEqualTo(appenderBConfig.PrefixPattern);
Check.That(appenderBLoadedConfig.FilePathRoot).IsEqualTo(appenderBConfig.FilePathRoot);
Check.That(appenderBLoadedConfig.MaxFileSizeInBytes).IsEqualTo(appenderBConfig.MaxFileSizeInBytes);
}
public static void Main()
{
IFactory <IAppender> appenderFactory = new AppenderFactory <IAppender>();
IFactory <ILayout> layoutFactory = new LayoutFactory <ILayout>();
IEngine engine = new Engine(appenderFactory, layoutFactory);
engine.Run();
}
public Engine()
{
this.reader = new Reader();
this.logConsole = new LogConsole();
this.MainLogger = new MainLogger();
this.appenderFactory = new AppenderFactory();
this.logFactory = new LogFactory();
}
private static void Main(string[] args)
{
IFactory <IAppender> appenderFactory = new AppenderFactory <IAppender>();
IFactory <ILayout> layoutFactory = new LayoutFactory <ILayout>();
IEngine engine = new Engine(appenderFactory, layoutFactory);
engine.Run();
}
public LoggerController(IInputReader inputReader, IOutputWriter outputWriter)
{
this.inputReader = inputReader;
this.outputWriter = outputWriter;
this.appenderFactory = new AppenderFactory();
this.layoutFactory = new LayoutFactory();
this.reportFactory = new ReportFactory();
}
public Engine(LoggerFactory loggerFactory, AppenderFactory appenderFactory, LayoutFactory layoutFactory) : this()
{
this.loggerFactory = loggerFactory;
this.appenderFactory = appenderFactory;
this.layoutFactory = layoutFactory;
GetAppenders();
SetLogger(this.loggerType);
}
public static void Main(string[] args)
{
ILayoutFactory layoutFactory = new LayoutFactory();
IAppenderFactory appenderFactory = new AppenderFactory();
ICommandInterpreter commandInterpreter = new CommandInterpreter(layoutFactory, appenderFactory);
IEngine engine = new Engine(commandInterpreter);
engine.Run();
}
private static void Main(string[] args)
{
LoggerFactory loggerFactory = new LoggerFactory();
AppenderFactory appenderFactory = new AppenderFactory();
LayoutFactory layoutFactory = new LayoutFactory();
Engine engine = new Engine(loggerFactory, appenderFactory, layoutFactory);
engine.Run();
}
static void Main(string[] args)
{
IAppenderFactory appenderFactory = new AppenderFactory();
ILayoutFactory layoutFactory = new LayoutFactory();
IReader reader = new FileReader();
IEngine engine = new Engine(appenderFactory, layoutFactory, reader);
engine.Run();
}
static void Main(string[] args)
{
int numberOfAppenders = Int32.Parse(Console.ReadLine());
IAppender[] appenders = new IAppender[numberOfAppenders];
for (int i = 0; i < numberOfAppenders; i++)
{
string[] words = Console.ReadLine().Split(' ');
IAppender appender = AppenderFactory.CreateAppender(words[0], words[1]);
if (words.Length > 2)
{
ReportLevel level = (ReportLevel)Enum.Parse(typeof(ReportLevel), words[2]);
appender.ReportLevel = level;
}
appenders[i] = appender;
}
var logger = new Logger(appenders);
string commandInput;
while ((commandInput = Console.ReadLine()).ToLower() != "end")
{
var words = commandInput.Split('|');
string time = words[1];
string msg = words[2];
ReportLevel level = (ReportLevel)Enum.Parse(typeof(ReportLevel), words[0]);
switch (level)
{
case ReportLevel.CRITICAL:
logger.Critical(time, msg);
break;
case ReportLevel.ERROR:
logger.Error(time, msg);
break;
case ReportLevel.FATAL:
logger.Fatal(time, msg);
break;
case ReportLevel.INFO:
logger.Info(time, msg);
break;
case ReportLevel.WARNING:
logger.Warning(time, msg);
break;
}
}
Console.WriteLine(logger);
Console.ReadLine();
}
public static void Main()
{
ILayoutFactory layoutFactory = new LayoutFactory();
IAppenderFactory appenderFactory = new AppenderFactory();
IReportLevelFactory reportLevelFactory = new ReportLevelFactory();
ILogger logger = new Logger();
IRunnable engine = new Engine(logger, layoutFactory, appenderFactory, reportLevelFactory);
engine.Run();
}
public static void Main()
{
int appendersCount = int.Parse(Console.ReadLine());
List <IAppender> appenders = new List <IAppender>();
for (int i = 0; i < appendersCount; i++)
{
string[] appenderInfo = Console.ReadLine().Split().ToArray();
IAppender appender = AppenderFactory.Get(appenderInfo);
appenders.Add(appender);
}
ILogger logger = new Logger(appenders);
string line = Console.ReadLine();
while (line != "END")
{
string[] messageInfo = line.Split("|").ToArray();
string type = messageInfo[0];
string date = messageInfo[1];
string message = messageInfo[2];
switch (type)
{
case "INFO":
logger.Info(date, message);
break;
case "WARNING":
logger.Warning(date, message);
break;
case "ERROR":
logger.Error(date, message);
break;
case "CRITICAL":
logger.Critical(date, message);
break;
case "FATAL":
logger.Fatal(date, message);
break;
}
line = Console.ReadLine();
}
Console.WriteLine(logger);
}
private static void InitializeAppenders(ICollection <IAppender> appenders,
string typeOfAppender,
string typeOfLayout,
string typeOfReportLevel)
{
AppenderFactory appenderFactory = new AppenderFactory();
IAppender appender = appenderFactory.CreateAppender(typeOfAppender,
typeOfLayout, typeOfReportLevel);
appenders.Add(appender);
}
