private static ConsoleLogWriter SetupLogging() { ConsoleLogWriter consoleWriter = new ConsoleLogWriter { LogLevel = BeatSyncLib.Logging.LogLevel.Info }; LogManager.AddLogWriter(consoleWriter); BeatSyncLib.Logger.log = new BeatSyncLogger("BeatSyncLib"); SongFeedReaderLogger feedReaderLogger = new SongFeedReaderLogger("SongFeedReader"); SongFeedReaders.Logging.LoggingController.DefaultLogger = feedReaderLogger; try { string logDirectory = LogDirectory ?? Paths.LogDirectory; string logFilePath = Path.Combine(logDirectory, "log.txt"); Directory.CreateDirectory(logDirectory); LogManager.AddLogWriter(new FileLogWriter(logFilePath)); } catch (Exception ex) { Logger.log.Error($"Error creating FileLogWriter: {ex.Message}"); } return(consoleWriter); }
/// <summary> /// /// </summary> /// <returns></returns> public static int Main(string[] args) { var log = ConsoleLogWriter.CreateLog("main", LogLevel.Info, "${Message}"); if (0 == args.Length) { log.Error("no dir given"); return(-1); } var src = Environment.CurrentDirectory; var trg = args[0]; if (1 < args.Length) { src = args[0]; trg = args[1]; } var syncer = new DirectorySynchronization(src, trg) { Log = log }; try{ syncer.Synchronize(); } catch (Exception ex) { log.Error("error " + ex.Message, ex); return(-2); } return(0); }
public static void LogProcessor___Valid___Works() { using (var consoleOut = new StringWriter(CultureInfo.CurrentCulture)) { using (var consoleError = new StringWriter(CultureInfo.CurrentCulture)) { // Arrange var infoCanary = A.Dummy <string>(); var errorCanary = new ArgumentException(A.Dummy <string>()); var logProcessor = new ConsoleLogWriter(new ConsoleLogConfig(LogInclusionKindToOriginsMaps.AnythingFromAnywhere, LogInclusionKindToOriginsMaps.StringAndObjectsFromItsLogEntryPosted, LogInclusionKindToOriginsMaps.ExceptionsFromAnywhere)); Console.SetOut(consoleOut); Console.SetError(consoleError); // Act logProcessor.Log(infoCanary.ToLogEntry().ToLogItem(LogItemOrigin.ItsLogEntryPosted)); logProcessor.Log(errorCanary.ToLogEntry().ToLogItem(LogItemOrigin.ItsLogEntryPosted)); var consoleOutOutput = consoleOut.ToString(); var consoleErrorOutput = consoleError.ToString(); // Assert consoleOutOutput.Should().Contain(infoCanary); consoleOutOutput.Should().NotContain(errorCanary.Message); consoleErrorOutput.Should().Contain(errorCanary.Message); consoleErrorOutput.Should().NotContain(infoCanary); } } }
private static void Main(/*string[] args*/) { var cw = new ConsoleLogWriter(); var pw = new PersistenceLogger( () => cw.Dispose(), p => cw.WriteLog( p.userId, p.companyId, p.topic, p.severityCode, p.machineName, p.memberName, p.filePath, p.lineNumber, p.message, p.dateUtc), async p => await cw.WriteLogAsync( p.userId, p.companyId, p.topic, p.severityCode, p.machineName, p.memberName, p.filePath, p.lineNumber, p.message, p.dateUtc)); pw.SetTopic("the topic"); pw.SetUser("the user", "the company"); pw.Log("test"); try { throw new Exception("test"); } catch (Exception e) { pw.Log(e); } }
static async Task Main(string[] args) { // welcome banner Console.WriteLine(); Console.WriteLine("**********************************"); Console.WriteLine(" SMT Network Testing Demo "); Console.WriteLine("**********************************"); Console.WriteLine(); // Load config and setup service ILogWriter logger = new ConsoleLogWriter(); IConfiguration config = new ConfigurationSettings(); IRulesetLoader loader = new DemoRulesetLoader(config, logger); // IRulesetLoader azureLoader = new AzureRulesetLoader(); // Or other ruleset loader IVnetSolver solver = new ZenVnetSolver(config, logger); IResultsWriter writer = new ConsoleResultsWriter(config, logger); // Load ruleset Acl ruleset = await loader.LoadRuleset(); // Find solutions Strategy invariant = Strategies.InboundPacketsAllowed(); IEnumerable <Packet> solutions = await solver.FindSolutions(ruleset, invariant); // Print results await writer.WriteResults(invariant.Name, solutions); }
public static ConsoleLogWriter GetInstance() { if (instance == null) { instance = new ConsoleLogWriter(); } return(instance); }
private static ILogger CreateLogger() { var formatter = new BasicLogFormatter(); var consoleWriter = new ConsoleLogWriter(formatter); var logger = new Logger(consoleWriter); return(logger); }
public void FlushTest() { ConsoleLogWriter target = new ConsoleLogWriter(); var consoleOut = new TestTextWriter(); Console.SetOut(consoleOut); target.Flush(); Assert.IsTrue(consoleOut.FlushWasInvoked); }
public static ConsoleLogWriter GetConsole() { if (_consoleLogWriter == null) { _consoleLogWriter = new ConsoleLogWriter(); } return(_consoleLogWriter); }
public void WriteLineTest() { ConsoleLogWriter target = new ConsoleLogWriter(); var consoleOut = new TestTextWriter(); Console.SetOut(consoleOut); target.WriteLine("Hello"); Assert.IsTrue(consoleOut.WriteLineWasInvoked); }
public void SyncThemas() { var sync = new DirectorySynchronization(@"C:\z3projects\assoi\local\Draft\themas\.old\thema", @"C:\mnt\testthemas") { Log = ConsoleLogWriter.CreateLog("main", customFormat: "${Message}") }; sync.Synchronize(); }
private void WritesLogToConsole(ILogFormatter formatter) { var logInfo = new LogInfo(LogLevel.INFO, new InvokerModel("", ""), ""); var consoleLogWriter = new ConsoleLogWriter(formatter); TestConsoleOutput( () => consoleLogWriter.Write(logInfo), (output) => Assert.AreEqual(formatter.Format(logInfo), output) ); }
static void Main(string[] args) { var ar1 = new FileLogWriter("LogError.txt"); var ar2 = new ConsoleLogWriter(); var log1 = new ILogWriter[] { ar1, ar2 }; var multiLog = new MultipleLogWriter(log1); multiLog.LogInfo("LogInfo new"); multiLog.LogError("LogError new"); multiLog.LogWarning("LogWarning new"); }
public static void Main(string[] args) { CheckEnvironment(); // TODO: Load certain plugins earlier if (PreStartup != null) { PreStartup(null, null); } if (SettingsProvider == null) { // Select a settings provider based on the enviornment if (File.Exists("server.properties")) { SettingsProvider = new VanillaSettingsProvider("server.properties"); } else { // TODO: Create a better settings provider than vanilla SettingsProvider = new VanillaSettingsProvider("server.properties"); SetUpDefaultPermissions(SettingsProvider); } } var server = new Server(SettingsProvider); LoadPlugins(server); Command.LoadCommands(server); // TODO: Better logging var consoleLog = new ConsoleLogWriter(LogImportance.Medium); LogProvider.RegisterProvider(consoleLog); server.Start(); Console.WriteLine("Use /stop to kill the server."); ConsoleClient = new ConsoleClient(server.MinecraftServer); while (true) { var command = Console.ReadLine(); try { Command.ExecuteCommand(server, ConsoleClient, command); } catch (Exception e) { Console.WriteLine(e.ToString()); } } server.Stop(); }
protected override void InitializeInternal() { AppInstanceUniqueId = Guid.NewGuid().ToString(); logWriter = new ConsoleLogWriter { ShowDetailedLogs = ShowDetailedLogs }; if (AutoDiscoverServer) { AutoDiscoverInit(); } else { ManagerInit(connectOnAwake); } }
/// <summary> /// Выполняет весь цикл, включая обращение к БД /// </summary> public void Execute() { _context.Log = _context.Log ?? ConsoleLogWriter.CreateLog("main", customFormat: "${Message}"); if (_context.DiffPairs == null) { _context.Log.Info("require diff checking"); if (!string.IsNullOrWhiteSpace(_context.SqlConnectionString) && string.IsNullOrWhiteSpace(_context.GitBaseRevision)) { _context.Log.Info("start revision determining"); new SqlSourceRevisionRetriever(_context).Determine(); _context.Log.Info("base revision detected as " + _context.GitBaseRevision); } else { _context.Log.Info("sql server not set up - work for script gen only"); } new DiffPairGenerator(_context).Generate(); _context.Log.Info("difference pairs prepared evaluated"); } new DataTableDiffGenerator(_context).Generate(); _context.Log.Info("difference tables generated: " + _context.Tables.Count() + " tables"); if (_context.Tables.Any()) { new SqlDiffGenerator(_context).Generate(); _context.Log.Info("sql script prepared"); if (_context.NoApply) { _context.Log.Info("Применение изменений к БД отключено"); } else { if (!string.IsNullOrWhiteSpace(_context.SqlConnectionString)) { new SqlUpdateApplyer(_context).Update(); _context.Log.Info("sql database updated"); } else { _context.Log.Info("sql not set up - no real apply to server"); } } } else { _context.Log.Info("Нет значимых изменений"); } }
public static LoggerProvider AddConsole(this LoggerProvider provider, string name = "", string source = "", string format = "", LogLevel minLevel = LogLevel.Info, LogLevel maxLevel = LogLevel.Info, Func <LogEvent, bool> condition = null) { ConsoleLogWriter writer = new ConsoleLogWriter { Name = name, Format = format, Source = source, MinLevel = minLevel, MaxLevel = maxLevel, }; if (condition != null) { writer.Condition = condition; } provider.Writers.Add(writer); return(provider); }
static void Main(string[] args) { ConsoleLogWriter consoleLogWriter = ConsoleLogWriter.GetConsole(); var fileLogWriter = FileLogWriter.GetFileWriter(@"D:\file.txt"); var logs = new ILogWriter[2]; logs[0] = consoleLogWriter; logs[1] = fileLogWriter; var multipleLogWriter = MultipleLogWriter.GetMultipleLog(logs); multipleLogWriter.LogError("Error!"); multipleLogWriter.LogInfo("Info!!!"); multipleLogWriter.LogWarning("Warning you!!!"); Console.ReadKey(); }
static void Main(string[] args) { FileLogWriter flw = FileLogWriter.GetInstance(); ConsoleLogWriter clw = ConsoleLogWriter.GetInstance(); MultipleLogWriter mlw = MultipleLogWriter.GetInstance(); mlw.Add(flw); mlw.Add(clw); mlw.LogWarning("Warning"); mlw.LogError("Error"); mlw.Remove(clw); FileLogWriter.Path = "anotherLog.txt"; mlw.LogInfo("Another info"); }
public TwitchNotificationService(DiscordSocketClient client, ConsoleLogWriter writer) { if (writer == null) { Console.WriteLine("WRITER IS NULL!"); } if (client == null) { Console.WriteLine("CLIENT IS NULL!"); } _client = client; _writer = writer; _client.GuildMemberUpdated += _client_GuildMemberUpdated; LogMessage l2 = new LogMessage(LogSeverity.Info, "GoLive", "TwitchNotificationService constructor called."); Client_Log(l2); //Read shouts.json, otherwise create it. using (FileStream fs = File.Open("shouts.json", FileMode.OpenOrCreate)) { using (StreamReader sr = new StreamReader(fs)) { string f = sr.ReadToEnd(); if (!string.IsNullOrWhiteSpace(f)) { JsonSerializerSettings s = new JsonSerializerSettings(); s.Formatting = Formatting.Indented; s.ConstructorHandling = ConstructorHandling.AllowNonPublicDefaultConstructor; s.ReferenceLoopHandling = ReferenceLoopHandling.Serialize; s.TypeNameHandling = TypeNameHandling.Arrays; shoutEntities = ((Newtonsoft.Json.Linq.JArray)JsonConvert.DeserializeObject(f, s)).ToObject <List <UserShout> >(); if (shoutEntities == null) { shoutEntities = new List <UserShout>(); LogMessage l = new LogMessage(LogSeverity.Warning, "GoLive", "WARNING: Shouts.json is null or invalid."); Client_Log(l); } } } } }
/// <summary> /// /// </summary> /// <param name="args"></param> public static int Main(string[] args) { var log = ConsoleLogWriter.CreateLog("main"); try{ var parameters = new DataDiffConsoleParameters(); parameters.Initialize(args); log = parameters.Log; var executor = new DataDiffConsololeExecutor(); executor.Execute(parameters); return(0); } catch (Exception ex) { log.Fatal(ex.ToString(), ex); return(-1); } finally{ log.Synchronize(); } }
public TestScenario(string scenarioCode, string description) { if (scenarioCode == null) { throw new ArgumentNullException(nameof(scenarioCode)); } if (description == null) { throw new ArgumentNullException(nameof(description)); } ScenarioCode = scenarioCode; Description = description; Logger = new ConsoleLogWriter(); var administratorUser = _applicationSettingsRepository.GetStringValue("administratorUser"); var administratorPassword = _applicationSettingsRepository.GetStringValue("administratorPassword"); Administrator = CreateSession("Administrator", false, administratorUser, administratorPassword); Anonymous = CreateSession("Anonymous", false); }
public void WritesOnlyLogsWithGivenLogLevels() { var logInfoInfo = new LogInfo(LogLevel.INFO, new InvokerModel("", ""), ""); var logInfoWarning = new LogInfo(LogLevel.WARNING, new InvokerModel("", ""), ""); var logInfoError = new LogInfo(LogLevel.ERROR, new InvokerModel("", ""), ""); var logInfoFatal = new LogInfo(LogLevel.FATAL, new InvokerModel("", ""), ""); var formatter = new CustomLogFormatter((i) => { if (i.Level == LogLevel.FATAL) { Assert.Fail(); } return(""); }); var allowedLogLevels = new LogLevel[] { LogLevel.INFO, LogLevel.WARNING, LogLevel.ERROR }; var logger = new ConsoleLogWriter(formatter, allowedLogLevels); logger.Write(logInfoInfo); logger.Write(logInfoWarning); logger.Write(logInfoError); logger.Write(logInfoFatal); }
/// <summary> /// /// </summary> /// <param name="context"></param> public DiffPairGenerator(TableDiffGeneratorContext context) { this._context = context; if (null == _context.Log) { _context.Log = ConsoleLogWriter.CreateLog("main", customFormat: "${Message}", level: LogLevel.Trace); } if (null != _context.PreparedContext) { if (string.IsNullOrWhiteSpace(_context.ProjectDirectory)) { throw new Exception("ProjectDirectory is required"); } if (string.IsNullOrWhiteSpace(_context.GitBranch)) { _context.GitBranch = "master"; } if (string.IsNullOrWhiteSpace(_context.RootDirectory)) { _context.RootDirectory = Path.GetTempFileName(); } if (string.IsNullOrWhiteSpace(_context.GitUrl)) { if (!Directory.Exists(Path.Combine(_context.RootDirectory, ".git"))) { throw new Exception("no valid repo directory, nor git URL was given"); } } if (string.IsNullOrWhiteSpace(_context.GitUpdateRevision)) { _context.GitUpdateRevision = "HEAD"; } } if (string.IsNullOrWhiteSpace(_context.BSharpPrototype)) { _context.BSharpPrototype = "db-meta"; } }
private static void Main() { try { var consoleLogWriter = new ConsoleLogWriter(GetLogPath(), Console.Out); Console.SetOut(consoleLogWriter); } catch (IOException ex) when(ex.Message.Contains("cannot access the file")) { MessageBox.Show("Only one instance of the program can be open at a time", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); return; } AppDomain.CurrentDomain.FirstChanceException += (sender, args) => { Console.WriteLine($"=== Exception occurred at {DateTime.Now:yyyy-MM-dd hh:mm:ss tt} ==={LF}"); Console.WriteLine($"{args.Exception}{LF}{LF}"); }; AppDomain.CurrentDomain.UnhandledException += (sender, args) => { MessageBox.Show($"Error: {( args.ExceptionObject as Exception )?.Message ?? "Unknown"}", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); }; // Configure dependency injection Services.Configure(modPackUrl: "https://mc.arcanox.me"); // Configure web clients ServicePointManager.Expect100Continue = true; ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12; Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); // Hook up a method that will run as soon as the application first goes idle Application.Idle += ApplicationOnEnterIdle; Application.Run(); }
public XToolsApp(string[] args = null) { parsedArguments = ParseCommandLine(args); this.logWriter = new ConsoleLogWriter(); ClientConfig config = new ClientConfig(ClientRole.Primary); config.SetServerAddress(GetArgumentOrDefault("sessionserver", "localhost")); config.SetLogWriter(this.logWriter); this.Manager = SharingManager.Create(config); this.syncListener = new ConsoleSyncReporter(); this.viewerConnection = this.Manager.GetPairedConnection(); this.serverConnection = this.Manager.GetServerConnection(); this.SessionManager = this.Manager.GetSessionManager(); BeginPairing(); ViewerListener = new NetworkConnectionAdapter(); ViewerListener.ConnectedCallback += this.OnViewerConnected; ViewerListener.ConnectionFailedCallback += this.OnViewerConnectionFailed; ViewerListener.DisconnectedCallback += this.OnViewerDisconnected; viewerConnection.AddListener((byte)MessageID.StatusOnly, ViewerListener); ServerListener = new NetworkConnectionAdapter(); ServerListener.ConnectedCallback += this.OnSessionConnected; ServerListener.ConnectionFailedCallback += this.OnSessionConnectionFailed; ServerListener.DisconnectedCallback += this.OnSessionDisconnected; serverConnection.AddListener((byte)MessageID.StatusOnly, ServerListener); this.rootObject = this.Manager.GetRootSyncObject(); this.rootObject.AddListener(this.syncListener); // Listen for new sessions SessionManagerListener = new XToolsSessionManagerListener(); this.SessionManager.AddListener(SessionManagerListener); }
private static IUserLog SetupLog(IDictionary <string, string> adict) { var level = LogLevel.Info; if (adict.ContainsKey("loglevel")) { level = (LogLevel)Enum.Parse(typeof(LogLevel), adict["loglevel"], true); } if (adict.ContainsKey("log-level")) { level = (LogLevel)Enum.Parse(typeof(LogLevel), adict["log-level"], true); } //disable logging for console-mode if (adict.ContainsKey("console-mode")) { level = LogLevel.Fatal; } var log = ConsoleLogWriter.CreateLog("main", customFormat: "${Message}", level: level); log.Info("log level " + level); return(log); }
/// <summary> /// Стандартный шаблон выполнения консольных приложений в Qorpent /// </summary> /// <typeparam name="TArgs"></typeparam> /// <param name="args"></param> /// <param name="executor"></param> /// <param name="shadowByDefault">Признак использования ShadowRun по умолчанию</param> /// <returns></returns> public static int Execute <TArgs>(string[] args, Func <TArgs, int> executor, bool shadowByDefault = false) where TArgs : ConsoleApplicationParameters, new() { if (args.Contains("--debug")) { Debugger.Launch(); } var log = ConsoleLogWriter.CreateLog(); try{ var parameters = new TArgs(); parameters.ShadowByDefault = shadowByDefault; parameters.Initialize(args); log = parameters.Log; if ((shadowByDefault || parameters.Shadow) && !parameters.NoShadow) { var shadower = new ShadowRun { Parameters = parameters, Log = log }; if (!shadower.EnsureShadow()) { return(-3); //shadow restart } } return(executor(parameters)); } catch (Exception ex) { log.Fatal(ex.ToString(), ex); return(-1); } finally{ if (null != log) { log.Synchronize(); } } }
private void _InitializeForStandaloneApplication() { if (Config.ApplicationMode != HostApplicationMode.Shared) { Container.Unregister(Container.FindComponent(typeof(IFileNameResolver), "")); Container.Register( Container.NewComponent <IFileNameResolver, HostFileNameResolver>( implementation: new HostFileNameResolver(this))); Container.Register(Container.NewComponent <IMvcContext, HostMvcContext>()); Container.Unregister(Container.FindComponent(typeof(IAction), "_sys.login.action")); Container.Unregister(Container.FindComponent(typeof(IAction), "_sys.logout.action")); Container.Register(Container.NewComponent <IHostConfigProvider, HostServer>(implementation: this)); var logger = (BaseLogger)ConsoleLogWriter.CreateLogger( level: Config.LogLevel, customFormat: "${Level} ${Time} ${Message}" ); logger.Mask = "*"; Application.Container.Register(Container.NewComponent <ILogger, BaseLogger>(implementation: logger)); Application.PerformAsynchronousStartup(); } }
public XToolsApp() { this.LogWriter = new ConsoleLogWriter(); }
public GoLiveModule(DiscordSocketClient discord, TwitchNotificationService service, ConsoleLogWriter writer) { _client = discord; this._writer = writer; _service = service; }
static void Main(string[] args) { ILogWriter logWriter = new ConsoleLogWriter(); var logger = new Log(logWriter); }