static void Main(string[] args)
{
ILayout simpleLayout = new SimpleLayout();
IAppender consoleAppender = new ConsoleAppender(simpleLayout);
var fileAppender = new FileAppender(simpleLayout);
fileAppender.File = "../../log.txt";
var logger = new Logger(consoleAppender, fileAppender);
logger.Error("Error parsing JSON.");
logger.Info(string.Format("User {0} successfully registered.", "Pesho"));
logger.Warn("Warning - missing files.");
var xmlLayout = new XmlLayout();
consoleAppender = new ConsoleAppender(xmlLayout);
logger = new Logger(consoleAppender);
logger.Fatal("mscorlib.dll does not respond");
logger.Critical("No connection string found in App.config");
consoleAppender = new ConsoleAppender(simpleLayout);
consoleAppender.ReportLevel = ReportLevel.Error;
logger = new Logger(consoleAppender);
logger.Info("Everything seems fine");
logger.Warn("Warning: ping is too high - disconnect imminent");
logger.Error("Error parsing request");
logger.Critical("No connection string found in App.config");
logger.Fatal("mscorlib.dll does not respond");
}
public List <string> LoadAndExecuteControlHead(string pathDLL)
{
Queue <KeyValuePair <String, String> > testInfo = new Queue <KeyValuePair <string, string> >();
List <Dictionary <string, string> > list_of_Dict_of_Logs = new List <Dictionary <string, string> >();
List <string> logs_and_Path = new List <string>();
testInfo = AppDomain.CurrentDomain.GetData("file_Data") as Queue <KeyValuePair <String, String> >;
executor execute = new executor();
Console.WriteLine("\n>> Looking up Directory: {0}, To Load TestDrivers.\n", pathDLL);
" [[ Displaying Requirement 5 (can be verified from executor.cs -- lines 72-100 )]]".title('='); // Using the utilities.cs to print
if (execute.LoadingTests(pathDLL, testInfo)) // Loading Tests by call Executor
{
list_of_Dict_of_Logs = execute.run(testInfo, pathDLL); // Running Test Drivers
}
else
{
Console.WriteLine("\n==================>>>>> couldn't load tests");
}
// after everything is done, the loader will ask the logger to give back the location where logs are created..
Logger.Logger logObj = new Logger.Logger();
string logsPath = logObj.sendLogsDirectoryToLoader();
logs_and_Path.Add(logsPath);
for (int i = 0; i < list_of_Dict_of_Logs.Count; i++)
{
var dictToString = string.Join("; ", list_of_Dict_of_Logs[i].Select(p => string.Format("{0}, {1}", p.Key, p.Value)));
logs_and_Path.Add(dictToString);
}
return(logs_and_Path);
}
static void Main(string[] args)
{
IParser ourParser = new Converter.Converter();
string path = AppDomain.CurrentDomain.BaseDirectory;
OptionsManager <DataAccessOptions> optionsManager = new OptionsManager <DataAccessOptions>(path, ourParser);
LoggingOptions loggingOptions = new LoggingOptions();
// Getting options using OptionsManager.
loggingOptions.ConnectionOptions = optionsManager.GetOptions <ConnectionOptions>() as ConnectionOptions;
SendingOptions sendingOptions = optionsManager.GetOptions <SendingOptions>() as SendingOptions;
ConnectionOptions connectionOptions = optionsManager.GetOptions <ConnectionOptions>() as ConnectionOptions;
ILogger logger = new Logger.Logger(loggingOptions, ourParser);
ServiceLayer.ServiceLayer sl = new ServiceLayer.ServiceLayer(connectionOptions, ourParser);
logger.Log(optionsManager.log);
// Getting info from DB.
logger.Log("Pulling of the data has been started...");
var people = sl.GetPersonInfoList(200);
logger.Log("Pulling of the data has been done successfully!");
// Creating XMl file.
XmlGenerator.XmlGenerator generator = new XmlGenerator.XmlGenerator(sendingOptions);
generator.CreateXML(people);
logger.Log("Xml file was created successfully");
}
static void Main(string[] args)
{
string appDirectory = AppDomain.CurrentDomain.BaseDirectory;
Parser.Parser parser = new Parser.Parser();
IValidator validator = new Validator();
OptionsManager <DataAccessOptions> options =
new OptionsManager <DataAccessOptions>(appDirectory, parser, validator);
LoggerOptions loggerOptions = new LoggerOptions();
loggerOptions.ConnectionOptions = options.GetOptions <ConnectionOptions>() as ConnectionOptions;
Logger.Logger logger = new Logger.Logger(loggerOptions);
logger.Log(options.LogString);
ServiceLayer.ServiceLayer SL = new ServiceLayer.ServiceLayer(
options.GetOptions <ConnectionOptions>() as ConnectionOptions);
SendingOptions sendingOptions = options.GetOptions <SendingOptions>() as SendingOptions;
logger.Log("DataManager is retrieving data");
PersonData personInfo = SL.GetPersonInfo();
logger.Log("DataManager retrieved data");
XmlGeneratorService xmlGenerator = new XmlGeneratorService(sendingOptions);
xmlGenerator.SerializeXML(personInfo);
logger.Log("DataManager sent data to server");
}
static async Task Main(string[] args)
{
IParser parser = new Converter.Converter();
string path = AppDomain.CurrentDomain.BaseDirectory;
OptionsManager <DataAccessOptions> optionsManager = new OptionsManager <DataAccessOptions>(path, parser);
LoggingOptions loggingOptions = new LoggingOptions();
loggingOptions.ConnectionOptions = optionsManager.GetOptions <ConnectionOptions>() as ConnectionOptions;
SendingOptions sendingOptions = optionsManager.GetOptions <SendingOptions>() as SendingOptions;
ConnectionOptions connectionOptions = optionsManager.GetOptions <ConnectionOptions>() as ConnectionOptions;
ILogger logger = new Logger.Logger(loggingOptions, parser);
ServiceLayer.ServiceLayer sl = new ServiceLayer.ServiceLayer(connectionOptions, parser);
List <PersonInfo> people;
XmlGenerator.XmlGenerator generator = new XmlGenerator.XmlGenerator(sendingOptions);
logger.Log(optionsManager.log);
var watch = System.Diagnostics.Stopwatch.StartNew();
logger.Log("Pulling of the data has been started...");
Console.WriteLine("Pulling of the data has been started...");
people = await sl.GetPersonInfoListAsync(5000);
Console.WriteLine("Pulling of the data has been done successfully!");
watch.Stop();
Console.WriteLine($"Total execution time: {watch.ElapsedMilliseconds}");
logger.Log("Pulling of the data has been done successfully!");
generator.CreateXML(people);
logger.Log("Xml file was created successfully");
Console.ReadLine();
}
static void Main(string[] args)
{
string appDirectory = AppDomain.CurrentDomain.BaseDirectory;
Parser.Parser parser = new Parser.Parser();
IValidator validator = new Validator();
OptionsManager <DataAccessOptions> options =
new OptionsManager <DataAccessOptions>(appDirectory, parser, validator);
LoggerOptions loggerOptions = new LoggerOptions();
loggerOptions.ConnectionOptions = options.GetOptions <ConnectionOptions>() as ConnectionOptions;
Logger.Logger logger = new Logger.Logger(loggerOptions);
logger.Log(options.LogString);
ServiceLayer.ServiceLayer SL = new ServiceLayer.ServiceLayer(
options.GetOptions <ConnectionOptions>() as ConnectionOptions);
SendingOptions sendingOptions = options.GetOptions <SendingOptions>() as SendingOptions;
logger.Log("DataManager is fetching data");
PurchasingInfo purchasingInfo = SL.GetPurchasingInfo();
logger.Log("DataManager has fetch all data successfully!");
XmlGeneratorService xmlGenerator = new XmlGeneratorService(sendingOptions);
xmlGenerator.SerializeXML(purchasingInfo);
logger.Log("DataManager has sent all data tp FTP server successfully!");
}
static void createLogger()
{
log = new Logger.Logger();
Logger.ConsoleOutputter cons = new ConsoleOutputter();
Logger.FileOutputter file = new FileOutputter();
log.SetLoggerLevel(Level.DEBUG);
log.SetLoggerOutput(cons);
log.SetLoggerOutput(file);
}
public void Extensibility()
{
var xmlLayout = new XmlLayout();
var consoleAppender = new ConsoleAppender(xmlLayout);
var logger = new Logger.Logger(consoleAppender);
logger.Fatal("3/31/2015 5:23:54 PM", "mscorlib.dll does not respond");
logger.Critical("3/31/2015 5:23:54 PM", "No connection string found in App.config");
}
public void FirstSample()
{
ILayout simpleLayout = new SimpleLayout();
IAppender consoleAppender = new ConsoleAppender(simpleLayout);
ILogger logger = new Logger.Logger(consoleAppender);
logger.Error("3/26/2015 2:08:11 PM", "Error parsing JSON.");
logger.Info("3/26/2015 2:08:11 PM", "User Pesho successfully registered.");
}
static void Main(string[] args)
{
Logger.Logger logger = new Logger.Logger();
var helloWorld = new DataEngine.HelloWorld(logger);
var person = helloWorld.DescribePerson();
Console.WriteLine(helloWorld.GraphToString(person));
Console.ReadLine();
}
public void Test_Log_ReceivedWriteString()
{
var mockFileWorker = Substitute.For <IStorage>();
var logger = new Logger.Logger(mockFileWorker);
var message = "Hello World";
logger.Log(message);
mockFileWorker.Received().WriteString(message);
}
static void Main(string[] args)
{
var formatter = new XmlFormatter();
var appender = new ConsoleAppender(formatter);
var logger = new Logger(appender);
logger.Info("This is app");
logger.Error("Cannot be empty!");
logger.Critical("You are illigle");
}
public bool Connect(int port, string IP, short ID, string Logfile)
{
mLogFileName = Logfile;
mID = ID;
mIP = IP;
mPort = port;
#region logger
try
{
if (mLogger == null)
{
// instantiate the logger
mLogger = Logger.Logger.Instance;
// instantiate the log observer that will write to disk
mFileLogger = new FileLogger(this.mLogFileName);
mFileLogger.Init();
// Add mFileLogger to the Logger.
mLogger.RegisterObserver(mFileLogger);
mLogger.AddLogMessage("******* NEW RUN OF THE AGENT! *******");
}
}
catch (Exception)
{
Clean();
return(false);
}
#endregion logger
#region Communication
try
{
IPAddress ipAddress = IPAddress.Parse(mIP);
mComm.Init(mID, ipAddress, mPort);
mComm.SendMessage(Command.Login, mID.ToString());
mComm.Listen();
}
catch (Exception ex)
{
mLogger.AddLogMessage("Communication Init: " + ex.Message);
if (mLogger != null)
{
mFileLogger.Terminate();
}
return(false);
}
#endregion Communication
// connection established successfully
AHStateManager(GameState.Idle);
return(true);
}
static void createLogger()
{
log = new Logger.Logger();
Logger.ConsoleOutputter cons = new ConsoleOutputter();
Logger.FileOutputter file = new FileOutputter();
SocketOutputter sockLogger = new SocketOutputter("localhost", 1800);
log.SetLoggerOutput(sockLogger);
log.SetLoggerLevel(Level.FATAL);
log.SetLoggerOutput(cons);
log.SetLoggerOutput(file);
}
static void Main(string[] args)
{
using (Logger.Logger l = new Logger.Logger(ImportanceLevel.Debug, "log.txt"))
{
l.WriteLine(ImportanceLevel.Debug, "Message1 1 - {0}, 2 - {1}", "param1", 1);
l.WriteLine(ImportanceLevel.Debug, "Message2 1 - {0}, 2 - {1}", "param2", 2);
l.WriteLine(ImportanceLevel.Debug, "Message3 1 - {0}, 2 - {1}", "param3", 3);
l.WriteLine(ImportanceLevel.Debug, "Message4 1 - {0}, 2 - {1}", "param4", 4);
l.WriteLine(ImportanceLevel.Debug, "Message5 1 - {0}, 2 - {1}", "param5", 5);
Console.ReadKey();
}
}
static void Main(string[] args)
{
IParser parser = new Converter.Converter();
IValidator validator = new Validator();
string directory = AppDomain.CurrentDomain.BaseDirectory;
OptionsManager <DataAccessOptions> options =
new OptionsManager <DataAccessOptions>(directory, parser, validator);
LoggingOptions loggingOptions = new LoggingOptions();
//loggingOptions.ConnectingOptions = options.GetOptions<ConnectingOptions>() as ConnectingOptions;
loggingOptions.EnableLogging = true;
ILogger logger = new Logger.Logger(loggingOptions, parser);
ServiceLayer.ServiceLayer SL = new ServiceLayer.ServiceLayer(
options.GetOptions <ConnectingOptions>() as ConnectingOptions,
parser, logger);
SendingOptions sendingOptions = options.GetOptions <SendingOptions>() as SendingOptions;
logger.Log("Starting pulling data");
if (sendingOptions.PullingMode == SendingOptions.PullingModes.FullTable)
{
int curIndex = 1;
int maxID = SL.DAL.EmployeeMaxID();
List <HumanResourcesInfo> info;
while (curIndex < maxID)
{
info = SL.GetPersonsRange(curIndex, sendingOptions.BatchSize);
int lastID = info.Last().Employee.BusinessEntityID;
string s = parser.SerializeXML(info);
using (StreamWriter sw = new StreamWriter($@"{sendingOptions.Target}\file{curIndex}-{lastID}.txt"))
{
sw.Write(s);
}
curIndex = lastID + 1;
}
}
else if (sendingOptions.PullingMode == SendingOptions.PullingModes.ByBatches)
{
List <HumanResourcesInfo> info = SL.GetEmployees();
SplitOnBatches(info, sendingOptions, parser);
}
else if (sendingOptions.PullingMode == SendingOptions.PullingModes.FullJoin)
{
List <HumanResourcesInfo> info = SL.GetHumanResourcesByJoin();
SplitOnBatches(info, sendingOptions, parser);
}
logger.Log("Pulled all data successfully");
}
public static void Main()
{
var simpleLayout = new SimpleLayout();
var consoleAppender = new ConsoleAppender(simpleLayout);
var fileAppender = new FileAppender(simpleLayout);
fileAppender.File = "log.txt";
var logger = new Logger(consoleAppender, fileAppender);
logger.Error("Error parsing JSON.");
logger.Info(string.Format("User {0} successfully registered.", "Pesho"));
logger.Warn("Warning - missing files.");
}
public static void Main()
{
var simpleLayout = new SimpleLayout();
var consoleAppender = new ConsoleAppender(simpleLayout);
consoleAppender.ReportLevel = ReportLevel.Error;
var logger = new Logger(consoleAppender);
logger.Info("Everything seems fine");
logger.Warn("Warning: ping is too high - disconnect imminent");
logger.Error("Error parsing request");
logger.Critical("No connection string found in App.config");
logger.Fatal("mscorlib.dll does not respond");
}
private static void Main(string[] args)
{
ILogger log = new Logger.Logger();
log.Info("hello world.");
ICalc calc = new Calc.Calc();
var r = calc.Sub(1, 2);
log.Warn($"result less than zero: {r}");
Console.WriteLine("press any key!");
Console.ReadLine();
}
public void ServerIsLogging()
{
Server server = new Server(new TestCommands(), correctSettings);
Thread serverThread = new Thread(new ThreadStart(server.Run));
serverThread.Start();
Thread.Sleep(100);
try
{
Logger.Logger serverLogger = server.GetLogger();
Assert.IsTrue(serverLogger.Logs[0].Text.Contains("Server started"));
Assert.AreEqual(EntryLevel.Server, serverLogger.Logs[0].Level);
Assert.AreEqual(1, serverLogger.Logs.Count());
}
finally
{
if (server != null)
{
server.Stop();
}
}
server = new Server(null, correctSettings);
serverThread = new Thread(new ThreadStart(server.Run));
serverThread.Start();
Thread.Sleep(100);
try
{
Logger.Logger serverLogger = server.GetLogger();
Assert.IsTrue(serverLogger.Logs[0].Text.Contains("Server started"));
Assert.AreEqual(EntryLevel.Server, serverLogger.Logs[0].Level);
Assert.AreEqual("Commands slot is void", serverLogger.Logs[1].Text);
Assert.AreEqual(EntryLevel.Server, serverLogger.Logs[1].Level);
Send("test");
Regex regex = new Regex("CLIENT-T-\\d+ REQUEST: test RESPONSE: c0");
Assert.IsTrue(regex.IsMatch(serverLogger.Logs.LastByTime().Text));
Assert.AreEqual(EntryLevel.User, serverLogger.Logs.LastByTime().Level);
}
finally
{
if (server != null)
{
server.Stop();
}
}
}
public void Test_ReadLog_GetString()
{
var stubFileWorker = Substitute.For <IStorage>();
var logger = new Logger.Logger(stubFileWorker);
stubFileWorker.ReadStrings().Returns(new List <string>()
{
"one", "two", "three"
});
var result = logger.ReadLog();
Assert.AreEqual("one\r\ntwo\r\nthree\r\n", result);
}
public void ReportThreshold()
{
var simpleLayout = new SimpleLayout();
var consoleAppender = new ConsoleAppender(simpleLayout);
consoleAppender.ReportLevel = ReportLevel.Error;
var logger = new Logger.Logger(consoleAppender);
logger.Info("3/31/2015 5:33:07 PM", "Everything seems fine");
logger.Warn("3/31/2015 5:33:07 PM", "Warning: ping is too high - disconnect imminent");
logger.Error("3/31/2015 5:33:07 PM", "Error parsing request");
logger.Critical("3/31/2015 5:33:07 PM", "No connection string found in App.config");
logger.Fatal("3/31/2015 5:33:07 PM", "mscorlib.dll does not respond");
}
public void Implementations()
{
var simpleLayout = new SimpleLayout();
var consoleAppender = new ConsoleAppender(simpleLayout);
var file = new LogFile();
var fileAppender = new FileAppender(simpleLayout)
{
File = file
};
var logger = new Logger.Logger(consoleAppender, fileAppender);
logger.Error("3/26/2015 2:08:11 PM", "Error parsing JSON.");
logger.Info("3/26/2015 2:08:11 PM", "User Pesho successfully registered.");
}
public static void Main()
{
ILayout simpleLayout = new SimpleLayout();
IDataAppender consoleAppender =
new ConsoleAppender(simpleLayout);
ILogger logger = new Logger(consoleAppender);
logger.Error("Error parsing JSON.");
logger.Info($"User {"Pesho"} successfully registered.");
var fileAppender = new FileAppender(simpleLayout, "log.txt");
logger = new Logger(fileAppender);
logger.Error("Error parsing JSON.");
logger.Info($"User {"Pesho"} successfully registered.");
logger.Warn("Warning - missing files.");
}
static void Main()
{
FileOutputter file = new FileOutputter();
log = new Logger.Logger();
log.SetLoggerLevel(Level.DEBUG);
log.SetLoggerOutput(file);
tcpListener.Start();
//listenerForLogger.Start();
Thread threadForServer = new Thread(RunServer);
threadForServer.Start();
s = new Server();
s.ShowDialog();
}
static void Main()
{
IFormatter formatter = new JsonFormatter();
FileAppender appender = new FileAppender("../../file.txt", formatter);
Logger.Logger logger = new Logger.Logger(appender);
int a = 5;
try
{
logger.Critical("a cannot be 5");
logger.Warn("Be carful for that 5!");
}
finally
{
appender.Close();
}
}
static void Main(string[] args)
{
IConverter converter = new Converter.Converter();
string based = AppDomain.CurrentDomain.BaseDirectory;
OptionsManager <DataAccessOptions> optionsManager = new OptionsManager <DataAccessOptions>(based, converter);
LoggingOptions loggingOptions = optionsManager.GetOptions <LoggingOptions>() as LoggingOptions;
SendingOptions sendingOptions = optionsManager.GetOptions <SendingOptions>() as SendingOptions;
ConnectionOptions connectionOptions = optionsManager.GetOptions <ConnectionOptions>() as ConnectionOptions;
ServiceLayer.ServiceLayer sl = new ServiceLayer.ServiceLayer(converter, connectionOptions);
Logger.Logger logger = new Logger.Logger(connectionOptions, converter);
List <Human> people;
logger.Log(optionsManager.logs);
people = sl.GetHumanList(100);
XmlGenerator generator = new XmlGenerator(sendingOptions);
generator.CreateXML(people);
}
static void Main()
{
var jsonReader = new JsonReader("data.json");
var service = new ServiceLayer.ServiceLayer(jsonReader);
var listIdInfo = jsonReader.GetElement <List <int> >("IDs");
var xmlGenerator = new SerializeXML();
var fileWriter = new FileManager.FileManager(jsonReader);
var logger = new Logger.Logger(jsonReader);
foreach (var id in listIdInfo)
{
logger.Log($"getting Info_{id}");
var item = service.GetInfo(id);
logger.Log($"generate xml and xsd");
var xml = xmlGenerator.SerializeXmlWithXsd(item, $"Info_{id}");
var xsd = xmlGenerator.SerializeXsd(item);
logger.Log($"create Info_{id}.xml and xsd");
fileWriter.FileName = $"Info_{id}.xml";
fileWriter.AddTextToFile(xml);
fileWriter.FileName = $"Info_{id}.xsd";
fileWriter.AddTextToFile(xsd);
}
}
public DataCore(Logger.Logger logger)
{
situation = new Situation(logger);
}
public BotClient(Logger.Logger _logger) : base()
{
logger = _logger;
}
public BotClient(IPEndPoint local_ep, Logger.Logger _logger) : base(local_ep)
{
logger = _logger;
}
public BotClient(String host_name, int port, Logger.Logger _logger) : base(host_name, port)
{
logger = _logger;
}
public BotClient(AddressFamily address_family, Logger.Logger _logger) : base(address_family)
{
logger = _logger;
}
public void SetLogger(Logger.Logger logger)
{
this._logger = logger;
}
private static void Added()
{
Logger.Logger log = Logger.Logger.Instance();
log.Info("One more User added!");
log.Warning(true);
}
private static void Deleted()
{
Logger.Logger log = Logger.Logger.Instance();
log.Info("User was deleted!");
log.Warning(false);
}
