public ResultSummary Run(object fixture, SpecificationConfig specificationConfig) { var source = string.IsNullOrEmpty(specificationConfig.BaseInputDirectory) ? (Source)new EmbeddedResourceSource(fixture.GetType().Assembly) : new FileSource(fixture.GetType().Assembly, specificationConfig.BaseInputDirectory); var target = new FileTarget(specificationConfig.BaseOutputDirectory); var testSummary = new SummarizingResultRecorder(); var anySpecExecuted = false; var fileExtensions = specificationConfig.SpecificationFileExtensions; foreach (var fileExtension in fileExtensions) { var specLocator = new ClassNameBasedSpecificationLocator(fileExtension); var specResource = specLocator.locateSpecification(fixture); if (source.canFind(specResource)) { var fixtureResult = RunSingleSpecification(fixture, source, specLocator, target, specificationConfig); AddToTestResults(fixtureResult, testSummary); anySpecExecuted = true; } } if (anySpecExecuted) return testSummary; throw new InvalidOperationException(string.Format("no specification extensions defined for: {0}", specificationConfig)); }
public void Test_Can_Get_File_Path_Successfully() { var resource = new Resource("\\blah\\blah.txt"); var target = new FileTarget(new File(@"c:\temp"), new IOUtil()); Assert.AreEqual(@"c:\temp\blah\blah.txt", target.resolvedPathFor(resource)); }
/// <summary> /// Initializes static members of the <see cref="Program"/> class. /// </summary> static Program() { var folder = Environment.CurrentDirectory.EnsureEndsWith(@"\"); var target = new FileTarget { Layout = "${longdate} ${message}", FileName = folder + @"yuicompressor-${level}.log", KeepFileOpen = false }; Vodca.SDK.NLog.Config.SimpleConfigurator.ConfigureForTargetLogging(target, LogLevel.Debug); }
private void scheduler_DragDrop(object sender, DragEventArgs e) { if (!e.Data.GetDataPresent(DataFormats.FileDrop)) e.Effect = DragDropEffects.None; else { string[] files = (string[])e.Data.GetData(DataFormats.FileDrop, false); if (e.Effect == DragDropEffects.Copy) { foreach (string file in files) using (FileStream stream = new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.Read)) { try { Program.eraserClient.Tasks.LoadFromStream(stream); } catch (SerializationException ex) { MessageBox.Show(S._("Could not import task list from {0}. The " + "error returned was: {1}", file, ex.Message), S._("Eraser"), MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1, S.IsRightToLeft(null) ? MessageBoxOptions.RtlReading | MessageBoxOptions.RightAlign : 0); } } } else if (e.Effect == DragDropEffects.Move) { Task task = new Task(); foreach (string file in files) { FileSystemObjectTarget target; if (Directory.Exists(file)) target = new FolderTarget(); else target = new FileTarget(); target.Path = file; task.Targets.Add(target); } Program.eraserClient.Tasks.Add(task); } } DropTargetHelper.Drop(e.Data, new Point(e.X, e.Y), e.Effect); }
private void IntializeLogger(string logPath, LoggerLevel logLevel) { if (logPath.StartsWith("/")) { logPath = HostingEnvironment.MapPath(logPath); } var config = new LoggingConfiguration(); var fileTarget = new FileTarget(); fileTarget.Layout = "${message}"; config.AddTarget("file", fileTarget); if (logPath.EndsWith(".log")) { fileTarget.FileName = logPath; } else { var logFile = "MissionSearch.log"; fileTarget.FileName = string.Format(@"{0}\{1}", logPath, logFile); } switch (logLevel) { case LoggerLevel.Debug: config.LoggingRules.Add(new LoggingRule("*", NLog.LogLevel.Trace, fileTarget)); break; case LoggerLevel.Info: config.LoggingRules.Add(new LoggingRule("*", NLog.LogLevel.Info, fileTarget)); break; case LoggerLevel.Error: config.LoggingRules.Add(new LoggingRule("*", NLog.LogLevel.Error, fileTarget)); break; } /* * if (logLevel == LogLevel.Info) * { * var rule2 = new LoggingRule("*", LogLevel.Info, fileTarget); * config.LoggingRules.Add(rule2); * } * else if (logLevel == LogLevel.Trace) * { * var rule2 = new LoggingRule("*", LogLevel.Info, fileTarget); * config.LoggingRules.Add(rule2); * * var rule3 = new LoggingRule("*", LogLevel.Trace, fileTarget); * config.LoggingRules.Add(rule3); * } * */ LogManager.Configuration = config; _logger = LogManager.GetLogger("MissionSearch"); }
private static void CommandAddTask(ConsoleArguments arg) { AddTaskArguments arguments = (AddTaskArguments)arg; Task task = new Task(); ErasureMethod method = arguments.ErasureMethod == Guid.Empty ? ErasureMethodManager.Default : ErasureMethodManager.GetInstance(arguments.ErasureMethod); switch (arguments.Schedule.ToUpperInvariant()) { case "NOW": task.Schedule = Schedule.RunNow; break; case "MANUALLY": task.Schedule = Schedule.RunManually; break; case "RESTART": task.Schedule = Schedule.RunOnRestart; break; default: throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, "Unknown schedule type: {0}", arguments.Schedule), "--schedule"); } List<string> trueValues = new List<string>(new string[] { "yes", "true" }); string[] strings = new string[] { "(?<recycleBin>recyclebin)", "unused=(?<unusedVolume>.*)(?<unusedTips>,clusterTips(=(?<unusedTipsValue>true|false))?)?", "dir=(?<directoryName>.*)(?<directoryParams>(?<directoryExcludeMask>,-[^,]+)|(?<directoryIncludeMask>,\\+[^,]+)|(?<directoryDeleteIfEmpty>,deleteIfEmpty(=(?<directoryDeleteIfEmptyValue>true|false))?))*", "file=(?<fileName>.*)" }; Regex regex = new Regex(string.Join("|", strings), RegexOptions.Compiled | RegexOptions.IgnoreCase | RegexOptions.RightToLeft); foreach (string argument in arguments.PositionalArguments) { Match match = regex.Match(argument); if (match.Captures.Count == 0) { Console.WriteLine("Unknown argument: {0}, skipped.", argument); continue; } ErasureTarget target = null; if (match.Groups["recycleBin"].Success) { target = new RecycleBinTarget(); } else if (match.Groups["unusedVolume"].Success) { UnusedSpaceTarget unusedSpaceTarget = new UnusedSpaceTarget(); target = unusedSpaceTarget; unusedSpaceTarget.Drive = match.Groups["unusedVolume"].Value; if (!match.Groups["unusedTips"].Success) unusedSpaceTarget.EraseClusterTips = false; else if (!match.Groups["unusedTipsValue"].Success) unusedSpaceTarget.EraseClusterTips = true; else unusedSpaceTarget.EraseClusterTips = trueValues.IndexOf(match.Groups["unusedTipsValue"].Value) != -1; } else if (match.Groups["directoryName"].Success) { FolderTarget folderTarget = new FolderTarget(); target = folderTarget; folderTarget.Path = match.Groups["directoryName"].Value; if (!match.Groups["directoryDeleteIfEmpty"].Success) folderTarget.DeleteIfEmpty = false; else if (!match.Groups["directoryDeleteIfEmptyValue"].Success) folderTarget.DeleteIfEmpty = true; else folderTarget.DeleteIfEmpty = trueValues.IndexOf(match.Groups["directoryDeleteIfEmptyValue"].Value) != -1; if (match.Groups["directoryExcludeMask"].Success) folderTarget.ExcludeMask += match.Groups["directoryExcludeMask"].Value.Remove(0, 2) + ' '; if (match.Groups["directoryIncludeMask"].Success) folderTarget.IncludeMask += match.Groups["directoryIncludeMask"].Value.Remove(0, 2) + ' '; } else if (match.Groups["fileName"].Success) { FileTarget fileTarget = new FileTarget(); target = fileTarget; fileTarget.Path = match.Groups["fileName"].Value; } if (target == null) continue; target.Method = method; task.Targets.Add(target); } if (task.Targets.Count == 0) throw new ArgumentException("Tasks must contain at least one erasure target."); try { using (RemoteExecutorClient client = new RemoteExecutorClient()) { client.Run(); if (!client.IsConnected) { Process eraserInstance = Process.Start( Assembly.GetExecutingAssembly().Location, "--quiet"); eraserInstance.WaitForInputIdle(); client.Run(); if (!client.IsConnected) throw new IOException("Eraser cannot connect to the running " + "instance for erasures."); } client.Tasks.Add(task); } } catch (UnauthorizedAccessException e) { throw new UnauthorizedAccessException("Another instance of Eraser " + "is already running but it is running with higher privileges than " + "this instance of Eraser. Tasks cannot be added in this manner.\n\n" + "Close the running instance of Eraser and start it again without " + "administrator privileges, or run the command again as an " + "administrator.", e); } }
/// <summary> /// Extends the logging rules in the "NLog.config" with node log settings rules. /// </summary> /// <param name="settings">Node log settings to extend the rules from the configuration file, or null if no extension is required.</param> /// <param name="dataFolder">Data folder to determine path to log files.</param> private static void AddFilters(LogSettings settings = null, DataFolder dataFolder = null) { if (settings == null) { return; } logSettings = settings; folder = dataFolder; // If we use "debug*" targets, which are defined in "NLog.config", make sure they log into the correct log folder in data directory. List <Target> debugTargets = LogManager.Configuration.AllTargets.Where(t => (t.Name != null) && t.Name.StartsWith("debug")).ToList(); foreach (Target debugTarget in debugTargets) { FileTarget debugFileTarget = debugTarget is AsyncTargetWrapper ? (FileTarget)((debugTarget as AsyncTargetWrapper).WrappedTarget) : (FileTarget)debugTarget; string currentFile = debugFileTarget.FileName.Render(new LogEventInfo { TimeStamp = DateTime.UtcNow }); debugFileTarget.FileName = Path.Combine(folder.LogPath, Path.GetFileName(currentFile)); if (debugFileTarget.ArchiveFileName != null) { string currentArchive = debugFileTarget.ArchiveFileName.Render(new LogEventInfo { TimeStamp = DateTime.UtcNow }); debugFileTarget.ArchiveFileName = Path.Combine(folder.LogPath, currentArchive); } } // Remove rule that forbids logging before the logging is initialized. LoggingRule nullPreInitRule = null; foreach (LoggingRule rule in LogManager.Configuration.LoggingRules) { if (rule.Final && rule.NameMatches("*") && (rule.Targets.Count > 0) && (rule.Targets[0].Name == "null")) { nullPreInitRule = rule; break; } } LogManager.Configuration.LoggingRules.Remove(nullPreInitRule); // Configure main file target, configured using command line or node configuration file settings. var mainTarget = new FileTarget { Name = "main", FileName = Path.Combine(folder.LogPath, "node.txt"), ArchiveFileName = Path.Combine(folder.LogPath, "node-${date:universalTime=true:format=yyyy-MM-dd}.txt"), ArchiveNumbering = ArchiveNumberingMode.Sequence, ArchiveEvery = FileArchivePeriod.Day, MaxArchiveFiles = 7, Layout = "[${longdate:universalTime=true} ${threadid}${mdlc:item=id}] ${level:uppercase=true}: ${callsite} ${message}", Encoding = Encoding.UTF8 }; LogManager.Configuration.AddTarget(mainTarget); // Default logging level is Info for all components. var defaultRule = new LoggingRule($"{nameof(Stratis)}.*", settings.LogLevel, mainTarget); if (settings.DebugArgs.Any() && settings.DebugArgs[0] != "1") { lock (KeyCategories) { var usedCategories = new HashSet <string>(StringComparer.Ordinal); // Increase selected categories to Debug. foreach (string key in settings.DebugArgs) { if (!KeyCategories.TryGetValue(key.Trim(), out string category)) { // Allow direct specification - e.g. "-debug=Stratis.Bitcoin.Miner". category = key.Trim(); } if (!usedCategories.Contains(category)) { usedCategories.Add(category); var rule = new LoggingRule(category, settings.LogLevel, mainTarget); LogManager.Configuration.LoggingRules.Add(rule); } } } } LogManager.Configuration.LoggingRules.Add(defaultRule); // Apply new rules. LogManager.ReconfigExistingLoggers(); }
private static void ConfigureLogging() { var config = clusterConfig.Logging; var loggingConfig = new LoggingConfiguration(); if (config != null) { // parse level var level = !string.IsNullOrEmpty(config.Level) ? LogLevel.FromString(config.Level) : LogLevel.Info; var layout = "[${longdate}] [${level:format=FirstCharacter:uppercase=true}] [${logger:shortName=true}] ${message} ${exception:format=ToString,StackTrace}"; if (config.EnableConsoleLog) { if (config.EnableConsoleColors) { var target = new ColoredConsoleTarget("console") { Layout = layout }; target.RowHighlightingRules.Add(new ConsoleRowHighlightingRule( ConditionParser.ParseExpression("level == LogLevel.Trace"), ConsoleOutputColor.DarkMagenta, ConsoleOutputColor.NoChange)); target.RowHighlightingRules.Add(new ConsoleRowHighlightingRule( ConditionParser.ParseExpression("level == LogLevel.Debug"), ConsoleOutputColor.Gray, ConsoleOutputColor.NoChange)); target.RowHighlightingRules.Add(new ConsoleRowHighlightingRule( ConditionParser.ParseExpression("level == LogLevel.Info"), ConsoleOutputColor.White, ConsoleOutputColor.NoChange)); target.RowHighlightingRules.Add(new ConsoleRowHighlightingRule( ConditionParser.ParseExpression("level == LogLevel.Warn"), ConsoleOutputColor.Yellow, ConsoleOutputColor.NoChange)); target.RowHighlightingRules.Add(new ConsoleRowHighlightingRule( ConditionParser.ParseExpression("level == LogLevel.Error"), ConsoleOutputColor.Red, ConsoleOutputColor.NoChange)); target.RowHighlightingRules.Add(new ConsoleRowHighlightingRule( ConditionParser.ParseExpression("level == LogLevel.Fatal"), ConsoleOutputColor.DarkRed, ConsoleOutputColor.White)); loggingConfig.AddTarget(target); loggingConfig.AddRule(level, LogLevel.Fatal, target); } else { var target = new ConsoleTarget("console") { Layout = layout }; loggingConfig.AddTarget(target); loggingConfig.AddRule(level, LogLevel.Fatal, target); } } if (!string.IsNullOrEmpty(config.LogFile)) { var target = new FileTarget("file") { FileName = GetLogPath(config, config.LogFile), FileNameKind = FilePathKind.Unknown, Layout = layout }; loggingConfig.AddTarget(target); loggingConfig.AddRule(level, LogLevel.Fatal, target); } if (config.PerPoolLogFile) { foreach (var poolConfig in clusterConfig.Pools) { var target = new FileTarget(poolConfig.Id) { FileName = GetLogPath(config, poolConfig.Id + ".log"), FileNameKind = FilePathKind.Unknown, Layout = layout }; loggingConfig.AddTarget(target); loggingConfig.AddRule(level, LogLevel.Fatal, target, poolConfig.Id); } } } LogManager.Configuration = loggingConfig; logger = LogManager.GetCurrentClassLogger(); }
public void Run(string[] args) { // prime the hoststring lazy instantiator hostString(); // print the thing PrintBanner(); // set up the message queue for operation BlockingMq.MakeMq(); // get a handle to the message queue singleton Mq = BlockingMq.GetMq(); // prime the UI handler SnaffCon controller = null; try { // parse cli opts in Options = Config.Parse(args); // set up the TSV output if the flag is set if (Options.LogTSV) { fileResultTemplate = "{0}" + Options.Separator + "{1}" + Options.Separator + "{2}" + Options.Separator + "{3}" + Options.Separator + "{4}" + Options.Separator + "{5}" + Options.Separator + "{6:u}" + Options.Separator + "{7}" + Options.Separator + "{8}"; shareResultTemplate = "{0}" + Options.Separator + "{1}"; dirResultTemplate = "{0}" + Options.Separator + "{1}"; } // otherwise just do the normal thing else { // treat all as strings except LastWriteTime {6} fileResultTemplate = "{{{0}}}<{1}|{2}{3}|{4}|{5}|{6:u}>({7}) {8}"; shareResultTemplate = "{{{0}}}({1}) {2}"; dirResultTemplate = "{{{0}}}({1})"; } //------------------------------------------ // set up new fangled logging //------------------------------------------ LoggingConfiguration nlogConfig = new LoggingConfiguration(); ColoredConsoleTarget logconsole = null; FileTarget logfile = null; ParseLogLevelString(Options.LogLevelString); // Targets where to log to: File and Console if (Options.LogToConsole) { logconsole = new ColoredConsoleTarget("logconsole") { DetectOutputRedirected = true, UseDefaultRowHighlightingRules = false, WordHighlightingRules = { new ConsoleWordHighlightingRule("{Green}", ConsoleOutputColor.DarkGreen, ConsoleOutputColor.White), new ConsoleWordHighlightingRule("{Yellow}", ConsoleOutputColor.DarkYellow, ConsoleOutputColor.White), new ConsoleWordHighlightingRule("{Red}", ConsoleOutputColor.DarkRed, ConsoleOutputColor.White), new ConsoleWordHighlightingRule("{Black}", ConsoleOutputColor.Black, ConsoleOutputColor.White), new ConsoleWordHighlightingRule("[Trace]", ConsoleOutputColor.DarkGray, ConsoleOutputColor.Black), new ConsoleWordHighlightingRule("[Degub]", ConsoleOutputColor.Gray, ConsoleOutputColor.Black), new ConsoleWordHighlightingRule("[Info]", ConsoleOutputColor.White, ConsoleOutputColor.Black), new ConsoleWordHighlightingRule("[Error]", ConsoleOutputColor.Magenta, ConsoleOutputColor.Black), new ConsoleWordHighlightingRule("[Fatal]", ConsoleOutputColor.Red, ConsoleOutputColor.Black), new ConsoleWordHighlightingRule("[File]", ConsoleOutputColor.Green, ConsoleOutputColor.Black), new ConsoleWordHighlightingRule("[Share]", ConsoleOutputColor.Yellow, ConsoleOutputColor.Black), new ConsoleWordHighlightingRule { CompileRegex = true, Regex = @"<.*\|.*\|.*\|.*?>", ForegroundColor = ConsoleOutputColor.Cyan, BackgroundColor = ConsoleOutputColor.Black }, new ConsoleWordHighlightingRule { CompileRegex = true, Regex = @"^\d\d\d\d-\d\d\-\d\d \d\d:\d\d:\d\d [\+-]\d\d:\d\d ", ForegroundColor = ConsoleOutputColor.DarkGray, BackgroundColor = ConsoleOutputColor.Black }, new ConsoleWordHighlightingRule { CompileRegex = true, Regex = @"\((?:[^\)]*\)){1}", ForegroundColor = ConsoleOutputColor.DarkMagenta, BackgroundColor = ConsoleOutputColor.Black } } }; nlogConfig.AddRule(LogLevel, LogLevel.Fatal, logconsole); logconsole.Layout = "${message}"; } if (Options.LogToFile) { logfile = new FileTarget("logfile") { FileName = Options.LogFilePath }; nlogConfig.AddRule(LogLevel, LogLevel.Fatal, logfile); logfile.Layout = "${message}"; } // Apply config LogManager.Configuration = nlogConfig; //------------------------------------------- if (Options.Snaffle && (Options.SnafflePath.Length > 4)) { Directory.CreateDirectory(Options.SnafflePath); } controller = new SnaffCon(Options); Task thing = Task.Factory.StartNew(() => { controller.Execute(); }); while (true) { HandleOutput(); } } catch (Exception e) { Console.WriteLine(e.ToString()); DumpQueue(); } }
public void AsyncMultiFileWrite() { //InternalLogger.LogToConsole = true; //InternalLogger.LogLevel = LogLevel.Trace; string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString()); try { FileTarget ft = new FileTarget(); ft.FileName = Path.Combine(tempPath, "${level}.txt"); ft.LineEnding = LineEndingMode.LF; ft.Layout = "${message} ${threadid}"; // this also checks that thread-volatile layouts // such as ${threadid} are properly cached and not recalculated // in logging threads. string threadID = Thread.CurrentThread.ManagedThreadId.ToString(); //InternalLogger.LogToConsole = true; //InternalLogger.LogLevel = LogLevel.Trace; SimpleConfigurator.ConfigureForTargetLogging(new AsyncTargetWrapper(ft, 1000, AsyncTargetWrapperOverflowAction.Grow), LogLevel.Debug); LogManager.ThrowExceptions = true; for (int i = 0; i < 250; ++i) { logger.Trace("@@@"); logger.Debug("aaa"); logger.Info("bbb"); logger.Warn("ccc"); logger.Error("ddd"); logger.Fatal("eee"); } LogManager.Flush(); LogManager.Configuration = null; Assert.IsFalse(File.Exists(Path.Combine(tempPath, "Trace.txt"))); AssertFileContents(Path.Combine(tempPath, "Debug.txt"), StringRepeat(250, "aaa " + threadID + "\n"), Encoding.UTF8); AssertFileContents(Path.Combine(tempPath, "Info.txt"), StringRepeat(250, "bbb " + threadID + "\n"), Encoding.UTF8); AssertFileContents(Path.Combine(tempPath, "Warn.txt"), StringRepeat(250, "ccc " + threadID + "\n"), Encoding.UTF8); AssertFileContents(Path.Combine(tempPath, "Error.txt"), StringRepeat(250, "ddd " + threadID + "\n"), Encoding.UTF8); AssertFileContents(Path.Combine(tempPath, "Fatal.txt"), StringRepeat(250, "eee " + threadID + "\n"), Encoding.UTF8); } finally { //if (File.Exists(tempFile)) // File.Delete(tempFile); LogManager.Configuration = null; if (Directory.Exists(tempPath)) Directory.Delete(tempPath, true); } }
internal static void InitCoreLoggers(bool uniqueInstance) { try { if ((Directory.GetCurrentDirectory() != AppContext.BaseDirectory) && File.Exists(NLogConfigurationFile)) { LogManager.Configuration = new XmlLoggingConfiguration(NLogConfigurationFile); } } catch (Exception e) { ASF.ArchiLogger.LogGenericException(e); } if (LogManager.Configuration != null) { IsUsingCustomConfiguration = true; InitConsoleLoggers(); LogManager.ConfigurationChanged += OnConfigurationChanged; return; } ConfigurationItemFactory.Default.ParseMessageTemplates = false; LoggingConfiguration config = new LoggingConfiguration(); ColoredConsoleTarget coloredConsoleTarget = new ColoredConsoleTarget("ColoredConsole") { Layout = GeneralLayout }; config.AddTarget(coloredConsoleTarget); config.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, coloredConsoleTarget)); if (uniqueInstance) { try { if (!Directory.Exists(SharedInfo.ArchivalLogsDirectory)) { Directory.CreateDirectory(SharedInfo.ArchivalLogsDirectory); } } catch (Exception e) { ASF.ArchiLogger.LogGenericException(e); } FileTarget fileTarget = new FileTarget("File") { ArchiveFileName = Path.Combine("${currentdir}", SharedInfo.ArchivalLogsDirectory, SharedInfo.ArchivalLogFile), ArchiveNumbering = ArchiveNumberingMode.Rolling, ArchiveOldFileOnStartup = true, CleanupFileName = false, ConcurrentWrites = false, DeleteOldFileOnStartup = true, FileName = Path.Combine("${currentdir}", SharedInfo.LogFile), Layout = GeneralLayout, MaxArchiveFiles = 10 }; config.AddTarget(fileTarget); config.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, fileTarget)); } LogManager.Configuration = config; InitConsoleLoggers(); }
private static void Start(string[] args) { //register object builder assembly string path = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "SpaceEngineers.ObjectBuilders.DLL"); VRage.Plugins.MyPlugins.RegisterGameObjectBuildersAssemblyFile(path); MyObjectBuilderType.RegisterAssemblies( ); MyObjectBuilderSerializer.RegisterAssembliesAndLoadSerializers( ); //Setup error handling for unmanaged exceptions AppDomain.CurrentDomain.UnhandledException += AppDomain_UnhandledException; Application.ThreadException += Application_ThreadException; Application.SetUnhandledExceptionMode(UnhandledExceptionMode.CatchException); //AppDomain.CurrentDomain.ClearEventInvocations("_unhandledException"); BaseLog.Info("Starting SEServerExtender with {0} arguments: {1}", args.Length, string.Join("\r\n\t", args)); CommandLineArgs extenderArgs = CommandLineArgs = new CommandLineArgs { ConsoleTitle = string.Empty, AutoStart = false, WorldName = string.Empty, InstanceName = string.Empty, NoGui = false, NoConsole = false, Debug = false, GamePath = new DirectoryInfo(PathManager.BasePath).Parent.FullName, //TODO: turn noWFC back to off by default whenever WCF gets fixed NoWcf = true, Autosave = 0, InstancePath = string.Empty, CloseOnCrash = false, RestartOnCrash = false, Args = string.Join(" ", args.Select(x => string.Format("\"{0}\"", x))) }; if (ConfigurationManager.AppSettings["WCFChatMaxMessageHistoryAge"] != null) { if (!int.TryParse(ConfigurationManager.AppSettings["WCFChatMaxMessageHistoryAge"], out _maxChatHistoryMessageAge)) { ConfigurationManager.AppSettings.Add("WCFChatMaxMessageHistoryAge", "3600"); } } if (ConfigurationManager.AppSettings["WCFChatMaxMessageHistoryCount"] != null) { if (!int.TryParse(ConfigurationManager.AppSettings["WCFChatMaxMessageHistoryCount"], out _maxChatHistoryMessageCount)) { ConfigurationManager.AppSettings.Add("WCFChatMaxMessageHistoryCount", "100"); } } bool logPathSet = false; //Process the args foreach (string arg in args) { string[] splitAtEquals = arg.Split('='); if (splitAtEquals.Length > 1) { string argName = splitAtEquals[0]; string argValue = splitAtEquals[1]; string lowerCaseArgument = argName.ToLower( ); if (lowerCaseArgument.Equals("instance")) { if (argValue[argValue.Length - 1] == '"') { argValue = argValue.Substring(1, argValue.Length - 2); } extenderArgs.InstanceName = argValue; //Only let this override log path if the log path wasn't already explicitly set if (!logPathSet) { FileTarget baseLogTarget = LogManager.Configuration.FindTargetByName("BaseLog") as FileTarget; if (baseLogTarget != null) { baseLogTarget.FileName = baseLogTarget.FileName.Render(new LogEventInfo { TimeStamp = DateTime.Now }).Replace("NoInstance", argValue); } FileTarget chatLogTarget = LogManager.Configuration.FindTargetByName("ChatLog") as FileTarget; if (chatLogTarget != null) { chatLogTarget.FileName = chatLogTarget.FileName.Render(new LogEventInfo { TimeStamp = DateTime.Now }).Replace("NoInstance", argValue); } FileTarget pluginLogTarget = LogManager.Configuration.FindTargetByName("PluginLog") as FileTarget; if (pluginLogTarget != null) { pluginLogTarget.FileName = pluginLogTarget.FileName.Render(new LogEventInfo { TimeStamp = DateTime.Now }).Replace("NoInstance", argValue); } } } else if (lowerCaseArgument.Equals("gamepath")) { if (argValue[argValue.Length - 1] == '"') { argValue = argValue.Substring(1, argValue.Length - 2); } extenderArgs.GamePath = argValue; } else if (lowerCaseArgument.Equals("autosave")) { if (!int.TryParse(argValue, out extenderArgs.Autosave)) { BaseLog.Warn("Autosave parameter was not a valid integer."); } } else if (lowerCaseArgument.Equals("path")) { if (argValue[argValue.Length - 1] == '"') { argValue = argValue.Substring(1, argValue.Length - 2); } extenderArgs.InstancePath = argValue; } else if (lowerCaseArgument.Equals("instancepath")) { if (argValue[argValue.Length - 1] == '"') { argValue = argValue.Substring(1, argValue.Length - 2); } extenderArgs.InstancePath = argValue; } else if (lowerCaseArgument.Equals("title")) { if (argValue[argValue.Length - 1] == '"') { argValue = argValue.Substring(1, argValue.Length - 2); } extenderArgs.ConsoleTitle = argValue; } else if (lowerCaseArgument == "logpath") { if (argValue[argValue.Length - 1] == '"') { argValue = argValue.Substring(1, argValue.Length - 2); } //This argument always prevails. FileTarget baseLogTarget = LogManager.Configuration.FindTargetByName("BaseLog") as FileTarget; if (baseLogTarget != null) { Layout l = new SimpleLayout(Path.Combine(argValue, "SEServerExtenderLog-${shortdate}.log")); baseLogTarget.FileName = l.Render(new LogEventInfo { TimeStamp = DateTime.Now }); ApplicationLog.BaseLog = BaseLog; } FileTarget chatLogTarget = LogManager.Configuration.FindTargetByName("ChatLog") as FileTarget; if (chatLogTarget != null) { Layout l = new SimpleLayout(Path.Combine(argValue, "ChatLog-${shortdate}.log")); chatLogTarget.FileName = l.Render(new LogEventInfo { TimeStamp = DateTime.Now }); ApplicationLog.ChatLog = ChatLog; } FileTarget pluginLogTarget = LogManager.Configuration.FindTargetByName("PluginLog") as FileTarget; if (pluginLogTarget != null) { Layout l = new SimpleLayout(Path.Combine(argValue, "PluginLog-${shortdate}.log")); pluginLogTarget.FileName = l.Render(new LogEventInfo { TimeStamp = DateTime.Now }); logPathSet = true; ApplicationLog.PluginLog = PluginLog; } } } else { string lowerCaseArgument = arg.ToLower( ); if (lowerCaseArgument.Equals("autostart")) { extenderArgs.AutoStart = true; } else if (lowerCaseArgument.Equals("nogui")) { extenderArgs.NoGui = true; //Implies autostart //extenderArgs.AutoStart = true; } else if (lowerCaseArgument.Equals("noconsole")) { extenderArgs.NoConsole = true; //Implies nogui and autostart extenderArgs.NoGui = true; extenderArgs.AutoStart = true; } else if (lowerCaseArgument.Equals("debug")) { extenderArgs.Debug = true; } else if (lowerCaseArgument.Equals("nowcf")) { extenderArgs.NoWcf = true; } else if (lowerCaseArgument.Equals("wcfon")) { extenderArgs.NoWcf = false; } else if (lowerCaseArgument.Equals("closeoncrash")) { extenderArgs.CloseOnCrash = true; } else if (lowerCaseArgument.Equals("autosaveasync")) { extenderArgs.AutoSaveSync = false; } else if (lowerCaseArgument.Equals("autosavesync")) { extenderArgs.AutoSaveSync = true; } else if (lowerCaseArgument.Equals("restartoncrash")) { extenderArgs.RestartOnCrash = true; } //these things are legacy and don't work anyway /* * else if ( lowerCaseArgument.Equals( "wrr" ) ) * { * extenderArgs.WorldRequestReplace = true; * } * else if ( lowerCaseArgument.Equals( "wrm" ) ) * { * extenderArgs.WorldDataModify = true; * } * else if (lowerCaseArgument.Equals("wvm")) * { * extenderArgs.WorldVoxelModify = true; * } */ } } if (!Environment.UserInteractive) { extenderArgs.NoConsole = true; extenderArgs.NoGui = true; extenderArgs.AutoStart = true; } if (extenderArgs.Debug) { ExtenderOptions.IsDebugging = true; } try { bool unitTestResult = BasicUnitTestManager.Instance.Run( ); if (!unitTestResult) { ExtenderOptions.IsInSafeMode = true; } Server = Server.Instance; Server.CommandLineArgs = extenderArgs; Server.IsWCFEnabled = !extenderArgs.NoWcf; Server.Init( ); ChatManager.ChatCommand guiCommand = new ChatManager.ChatCommand("gui", ChatCommand_GUI, false); ChatManager.Instance.RegisterChatCommand(guiCommand); if (!CommandLineArgs.NoConsole) { if (string.IsNullOrEmpty(extenderArgs.ConsoleTitle) || string.IsNullOrWhiteSpace(extenderArgs.ConsoleTitle)) { Console.Title = "SESE"; } else { Console.Title = extenderArgs.ConsoleTitle; } } if (extenderArgs.AutoStart) { Server.StartServer( ); } if (!extenderArgs.NoWcf) { string uriString = string.Format("{0}{1}", ConfigurationManager.AppSettings["WCFServerServiceBaseAddress"], CommandLineArgs.InstanceName); BaseLog.Info("Opening up WCF service listener at {0}", uriString); ServerServiceHost = new ServiceHost(typeof(ServerService.ServerService), new Uri(uriString, UriKind.Absolute)); ServerServiceHost.Open( ); ChatManager.Instance.ChatMessage += ChatManager_ChatMessage; } if (!extenderArgs.NoGui) { Thread uiThread = new Thread(StartGui); uiThread.SetApartmentState(ApartmentState.STA); uiThread.Start( ); } else if (Environment.UserInteractive) { Console.ReadLine( ); } } catch (AutoException eEx) { if (!extenderArgs.NoConsole) { BaseLog.Info("AutoException - {0}\n\r{1}", eEx.AdditionnalInfo, eEx.GetDebugString( )); } if (!extenderArgs.NoGui) { MessageBox.Show(string.Format("{0}\n\r{1}", eEx.AdditionnalInfo, eEx.GetDebugString( )), @"SEServerExtender", MessageBoxButtons.OK, MessageBoxIcon.Error); } if (extenderArgs.NoConsole && extenderArgs.NoGui) { throw eEx.GetBaseException( ); } } catch (TargetInvocationException ex) { if (!extenderArgs.NoConsole) { BaseLog.Info("TargetInvocationException - {0}\n\r{1}", ex, ex.InnerException); } if (!extenderArgs.NoGui) { MessageBox.Show(string.Format("{0}\n\r{1}", ex, ex.InnerException), @"SEServerExtender", MessageBoxButtons.OK, MessageBoxIcon.Error); } if (extenderArgs.NoConsole && extenderArgs.NoGui) { throw; } } catch (Exception ex) { if (!extenderArgs.NoConsole) { BaseLog.Info(ex, "Exception - {0}", ex); } if (!extenderArgs.NoGui) { MessageBox.Show(ex.ToString( ), @"SEServerExtender", MessageBoxButtons.OK, MessageBoxIcon.Error); } if (extenderArgs.NoConsole && extenderArgs.NoGui) { throw; } } }
/// <summary> /// Initializes application logging. /// </summary> /// <param name="path">The path.</param> /// <param name="remoteLoggingEnabled">if set to <c>true</c> [remote logging enabled].</param> /// <param name="remoteLogIpAddress">The remote log ip address.</param> /// <returns>ILogger.</returns> public static ILogger InitializeLogging(string path, bool remoteLoggingEnabled, string remoteLogIpAddress) { var filePath = Path.Combine(path, $"{DateTime.Today.Month}-{DateTime.Today.Day}-{DateTime.Today.Year}.log"); var jsonFilePath = Path.Combine(path, $"{DateTime.Today.Month}-{DateTime.Today.Day}-{DateTime.Today.Year}.json"); var config = new LoggingConfiguration(); var jsonLayout = new JsonLayout { Attributes = { new JsonAttribute("date", "${date:format=MM-dd-yyyy}"), new JsonAttribute("time", "${time}"), new JsonAttribute("friendlytime", @"${date:format=HH\:mm\:ss}"), new JsonAttribute("hour", "${date:format=HH}"), new JsonAttribute("minute", "${date:format=mm}"), new JsonAttribute("ticks", "${ticks}"), new JsonAttribute("logger", "${logger}"), new JsonAttribute("level", "${level}"), new JsonAttribute("appDomain", "${appdomain}"), new JsonAttribute("version", "${assembly-version}"), new JsonAttribute("ident", "${identity}"), new JsonAttribute("winIdent", "${windows-identity}"), new JsonAttribute("machine", "${machinename}"), new JsonAttribute("message", "${message}"), new JsonAttribute("exceptionData", new JsonLayout { Attributes = { new JsonAttribute("exception", "${exception}"), new JsonAttribute("stack", "${stacktrace}"), new JsonAttribute("callSite", "${callsite}"), new JsonAttribute("callSite-Line", "${callsite-linenumber}") }, RenderEmptyObject = false }) } }; if (remoteLoggingEnabled) { var viewerTarget = new NLogViewerTarget { Encoding = Encoding.UTF8, IncludeCallSite = true, NewLine = true, OnOverflow = NetworkTargetOverflowAction.Split, MaxConnections = 0, MaxMessageSize = 65565, ConnectionCacheSize = 25, KeepConnection = true, IncludeSourceInfo = true, IncludeMdc = true, IncludeNLogData = true, IncludeNdc = true, Address = $"udp://{remoteLogIpAddress}", Layout = jsonLayout }; config.AddTarget("RemoteViewer", viewerTarget); config.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, viewerTarget)); } var fileTarget = new FileTarget { FileName = filePath, Layout = @"${date:format=HH\:mm\:ss} ${logger} ${message}" }; config.AddTarget("LogFile", fileTarget); config.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, fileTarget)); var jsonTarget = new FileTarget { FileName = jsonFilePath, Layout = jsonLayout }; config.AddTarget("JsonLogFile", jsonTarget); config.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, jsonTarget)); LogManager.Configuration = config; _logger = LogManager.GetCurrentClassLogger(); return _logger; }
public static void Configure(Settings settings, bool logToConsole) { LogManager.Use <NLogFactory>(); if (NLog.LogManager.Configuration != null) { return; } var version = FileVersionInfo.GetVersionInfo(typeof(Host).Assembly.Location).ProductVersion; var nlogConfig = new LoggingConfiguration(); var simpleLayout = new SimpleLayout("${longdate}|${threadid}|${level}|${logger}|${message}${onexception:${newline}${exception:format=tostring}}"); var header = $@"------------------------------------------------------------- ServiceControl Monitoring Version: {version} Selected Transport: {settings.TransportType} -------------------------------------------------------------"; var fileTarget = new FileTarget { ArchiveEvery = FileArchivePeriod.Day, FileName = Path.Combine(settings.LogPath, "logfile.${shortdate}.txt"), ArchiveFileName = Path.Combine(settings.LogPath, "logfile.{#}.txt"), ArchiveNumbering = ArchiveNumberingMode.DateAndSequence, Layout = simpleLayout, MaxArchiveFiles = 14, ArchiveAboveSize = 30 * MegaByte, Header = new SimpleLayout(header) }; var consoleTarget = new ColoredConsoleTarget { Layout = simpleLayout, UseDefaultRowHighlightingRules = true }; var nullTarget = new NullTarget(); nlogConfig.AddTarget("console", consoleTarget); nlogConfig.AddTarget("debugger", fileTarget); nlogConfig.AddTarget("null", nullTarget); //Suppress NSB license logging since this will have it's own nlogConfig.LoggingRules.Add(new LoggingRule("NServiceBus.LicenseManager", LogLevel.Info, nullTarget) { Final = true }); // Always want to see license logging regardless of default logging level nlogConfig.LoggingRules.Add(new LoggingRule("ServiceControl.Monitoring.Licensing.*", LogLevel.Info, fileTarget)); nlogConfig.LoggingRules.Add(new LoggingRule("ServiceControl.Monitoring.Licensing.*", LogLevel.Info, consoleTarget) { Final = true }); // Defaults nlogConfig.LoggingRules.Add(new LoggingRule("*", settings.LogLevel, fileTarget)); nlogConfig.LoggingRules.Add(new LoggingRule("*", settings.LogLevel < LogLevel.Info ? settings.LogLevel : LogLevel.Info, consoleTarget)); if (logToConsole) { foreach (var rule in nlogConfig.LoggingRules.Where(p => p.Targets.Contains(consoleTarget)).ToList()) { nlogConfig.LoggingRules.Remove(rule); } } NLog.LogManager.Configuration = nlogConfig; var logger = LogManager.GetLogger("LoggingConfiguration"); var logEventInfo = new LogEventInfo { TimeStamp = DateTime.Now }; logger.InfoFormat("Logging to {0} with LogLevel '{1}'", fileTarget.FileName.Render(logEventInfo), settings.LogLevel.Name); }
static void Main(string[] args) { CommandLineApplication app = new CommandLineApplication(); app.HelpOption("-? | -h | --help"); var UserNameOption = app.Option( "-u | --username <USERNAME>", "The UserName to login to the Covenant API. (env: COVENANT_USERNAME)", CommandOptionType.SingleValue ); var PasswordOption = app.Option( "-p | --password <PASSWORD>", "The Password to login to the Covenant API. (env: COVENANT_PASSWORD)", CommandOptionType.SingleValue ); var ComputerNameOption = app.Option( "-c | --computername <COMPUTERNAME>", "The ComputerName (IPAddress or Hostname) to bind the Covenant API to. (env: COVENANT_COMPUTER_NAME)", CommandOptionType.SingleValue ); app.OnExecute(() => { if (!File.Exists(Path.Combine(Common.CovenantSharpSploitDirectory, "SharpSploit.sln")) || !File.Exists(Path.Combine(Common.CovenantRubeusDirectory, "Rubeus.sln"))) { Console.Error.WriteLine("Error: git submodules have not been initialized"); Console.Error.WriteLine("Covenant's submodules can be cloned with: git clone --recurse-submodules https://github.com/cobbr/Covenant"); Console.Error.WriteLine("Or initialized after cloning with: git submodule update --init --recursive"); return(-1); } string username = UserNameOption.HasValue() ? UserNameOption.Value() : Environment.GetEnvironmentVariable("COVENANT_USERNAME"); string password = PasswordOption.HasValue() ? PasswordOption.Value() : Environment.GetEnvironmentVariable("COVENANT_PASSWORD"); if (!string.IsNullOrEmpty(username) && string.IsNullOrEmpty(password)) { Console.Write("Password: "******"COVENANT_COMPUTER_NAME");; if (string.IsNullOrEmpty(CovenantBindUrl)) { CovenantBindUrl = "0.0.0.0"; } IPAddress address = null; try { address = IPAddress.Parse(CovenantBindUrl); } catch (FormatException) { address = Dns.GetHostAddresses(CovenantBindUrl).FirstOrDefault(); } IPEndPoint CovenantEndpoint = new IPEndPoint(address, Common.CovenantHTTPSPort); string CovenantUri = (CovenantBindUrl == "0.0.0.0" ? "https://127.0.0.1:" + Common.CovenantHTTPSPort : "https://" + CovenantEndpoint); var host = BuildHost(CovenantEndpoint, CovenantUri); using (var scope = host.Services.CreateScope()) { var services = scope.ServiceProvider; var context = services.GetRequiredService <CovenantContext>(); var service = services.GetRequiredService <ICovenantService>(); var userManager = services.GetRequiredService <UserManager <CovenantUser> >(); var signInManager = services.GetRequiredService <SignInManager <CovenantUser> >(); var roleManager = services.GetRequiredService <RoleManager <IdentityRole> >(); var configuration = services.GetRequiredService <IConfiguration>(); var listenerTokenSources = services.GetRequiredService <ConcurrentDictionary <int, CancellationTokenSource> >(); context.Database.EnsureCreated(); DbInitializer.Initialize(service, context, roleManager, listenerTokenSources).Wait(); CovenantUser serviceUser = new CovenantUser { UserName = "******" }; if (!context.Users.Any()) { string serviceUserPassword = Utilities.CreateSecretPassword() + "A"; userManager.CreateAsync(serviceUser, serviceUserPassword).Wait(); userManager.AddToRoleAsync(serviceUser, "ServiceUser").Wait(); if (!string.IsNullOrEmpty(username) && !string.IsNullOrEmpty(password)) { CovenantUser user = new CovenantUser { UserName = username }; Task <IdentityResult> task = userManager.CreateAsync(user, password); task.Wait(); IdentityResult userResult = task.Result; if (userResult.Succeeded) { userManager.AddToRoleAsync(user, "User").Wait(); userManager.AddToRoleAsync(user, "Administrator").Wait(); } else { Console.Error.WriteLine($"Error creating user: {user.UserName}"); return(-1); } } } configuration["ServiceUserToken"] = Utilities.GenerateJwtToken( serviceUser.UserName, serviceUser.Id, new string[] { "ServiceUser" }, configuration["JwtKey"], configuration["JwtIssuer"], configuration["JwtAudience"], configuration["JwtExpireDays"] ); } LoggingConfiguration loggingConfig = new LoggingConfiguration(); var consoleTarget = new ColoredConsoleTarget(); var fileTarget = new FileTarget(); loggingConfig.AddTarget("console", consoleTarget); loggingConfig.AddTarget("file", fileTarget); consoleTarget.Layout = @"${longdate}|${event-properties:item=EventId_Id}|${uppercase:${level}}|${logger}|${message} ${exception:format=tostring}"; fileTarget.Layout = @"${longdate}|${event-properties:item=EventId_Id}|${uppercase:${level}}|${logger}|${message} ${exception:format=tostring}"; fileTarget.FileName = Common.CovenantLogDirectory + "covenant.log"; loggingConfig.AddRule(NLog.LogLevel.Info, NLog.LogLevel.Fatal, "console"); loggingConfig.AddRule(NLog.LogLevel.Info, NLog.LogLevel.Fatal, "file"); var logger = NLogBuilder.ConfigureNLog(loggingConfig).GetCurrentClassLogger(); try { logger.Debug("Starting Covenant API"); if (!IsElevated()) { Console.Error.WriteLine("WARNING: Running Covenant non-elevated. You may not have permission to start Listeners on low-numbered ports. Consider running Covenant elevated."); } host.Run(); } catch (Exception ex) { logger.Error(ex, "Covenant stopped due to exception"); throw; } finally { NLog.LogManager.Shutdown(); } return(0); }); app.Execute(args); }
static void Main(string[] args) { Console.WriteLine($"GC: " + System.Runtime.GCSettings.LatencyMode); System.Runtime.GCSettings.LatencyMode = System.Runtime.GCLatencyMode.SustainedLowLatency; Options options = null; Parser.Default .ParseArguments <Options>(args) .WithParsed <Options>((opts) => options = opts) /*.WithNotParsed<Options>((errs) => HandleParseError(errs))*/; if (args.Length < 1) { //error } //var usage = "%prog [options] <config file>"; //var opts = optparse.OptionParser(usage); //opts.add_option("-i", "--debuginput", dest: "debuginput", help: "read commands from file instead of from tty port"); //opts.add_option("-I", "--input-tty", dest: "inputtty", @default: "/tmp/printer", help: "input tty name (default is /tmp/printer)"); //opts.add_option("-l", "--logfile", dest: "logfile", help: "write log to file instead of stderr"); //opts.add_option("-v", action: "store_true", dest: "verbose", help: "enable debug messages"); //opts.add_option("-o", "--debugoutput", dest: "debugoutput", help: "write output to file instead of to serial port"); //opts.add_option("-d", "--dictionary", dest: "dictionary", type: "string", action: "callback", callback: arg_dictionary, help: "file to read for mcu protocol dictionary"); //var _tup_1 = opts.parse_args(); //var options = _tup_1.Item1; //var args = _tup_1.Item2; //if (args.Length != 1) //{ // opts.error("Incorrect number of arguments"); //} var start_args = new Dictionary <string, object> { { "config_file", args[0] }, { "start_reason", "startup" } }; Stream input_fd = null; var debuglevel = LogLevel.Info; object bglogger = null; if (options.Verbose) { debuglevel = LogLevel.Debug; } if (options.Debuginput != null) { start_args["debuginput"] = options.Debuginput; var debuginput = File.OpenRead(options.Debuginput); input_fd = debuginput; } else { //input_fd = util.create_pty(options.Inputtty); } if (options.Debugoutput != null) { start_args["debugoutput"] = options.Debugoutput; //start_args.update(options.Dictionary); } //if (options.Logfile != null) //{ // bglogger = queuelogger.setup_bg_logging(options.Logfile, debuglevel); //} var config = new LoggingConfiguration(); var logfile = new FileTarget("logfile") { FileName = "file.txt" }; var logconsole = new ConsoleTarget("logconsole"); config.AddRule(LogLevel.Debug, LogLevel.Fatal, logconsole); config.AddRule(LogLevel.Debug, LogLevel.Fatal, logfile); LogManager.Configuration = config; var logging = LogManager.GetCurrentClassLogger(); logging.Info("Starting Klippy..."); start_args["software_version"] = 1.0; //util.get_git_version(); if (bglogger != null) { //var versions = string.Join("\n", new List<string> { // String.Format("Args: %s", sys.argv), // String.Format("Git version: %s", repr(start_args["software_version"])), // String.Format("CPU: %s", util.get_cpu_info()), // String.Format("Python: %s", repr(sys.version)) //}); //logging.Info(versions); } // Start Printer() class string res; while (true) { if (bglogger != null) { //bglogger.clear_rollover_info(); //bglogger.set_rollover_info("versions", versions); } var printer = new Machine(input_fd, null /*bglogger*/, start_args); res = printer.run(); if ("exit" == res || "error_exit" == res) { break; } Thread.Sleep(1000); logging.Info("Restarting printer"); start_args["start_reason"] = res; } if (bglogger != null) { //bglogger.stop(); } if (res == "error_exit") { Environment.ExitCode = -1; } }
private static ILogger GetLog() { var config = new NLog.Config.LoggingConfiguration(); var fileTarget = new FileTarget("logfile") { FileName = CurrentLogPath, ArchiveEvery = FileArchivePeriod.Day, ArchiveNumbering = ArchiveNumberingMode.DateAndSequence, KeepFileOpen = true, ConcurrentWrites = false, AutoFlush = false, OpenFileFlushTimeout = 1, Layout = "${longdate} ${sequenceid:padding=6} ${level:uppercase=true:padding=-5} ${message} ${onexception:" + "${newline}${exception:format=ToString}" + ":when=not contains('${exception:format=ShortType}','TaskCanceledException')}", }; var asyncFileTarget = new AsyncTargetWrapper(fileTarget) { TimeToSleepBetweenBatches = 0, OverflowAction = AsyncTargetWrapperOverflowAction.Block, BatchSize = 500, }; var consoleTarget = new ColoredConsoleTarget("logconsole") { Layout = "${longdate} ${level:uppercase=true:padding=-5} ${message} ${onexception:" + "${newline}${exception:format=Message}" + ":when=not contains('${exception:format=ShortType}','TaskCanceledException')}", }; var watchdogTarget = new MethodCallTarget("watchdog") { ClassName = typeof(Watchdog).AssemblyQualifiedName, MethodName = nameof(Watchdog.OnLogHandler), }; watchdogTarget.Parameters.AddRange(new[] { new MethodCallParameter("${level}"), new MethodCallParameter("${message}"), }); #if DEBUG config.AddRule(LogLevel.Trace, LogLevel.Fatal, consoleTarget, "default"); // only echo messages from default logger to the console #else config.AddRule(LogLevel.Info, LogLevel.Fatal, consoleTarget, "default"); #endif config.AddRule(LogLevel.Debug, LogLevel.Fatal, asyncFileTarget); config.AddRule(LogLevel.Info, LogLevel.Fatal, watchdogTarget); var ignoreFilter1 = new ConditionBasedFilter { Condition = "contains('${message}','TaskCanceledException')", Action = FilterResult.Ignore, }; var ignoreFilter2 = new ConditionBasedFilter { Condition = "contains('${message}','One or more pre-execution checks failed')", Action = FilterResult.Ignore, }; foreach (var rule in config.LoggingRules) { rule.Filters.Add(ignoreFilter1); rule.Filters.Add(ignoreFilter2); } LogManager.Configuration = config; return(LogManager.GetLogger("default")); }
public void TargetContructorWithNameTest() { var targetTypes = typeof(Target).Assembly.GetTypes().Where(t => !t.IsAbstract && t.IsSubclassOf(typeof(Target))).ToList(); int neededCheckCount = targetTypes.Count; int checkCount = 0; Target fileTarget = new FileTarget(); Target memoryTarget = new MemoryTarget(); foreach (Type targetType in targetTypes) { string lastPropertyName = null; try { // Check if the Target can be created using a default constructor var name = targetType + "_name"; var isWrapped = targetType.IsSubclassOf(typeof(WrapperTargetBase)); var isCompound = targetType.IsSubclassOf(typeof(CompoundTargetBase)); if (isWrapped) { neededCheckCount++; var args = new List <object> { fileTarget }; //default ctor var defaultConstructedTarget = (WrapperTargetBase)Activator.CreateInstance(targetType); defaultConstructedTarget.Name = name; defaultConstructedTarget.WrappedTarget = fileTarget; //specials cases if (targetType == typeof(FilteringTargetWrapper)) { ConditionLoggerNameExpression cond = null; args.Add(cond); var target = (FilteringTargetWrapper)defaultConstructedTarget; target.Condition = cond; } else if (targetType == typeof(RepeatingTargetWrapper)) { var repeatCount = 5; args.Add(repeatCount); var target = (RepeatingTargetWrapper)defaultConstructedTarget; target.RepeatCount = repeatCount; } else if (targetType == typeof(RetryingTargetWrapper)) { var retryCount = 10; var retryDelayMilliseconds = 100; args.Add(retryCount); args.Add(retryDelayMilliseconds); var target = (RetryingTargetWrapper)defaultConstructedTarget; target.RetryCount = retryCount; target.RetryDelayMilliseconds = retryDelayMilliseconds; } //ctor: target var targetConstructedTarget = (WrapperTargetBase)Activator.CreateInstance(targetType, args.ToArray()); targetConstructedTarget.Name = name; args.Insert(0, name); //ctor: target+name var namedConstructedTarget = (WrapperTargetBase)Activator.CreateInstance(targetType, args.ToArray()); CheckEquals(targetType, targetConstructedTarget, namedConstructedTarget, ref lastPropertyName, ref checkCount); CheckEquals(targetType, defaultConstructedTarget, namedConstructedTarget, ref lastPropertyName, ref checkCount); } else if (isCompound) { neededCheckCount++; //multiple targets var args = new List <object> { fileTarget, memoryTarget }; //specials cases //default ctor var defaultConstructedTarget = (CompoundTargetBase)Activator.CreateInstance(targetType); defaultConstructedTarget.Name = name; defaultConstructedTarget.Targets.Add(fileTarget); defaultConstructedTarget.Targets.Add(memoryTarget); //ctor: target var targetConstructedTarget = (CompoundTargetBase)Activator.CreateInstance(targetType, args.ToArray()); targetConstructedTarget.Name = name; args.Insert(0, name); //ctor: target+name var namedConstructedTarget = (CompoundTargetBase)Activator.CreateInstance(targetType, args.ToArray()); CheckEquals(targetType, targetConstructedTarget, namedConstructedTarget, ref lastPropertyName, ref checkCount); CheckEquals(targetType, defaultConstructedTarget, namedConstructedTarget, ref lastPropertyName, ref checkCount); } else { //default ctor var targetConstructedTarget = (Target)Activator.CreateInstance(targetType); targetConstructedTarget.Name = name; // ctor: name var namedConstructedTarget = (Target)Activator.CreateInstance(targetType, name); CheckEquals(targetType, targetConstructedTarget, namedConstructedTarget, ref lastPropertyName, ref checkCount); } } catch (Exception ex) { var constructionFailed = true; string failureMessage = $"Error testing constructors for '{targetType}.{lastPropertyName}`\n{ex.ToString()}"; Assert.False(constructionFailed, failureMessage); } } Assert.Equal(neededCheckCount, checkCount); }
public void Init(string DirectoryPath, string LogName, Encoding encoding, LogLevel loglevel, long MaximumFileSize = 1024 * 1024 * 20) { isRunning = true; // Step 1. Create configuration object var config = new LoggingConfiguration(); // Step 2. Create targets and add them to the configuration var fileTarget = new FileTarget(); config.AddTarget(LogName, fileTarget); // Step 3. Set target properties fileTarget.Layout = "${message}"; fileTarget.FileName = DirectoryPath + "/" + LogName + ".log"; fileTarget.ArchiveAboveSize = MaximumFileSize; fileTarget.ArchiveEvery = FileArchivePeriod.Day; fileTarget.ArchiveFileName = DirectoryPath + "/${shortdate}/" + LogName + "_{#}.log"; fileTarget.ArchiveNumbering = ArchiveNumberingMode.Sequence; fileTarget.MaxArchiveFiles = 1000; fileTarget.Encoding = encoding; NLog.LogLevel lv = NLog.LogLevel.Debug; if (loglevel == LogLevel.Debug) { lv = NLog.LogLevel.Debug; } else if (loglevel == LogLevel.Error) { lv = NLog.LogLevel.Error; } else if (loglevel == LogLevel.Fatal) { lv = NLog.LogLevel.Fatal; } else if (loglevel == LogLevel.Info) { lv = NLog.LogLevel.Info; } else if (loglevel == LogLevel.Off) { lv = NLog.LogLevel.Off; } else if (loglevel == LogLevel.Trace) { lv = NLog.LogLevel.Trace; } else if (loglevel == LogLevel.Warn) { lv = NLog.LogLevel.Warn; } // Step 4. Define rules var rule = new LoggingRule(LogName, lv, fileTarget); config.LoggingRules.Add(rule); // Step 5. Activate the configuration LogManager.Configuration = config; logger = LogManager.GetLogger(LogName); writethread.Add(Task.Factory.StartNew(() => WriteToFile(), TaskCreationOptions.LongRunning)); TaskScheduler.UnobservedTaskException += (sender, args) => { foreach (var ex in args.Exception.InnerExceptions) { logger.Fatal(ex.ToString()); } args.SetObserved(); }; isInitialized = true; logger.Info(msgWithTime(" Program Started!")); }
/* Now we write our main program, making reference to the functions above where necessary. */ static void Main(string[] args) { /* Set up log functionality */ var config = new LoggingConfiguration(); var target = new FileTarget { FileName = @"C:\Work\Logs\SupportBank.log", Layout = @"${longdate} ${level} - ${logger}: ${message}" }; config.AddTarget("File Logger", target); config.LoggingRules.Add(new LoggingRule("*", LogLevel.Info, target)); LogManager.Configuration = config; ILogger logger = LogManager.GetCurrentClassLogger(); logger.Info("And so we begin!"); /* This section reads all the data we'll be using */ int entries = 0; Debt[] total_debts = new Debt[0]; total_debts = Import_csv(@"C:\Work\Training\SupportBank\Transactions2014.csv", entries, total_debts); entries = total_debts.Length; logger.Info("Finished reading 2014 entries."); total_debts = Import_csv(@"C:\Work\Training\SupportBank\DodgyTransactions2015.csv", entries, total_debts); entries = total_debts.Length; logger.Info("Finished reading dodgy 2015 entries."); logger.Info("We've read the CSV files"); /* Now we read the Json file. We use the function above to turn it into a string, deserialise it, convert it to the debt format, and add to the list */ total_debts = Import_json(@"C:\Work\Training\SupportBank\Transactions2013.json", entries, total_debts); entries = total_debts.Length; logger.Info("We've read the Json file"); /* Now we read the xml file */ string json_of_xml = import_xml_to_json(@"C:\Users\RTL\Documents\Transactions2012.xml"); total_debts = Import_json_string(json_of_xml, entries, total_debts); entries = total_debts.Length; /* Now we get a list of all the different people involved */ List <string> people = new List <string>(); for (int i = 0; i < entries; i++) // Look at each transaction in turn { Debt transaction = total_debts[i]; try { if (transaction.From != "") { people.Add(transaction.From); // Add whoever owes to the list } if (transaction.To != "") { people.Add(transaction.To); // Add whoever is owed to the list } } catch { // } } people = people.Distinct().ToList(); // Remove any duplicates in the list of people. /* That finishes out compilation and sorting of the data. Here we start the actual process of taking user commands, and * churning out whatever data they have requested */ bool running = true; while (running == true) { Console.WriteLine("Enter a command (List All, List [Specific person], Import File or Exit): "); string input = Console.ReadLine(); // Get user input for the command" var case_string = ""; if (input == "List All" || input == "Exit" || input == "Import File") { case_string = input; } else if (input.StartsWith("List")) { case_string = "List Person"; } switch (case_string) { case ("List All"): { logger.Info("User wants a list of all the data!"); List_all(people, entries, total_debts); // If they want List All, run that function break; } case ("Exit"): { logger.Info("User wants to leave me. What have I done??"); running = false; // If they input Exit, end the program break; } case ("Import File"): // Add functionality for the user to specify a file to import. { logger.Info("User wants to import another file. Eurgh!"); Console.WriteLine("Please enter the file that you would like to import"); string file_name = Console.ReadLine(); // Get user input for the file to import. try { string file_type = file_name.Substring(file_name.Length - 4, 4); /* Now we deal with the different cases of different filetypes */ switch (file_type) { /* At this point it makes sense to create new functions to deal with the different cases */ case ".csv": { logger.Info("User wants to import a CSV. We all love commas!"); total_debts = Import_csv(file_name, entries, total_debts); entries = total_debts.Length; people = new List <string>(); // Update the list of people for (int i = 0; i < entries; i++) // Look at each transaction in turn { Debt transaction = total_debts[i]; try { if (transaction.From != "") { people.Add(transaction.From); // Add whoever owes to the list } if (transaction.To != "") { people.Add(transaction.To); // Add whoever is owed to the list } } catch { // } } people = people.Distinct().ToList(); // Remove any duplicates in the list of people. break; } case "json": { logger.Info("User wants to import a json???? WHYYYYYY"); total_debts = Import_json(file_name, entries, total_debts); entries = total_debts.Length; people = new List <string>(); // Update the list of people for (int i = 0; i < entries; i++) // Look at each transaction in turn { Debt transaction = total_debts[i]; try { if (transaction.From != "") { people.Add(transaction.From); // Add whoever owes to the list } if (transaction.To != "") { people.Add(transaction.To); // Add whoever is owed to the list } } catch { // } } people = people.Distinct().ToList(); // Remove any duplicates in the list of people. break; } default: Console.WriteLine("Invalid file name! Please try again."); break; } } /* If the filename they inputted doesn't end in a sensible way, or is not long enough, we reach this part */ catch { Console.WriteLine("Invalid file name! Please try again."); } break; } case ("List Person"): { string specific_person = input.Substring(5); if (people.Contains(specific_person)) { logger.Info("User wants to know the specific transactions of " + specific_person + ". Curious..."); List_person(specific_person, people, entries, total_debts); } else { logger.Info("User wants to find the transactions of " + specific_person + " but they don't exist :("); Console.WriteLine("Error - cannot find this person. Please try again."); } break; } default: { logger.Info("User can't even do a valid input command. They tried to hit me with {0}. User? More like loser!", input); Console.WriteLine("Invalid input. Please enter a valid command."); break; } } } }
public void SequentialArchiveTest1() { var tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString()); var tempFile = Path.Combine(tempPath, "file.txt"); try { var ft = new FileTarget { FileName = tempFile, ArchiveFileName = Path.Combine(tempPath, "archive/{####}.txt"), ArchiveAboveSize = 1000, LineEnding = LineEndingMode.LF, Layout = "${message}", MaxArchiveFiles = 3, ArchiveNumbering = ArchiveNumberingMode.Sequence }; SimpleConfigurator.ConfigureForTargetLogging(ft, LogLevel.Debug); // we emit 5 * 250 *(3 x aaa + \n) bytes // so that we should get a full file + 3 archives for (var i = 0; i < 250; ++i) { logger.Debug("aaa"); } for (var i = 0; i < 250; ++i) { logger.Debug("bbb"); } for (var i = 0; i < 250; ++i) { logger.Debug("ccc"); } for (var i = 0; i < 250; ++i) { logger.Debug("ddd"); } for (var i = 0; i < 250; ++i) { logger.Debug("eee"); } LogManager.Configuration = null; AssertFileContents(tempFile, StringRepeat(250, "eee\n"), Encoding.UTF8); AssertFileContents( Path.Combine(tempPath, "archive/0001.txt"), StringRepeat(250, "bbb\n"), Encoding.UTF8); AssertFileContents( Path.Combine(tempPath, "archive/0002.txt"), StringRepeat(250, "ccc\n"), Encoding.UTF8); AssertFileContents( Path.Combine(tempPath, "archive/0003.txt"), StringRepeat(250, "ddd\n"), Encoding.UTF8); Assert.IsTrue(!File.Exists(Path.Combine(tempPath, "archive/0000.txt"))); Assert.IsTrue(!File.Exists(Path.Combine(tempPath, "archive/0004.txt"))); } finally { LogManager.Configuration = null; if (File.Exists(tempFile)) { File.Delete(tempFile); } if (Directory.Exists(tempPath)) { Directory.Delete(tempPath, true); } } }
public void RollingArchiveTest1() { // create the file in a not-existent // directory which forces creation string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString()); string tempFile = Path.Combine(tempPath, "file.txt"); try { FileTarget ft = new FileTarget(); ft.FileName = tempFile; ft.ArchiveFileName = Path.Combine(tempPath, "archive/{####}.txt"); ft.ArchiveAboveSize = 1000; ft.LineEnding = LineEndingMode.LF; ft.ArchiveNumbering = ArchiveNumberingMode.Rolling; ft.Layout = "${message}"; ft.MaxArchiveFiles = 3; SimpleConfigurator.ConfigureForTargetLogging(ft, LogLevel.Debug); // we emit 5 * 250 * (3 x aaa + \n) bytes // so that we should get a full file + 3 archives for (int i = 0; i < 250; ++i) { logger.Debug("aaa"); } for (int i = 0; i < 250; ++i) { logger.Debug("bbb"); } for (int i = 0; i < 250; ++i) { logger.Debug("ccc"); } for (int i = 0; i < 250; ++i) { logger.Debug("ddd"); } for (int i = 0; i < 250; ++i) { logger.Debug("eee"); } LogManager.Configuration = null; AssertFileContents(tempFile, StringRepeat(250, "eee\n"), Encoding.UTF8); AssertFileContents( Path.Combine(tempPath, "archive/0000.txt"), StringRepeat(250, "ddd\n"), Encoding.UTF8); AssertFileContents( Path.Combine(tempPath, "archive/0001.txt"), StringRepeat(250, "ccc\n"), Encoding.UTF8); AssertFileContents( Path.Combine(tempPath, "archive/0002.txt"), StringRepeat(250, "bbb\n"), Encoding.UTF8); Assert.IsTrue(!File.Exists(Path.Combine(tempPath, "archive/0003.txt"))); } finally { LogManager.Configuration = null; if (File.Exists(tempFile)) File.Delete(tempFile); if (Directory.Exists(tempPath)) Directory.Delete(tempPath, true); } }
private static void Main() { #if DEBUG AllocConsole(); var defaultStdout = new IntPtr(7); if (GetStdHandle(StdOutputHandle) != defaultStdout) { SetStdHandle(StdOutputHandle, defaultStdout); } Console.SetOut(new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = true }); Console.Title = $"{Name} - Build: {Version}"; var config = new LoggingConfiguration(); var developerLog = new ColoredConsoleTarget() { Name = "developer", Layout = @"[${date:format=HH\:mm\:ss}] [${level}] ${message} ${exception}" }; var developerFile = new FileTarget() { Name = "developer-file", FileName = "../../../logs/assetsmanager/Build ${assembly-version}/${level}/${date:format=dd-MM-yyyy HH.mm.ss}.txt", Layout = @"[${date:format=HH\:mm\:ss}] [${level}] ${message} ${exception}" }; config.AddTarget(developerLog); config.AddTarget(developerFile); config.AddRule(LogLevel.Info, LogLevel.Fatal, developerFile); config.AddRuleForAllLevels(developerLog); LogManager.Configuration = config; RollbarLocator.RollbarInstance.Configure(new RollbarConfig(RollbarId)); #endif Info("Game Xml Manager is loading..."); try { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new Manager()); } catch (Exception e) { Info("An error occurred!"); Error(e); Thread.Sleep(100); Warn("Press 'ESC' to close..."); #if DEBUG while (Console.ReadKey(true).Key != ConsoleKey.Escape) { ; } #endif Environment.Exit(0); } }
public void DeleteFileOnStartTest() { string tempFile = Path.GetTempFileName(); try { FileTarget ft = new FileTarget(); ft.FileName = SimpleLayout.Escape(tempFile); ft.LineEnding = LineEndingMode.LF; ft.Layout = "${level} ${message}"; SimpleConfigurator.ConfigureForTargetLogging(ft, LogLevel.Debug); logger.Debug("aaa"); logger.Info("bbb"); logger.Warn("ccc"); LogManager.Configuration = null; AssertFileContents(tempFile, "Debug aaa\nInfo bbb\nWarn ccc\n", Encoding.UTF8); // configure again, without // DeleteOldFileOnStartup ft = new FileTarget(); ft.FileName = SimpleLayout.Escape(tempFile); ft.LineEnding = LineEndingMode.LF; ft.Layout = "${level} ${message}"; SimpleConfigurator.ConfigureForTargetLogging(ft, LogLevel.Debug); logger.Debug("aaa"); logger.Info("bbb"); logger.Warn("ccc"); LogManager.Configuration = null; AssertFileContents(tempFile, "Debug aaa\nInfo bbb\nWarn ccc\nDebug aaa\nInfo bbb\nWarn ccc\n", Encoding.UTF8); // configure again, this time with // DeleteOldFileOnStartup ft = new FileTarget(); ft.FileName = SimpleLayout.Escape(tempFile); ft.LineEnding = LineEndingMode.LF; ft.Layout = "${level} ${message}"; ft.DeleteOldFileOnStartup = true; SimpleConfigurator.ConfigureForTargetLogging(ft, LogLevel.Debug); logger.Debug("aaa"); logger.Info("bbb"); logger.Warn("ccc"); LogManager.Configuration = null; AssertFileContents(tempFile, "Debug aaa\nInfo bbb\nWarn ccc\n", Encoding.UTF8); } finally { LogManager.Configuration = null; if (File.Exists(tempFile)) File.Delete(tempFile); } }
/// <summary> /// Setup all the logging targets and rules. Call only once, usually at the start of the program. /// </summary> public static void Initialize() { Directory.CreateDirectory(Constants.LogDirectory); LoggingConfiguration loggingConfiguration = new LoggingConfiguration(); // Setup and layout formatting for the console ColoredConsoleTarget consoleTarget = new ColoredConsoleTarget() { Name = Constants.ApplicationNameFormatted, //Layout = "${message}" // Match the console target format with file targets. It looks cluttered on small terminals Layout = "${longdate} [${pad:padCharacter= :padding=5:fixedLength=true:alignmentOnTruncation=Right:${uppercase:${level}}}] [${callsite:includeNamespace=false:cleanNamesOfAnonymousDelegates=true:cleanNamesOfAsyncContinuations=true}] ${message}" }; // Override the trace color ConsoleRowHighlightingRule consoleTarget_RowRules_Trace = new ConsoleRowHighlightingRule() { Condition = ConditionParser.ParseExpression("level == LogLevel.Trace"), ForegroundColor = ConsoleOutputColor.Gray }; consoleTarget.RowHighlightingRules.Add(consoleTarget_RowRules_Trace); // Override the debug color ConsoleRowHighlightingRule consoleTarget_RowRules_Debug = new ConsoleRowHighlightingRule() { Condition = ConditionParser.ParseExpression("level == LogLevel.Debug"), ForegroundColor = ConsoleOutputColor.Gray }; consoleTarget.RowHighlightingRules.Add(consoleTarget_RowRules_Debug); // Override the info color ConsoleRowHighlightingRule consoleTarget_RowRules_Info = new ConsoleRowHighlightingRule() { Condition = ConditionParser.ParseExpression("level == LogLevel.Info"), ForegroundColor = ConsoleOutputColor.White }; consoleTarget.RowHighlightingRules.Add(consoleTarget_RowRules_Info); // Override the warn color ConsoleRowHighlightingRule consoleTarget_RowRules_Warn = new ConsoleRowHighlightingRule() { Condition = ConditionParser.ParseExpression("level == LogLevel.Warn"), ForegroundColor = ConsoleOutputColor.Yellow }; consoleTarget.RowHighlightingRules.Add(consoleTarget_RowRules_Warn); // Override the error color ConsoleRowHighlightingRule consoleTarget_RowRules_Error = new ConsoleRowHighlightingRule() { Condition = ConditionParser.ParseExpression("level == LogLevel.Error"), ForegroundColor = ConsoleOutputColor.Red }; consoleTarget.RowHighlightingRules.Add(consoleTarget_RowRules_Error); // Override the fatal color ConsoleRowHighlightingRule consoleTarget_RowRules_Fatal = new ConsoleRowHighlightingRule() { Condition = ConditionParser.ParseExpression("level == LogLevel.Fatal"), ForegroundColor = ConsoleOutputColor.Red }; consoleTarget.RowHighlightingRules.Add(consoleTarget_RowRules_Fatal); // Add consoleTarget to the overall configuration loggingConfiguration.AddTarget(consoleTarget); loggingConfiguration.AddRule(LogLevel.Trace, LogLevel.Fatal, Constants.ApplicationNameFormatted); // ================================= // All messages from Trace to Warn levels write to the general file FileTarget fileTarget_General = new FileTarget() { Name = Constants.ApplicationNameFormatted, FileName = Path.Combine(Constants.LogDirectory, "General.log"), Layout = "${longdate} [${pad:padCharacter= :padding=5:fixedLength=true:alignmentOnTruncation=Right:${uppercase:${level}}}] [${callsite:includeNamespace=false:cleanNamesOfAnonymousDelegates=true:cleanNamesOfAsyncContinuations=true}] ${message}", ArchiveFileName = Path.Combine(Constants.LogDirectory, "General{#}.Archive.log"), ArchiveEvery = FileArchivePeriod.Day, ArchiveNumbering = ArchiveNumberingMode.Rolling, MaxArchiveFiles = 7, ConcurrentWrites = false }; // Limit how often the file will get written to disk. // Default: BufferSize = 50 (log events), FlushTimeout = 5000 (milliseconds) BufferingTargetWrapper fileAsyncTargetWrapper_General = new BufferingTargetWrapper { Name = Constants.ApplicationNameFormatted, WrappedTarget = fileTarget_General, BufferSize = 50, FlushTimeout = 5000, SlidingTimeout = false }; loggingConfiguration.AddTarget(fileAsyncTargetWrapper_General); loggingConfiguration.AddRule(LogLevel.Trace, LogLevel.Warn, Constants.ApplicationNameFormatted); // All messages from Warn to Fatal levels write to the error file with advanced trace information FileTarget fileTarget_Error = new FileTarget() { Name = Constants.ApplicationNameFormatted, FileName = Path.Combine(Constants.LogDirectory, "Error.log"), Layout = "${longdate} [${pad:padCharacter= :padding=5:fixedLength=true:alignmentOnTruncation=Right:${uppercase:${level}}}] [${callsite:includeSourcePath=true:cleanNamesOfAnonymousDelegates=true:cleanNamesOfAsyncContinuations=true}:${callsite-linenumber}; ${stacktrace}] ${message}${exception:format=ToString,StackTrace}", ArchiveFileName = Path.Combine(Constants.LogDirectory, "Error{#}.Archive.log"), ArchiveEvery = FileArchivePeriod.Day, ArchiveNumbering = ArchiveNumberingMode.Rolling, MaxArchiveFiles = 7, ConcurrentWrites = false }; loggingConfiguration.AddTarget(fileTarget_Error); loggingConfiguration.AddRule(LogLevel.Error, LogLevel.Fatal, Constants.ApplicationNameFormatted); // Apply all the custom configurations to the LogManager LogManager.Configuration = loggingConfiguration; // Setup logger factory InitializeDatabaseFactory(); Log.Info("Logging initialization finished."); }
public Log() { if (log == null) { // Step 1. Create configuration object LoggingConfiguration logConfig = new LoggingConfiguration(); // Step 2. Create targets and add them to the configuration FileTarget fileTarget = new FileTarget(); logConfig.AddTarget("file", fileTarget); // Step 3. Set target properties //fileTarget.FileName = "${basedir}/${date}_log.txt"; fileTarget.Layout = "${longdate} ${uppercase:${level}} ${message}"; fileTarget.Encoding = Encoding.UTF8; fileTarget.FileName = "${basedir}/logs/log.log"; fileTarget.ArchiveFileName = "${basedir}/logs/archives/log.{#}.log"; fileTarget.ArchiveEvery = FileArchivePeriod.Day; fileTarget.ArchiveNumbering = ArchiveNumberingMode.Date; fileTarget.ArchiveDateFormat = "yyyyMMdd"; fileTarget.MaxArchiveFiles = 30; // Step 4. Define rules LoggingRule rule = new LoggingRule("*", LogLevel.Trace, fileTarget); logConfig.LoggingRules.Add(rule); //if (Config.GetIsOpenLogForm()) if (false) { RichTextBoxTarget richTextBoxInfoTarget = new RichTextBoxTarget(); richTextBoxInfoTarget.Name = "info"; richTextBoxInfoTarget.AutoScroll = true; richTextBoxInfoTarget.MaxLines = 10000; richTextBoxInfoTarget.FormName = "LogForm"; richTextBoxInfoTarget.ToolWindow = true; richTextBoxInfoTarget.ControlName = "richTextBoxInfo"; richTextBoxInfoTarget.UseDefaultRowColoringRules = true; richTextBoxInfoTarget.Layout = "${longdate} ${uppercase:${level}} ${message}"; logConfig.AddTarget("richTextBoxInfoTarget", richTextBoxInfoTarget); RichTextBoxTarget richTextBoxTraceTarget = new RichTextBoxTarget(); richTextBoxTraceTarget.Name = "trace"; richTextBoxTraceTarget.AutoScroll = true; richTextBoxTraceTarget.MaxLines = 10000; richTextBoxTraceTarget.FormName = "LogForm"; richTextBoxTraceTarget.ToolWindow = true; richTextBoxTraceTarget.ControlName = "richTextBoxTrace"; richTextBoxTraceTarget.UseDefaultRowColoringRules = true; richTextBoxTraceTarget.Layout = "${longdate} ${uppercase:${level}} ${message}"; logConfig.AddTarget("richTextBoxTraceTarget", richTextBoxTraceTarget); rule = new LoggingRule("*", LogLevel.Debug, richTextBoxInfoTarget); logConfig.LoggingRules.Add(rule); rule = new LoggingRule("*", LogLevel.Trace, LogLevel.Trace, richTextBoxTraceTarget); logConfig.LoggingRules.Add(rule); } // Step 5. Activate the configuration LogManager.Configuration = logConfig; log = LogManager.GetLogger("Example"); //log = NLog.LogManager.GetCurrentClassLogger(); } }
public void InitializeLoggers() { // default log directory. string logFolderBase; // Log directory supplied in Settings.xml. if (!string.IsNullOrEmpty(LogFolderBasePath)) { logFolderBase = LogFolderBasePath; if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { // Add current drive letter if not supplied for Windows path target. if (!LogFolderBasePath.Substring(0, 3).Contains(":\\")) { string windrive = Environment.SystemDirectory.Substring(0, 3); logFolderBase = windrive + LogFolderBasePath; } } else { // Remove supplied drive letter if Linux is the runtime target. if (LogFolderBasePath.Substring(0, 3).Contains(":\\")) { logFolderBase = LogFolderBasePath.Remove(0, 3).Replace("\\", "/"); } } } else { if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { string windrive = Environment.SystemDirectory.Substring(0, 3); logFolderBase = windrive + "observer_logs"; } else { logFolderBase = "/tmp/observer_logs"; } } this.LogFolderBasePath = logFolderBase; string file = Path.Combine(logFolderBase, "fabric_observer.log"); if (!string.IsNullOrEmpty(FolderName) && !string.IsNullOrEmpty(Filename)) { string folderPath = Path.Combine(logFolderBase, FolderName); file = Path.Combine(folderPath, Filename); } FilePath = file; var targetName = this.loggerName + "LogFile"; if (LogManager.Configuration == null) { LogManager.Configuration = new LoggingConfiguration(); } if ((FileTarget)LogManager.Configuration?.FindTargetByName(targetName) == null) { var target = new FileTarget { Name = targetName, OptimizeBufferReuse = true, ConcurrentWrites = true, FileName = file, Layout = "${longdate}--${uppercase:${level}}--${message}", OpenFileCacheTimeout = 5, ArchiveNumbering = ArchiveNumberingMode.DateAndSequence, ArchiveEvery = FileArchivePeriod.Day, AutoFlush = true, }; LogManager.Configuration.AddTarget(this.loggerName + "LogFile", target); var ruleInfo = new LoggingRule(this.loggerName, NLog.LogLevel.Debug, target); LogManager.Configuration.LoggingRules.Add(ruleInfo); LogManager.ReconfigExistingLoggers(); } TimeSource.Current = new AccurateUtcTimeSource(); OLogger = LogManager.GetLogger(this.loggerName); }
public AutomationLogging() { string resultFolder = @"C:/WDTF/TestResult"; string asm = Assembly.GetCallingAssembly().FullName; string logFormat = string.Format("{0:yyMMddhhmmss}", DateTime.Now); newLocationInResultFolder = resultFolder + "/" + currentGuid + "_" + logFormat; DirectoryInfo directoryInfo = new DirectoryInfo(newLocationInResultFolder); if (!directoryInfo.Exists) { System.IO.Directory.CreateDirectory(newLocationInResultFolder); } //FileInfo[] fileInformation = directoryInfo.GetFiles(); //foreach (FileInfo item in fileInformation) //{ // item.Delete(); //} LoggingConfiguration config = new LoggingConfiguration(); //{TestName}_TIME.htm // string logFormat = string.Format("{0:yyMMddhhmmss}", DateTime.Now); //===========================================================================================// ColoredConsoleTarget consoleTarget = new ColoredConsoleTarget(); consoleTarget.Layout = "${time} | ${level} | ${stacktrace::topFrames=2}|${message} "; config.AddTarget("console", consoleTarget); LoggingRule consoleInfo = new LoggingRule("*", LogLevel.Info, consoleTarget); config.LoggingRules.Add(consoleInfo); //===========================================================================================// FileTarget fileTarget = new FileTarget(); fileTarget.Layout = "${time} | ${level} | ${stacktrace:topFrames=2} | ${message} "; fileTarget.FileName = newLocationInResultFolder + "/" + className + "_" + logFormat + ".txt"; config.AddTarget("file", fileTarget); LoggingRule fileInfo = new LoggingRule("*", LogLevel.Info, fileTarget); config.LoggingRules.Add(fileInfo); //===========================================================================================// TraceTarget traceTarget = new TraceTarget(); traceTarget.Layout = "${time} | ${level} | ${stacktrace:topFrames=2} | ${message} "; //===========================================================================================// MailTarget mailTarget = new MailTarget(); mailTarget.Name = "gmail"; mailTarget.SmtpServer = "smtp.gmail.com"; mailTarget.SmtpPort = 465; mailTarget.SmtpAuthentication = SmtpAuthenticationMode.Basic; mailTarget.SmtpUserName = "******"; mailTarget.SmtpPassword = "******"; mailTarget.EnableSsl = true; mailTarget.From = "*****@*****.**"; mailTarget.To = "*****@*****.**"; mailTarget.CC = ""; LoggingRule mailInfo = new LoggingRule("*", LogLevel.Info, mailTarget); config.LoggingRules.Add(mailInfo); //===========================================================================================// DatabaseTarget dbTarget = new DatabaseTarget(); //===========================================================================================// // Step 4. Define rules LogManager.Configuration = config; }
/// <summary> initializes the log system using the logfile argument /// * /// </summary> /// <param name="logFile"> file for log messages /// /// </param> public virtual void init(System.String logFile) { /* * make our FileTarget. Note we are going to keep the * default behavior of not appending... */ FileTarget target = new FileTarget(new System.IO.FileInfo(logFile), false, new VelocityFormatter("%{time} %{message}\\n%{throwable}")); /* * use the toString() of RuntimeServices to make a unique logger */ //UPGRADE_TODO: The equivalent in .NET for method 'java.Object.toString' may return a different value. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1043"' logger = Hierarchy.DefaultHierarchy.getLoggerFor(rsvc.ToString()); logger.Priority = Priority.DEBUG; logger.LogTargets = new LogTarget[]{target}; }
/// <summary> /// Default initialization for on-premise paths /// </summary> private void InitializeForPremise() { // Replace log file and role name settings in the configuration var currentCfg = LogManager.Configuration; if (currentCfg == null) { Trace.WriteLine("No on-premise NLog configuration available - creating default config"); var level = global::NLog.LogLevel.Debug; var config = new LoggingConfiguration(); var console = new ColoredConsoleTarget() { UseDefaultRowHighlightingRules = true, Layout = "${date:format=HH\\:MM\\:ss} ${logger} ${message}" }; var file = new FileTarget() { FileName = "${basedir}/application.log", Layout = "${date:format=HH\\:MM\\:ss} ${logger} ${message}" }; var debug = new DebuggerTarget() { Layout = "${date:format=HH\\:MM\\:ss} ${logger} ${message}" }; config.AddTarget("debug", debug); config.AddTarget("console", console); config.AddTarget("file", file); config.LoggingRules.Add(new LoggingRule("*", level, console)); config.LoggingRules.Add(new LoggingRule("*", level, file)); config.LoggingRules.Add(new LoggingRule("*", level, debug)); LogManager.Configuration = config; } else { Trace.WriteLine("Using NLog.config for non-Azure deployment"); } }
/// <summary>Basic constructor.</summary> public MicroserviceBase() { // Listen the ProcessExit event to control service stop. AppDomain.CurrentDomain.ProcessExit += (s, e) => StopEvent(s, e); // Log configuration. var loggerFactory = new LoggerFactory(); loggerFactory.AddNLog(); LoggingConfiguration logConfig = new LoggingConfiguration(); string instanceId = System.Environment.MachineName; if (instanceId.Length > 12) { instanceId = instanceId.Substring(0, 12); } // Read appsettings.json configuration file. string configPath = "appsettings.json"; var file = new FileInfo(configPath); string env = GetEnvironmentConfigFileSuffix(); string fileName = file.Name.Substring(0, file.Name.Length - file.Extension.Length); string envConfigPath = fileName + "." + env + file.Extension; var builder = new ConfigurationBuilder() .SetBasePath(System.Environment.CurrentDirectory) .AddJsonFile(configPath, true) .AddJsonFile(envConfigPath, true); var config = builder.Build(); var section = config.GetSection("Relier.Microservice"); if (section.Exists()) { // Verify if have to log Debug. if (section.GetValue <bool>("Debug")) { FileTarget debugFileTarget = new FileTarget(); debugFileTarget.FileName = "${basedir}/logs/log-" + instanceId + "-debug.log"; debugFileTarget.Layout = "${date} ${level:uppercase=true} ${message} ${exception}"; logConfig.AddTarget("debugFileLog", debugFileTarget); logConfig.AddRule(NLog.LogLevel.Debug, NLog.LogLevel.Fatal, "debugFileLog"); } } FileTarget generalFileLog = new FileTarget(); generalFileLog.FileName = "${basedir}/logs/log-" + instanceId + ".log"; generalFileLog.Layout = "${date} ${level:uppercase=true} ${message} ${exception}"; logConfig.AddTarget("generalFileLog", generalFileLog); logConfig.AddRule(NLog.LogLevel.Info, NLog.LogLevel.Fatal, "generalFileLog"); NLog.LogManager.Configuration = logConfig; this.Logger = loggerFactory.CreateLogger <MicroserviceBase>(); if (section.Exists()) { // Verify if this service have any specific execution period. // Example: 00:00-06:00. string executionPeriod = section.GetValue <string>("ExecutionPeriod"); if (!string.IsNullOrEmpty(executionPeriod)) { var regEx = new Regex("^(?:0?[0-9]|1[0-9]|2[0-3]):[0-5][0-9]-(?:0?[0-9]|1[0-9]|2[0-3]):[0-5][0-9]$"); if (!regEx.IsMatch(executionPeriod)) { string errorMessage = "Invalid time format for ExecutionPeriod parameter. The value " + executionPeriod + " is invalid. The correct pattern is HH:MM-HH:MM."; this.Logger.LogError(errorMessage); System.Environment.FailFast(errorMessage); } _executionPeriodStart = executionPeriod.Split('-')[0]; _executionPeriodEnd = executionPeriod.Split('-')[1]; } } }
public void CallsUpdateFileOnRepo() { this._mockRepo .Setup(m => m.UpdateFile( this._authToken, It.IsAny<File>(), It.IsAny<FileTarget>(), It.IsAny<string>() )) .Verifiable(); var file = new DiskFile("Resources/content_file.gif"); var target = new FileTarget("pseudomuto", "reponame", "content_file.gif"); this._subject.PushFile(file, target, "updating file"); this._mockRepo.Verify(); }
static void Main() { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); SetupConfig(); if (AppConfig.NeedsConfigSetup) { int i = 1; } #region Setup Logger // Step 1. Create configuration object var config = new LoggingConfiguration(); // Step 2. Create targets and add them to the configuration #region File Log FileTarget fileTarget; if (!string.IsNullOrEmpty(AppConfig.LogFileLocation)) { fileTarget = new FileTarget { ArchiveAboveSize = 1048576, AutoFlush = true, MaxArchiveFiles = 10, CreateDirs = true, EnableFileDelete = true, Header = "\n${date:format=HH\\:mm\\:ss}\nLog file for IMR Crawler Application\n===============================\n", Footer = "===============================\nEnd Log - ${date:format=HH\\:mm\\:ss}", FileName = AppConfig.LogFileLocation + "\\${shortdate}.log", Layout = "${date:format=HH\\:mm\\:ss} ${logger} : ${level:uppercase=true} : ${message} ${exception:format=message}" }; } else { if (!Directory.Exists("C:\\Logs")) { Directory.CreateDirectory("C:\\Logs"); } fileTarget = new FileTarget { ArchiveAboveSize = 1048576, AutoFlush = true, MaxArchiveFiles = 10, CreateDirs = true, EnableFileDelete = true, Header = "\n${date:format=HH\\:mm\\:ss}\nLog file for IMR Crawler Application\n===============================\n", Footer = "===============================\nEnd Log - ${date:format=HH\\:mm\\:ss}", FileName = "C:\\Logs\\${shortdate}.log", Layout = "${date:format=HH\\:mm\\:ss} ${logger} : ${level:uppercase=true} : ${message} ${exception:format=message}" }; } config.AddTarget("file", fileTarget); #endregion var rule2 = new LoggingRule("*", LogLevel.Debug, fileTarget); config.LoggingRules.Add(rule2); // Step 5. Activate the configuration LogManager.Configuration = config; #endregion if (Environment.OSVersion.Version.Major >= 6) { if (!IsRunAsAdmin()) { ProcessStartInfo proc = new ProcessStartInfo(); proc.UseShellExecute = true; proc.WorkingDirectory = Environment.CurrentDirectory; proc.FileName = Application.ExecutablePath; proc.Verb = "runas"; try { Process.Start(proc); } catch { // The user refused the elevation. // Do nothing and return directly ... return; } Application.Exit(); // Quit itself } else { Application.Run(new frmMain()); } } else { Application.Run(new frmMain()); } }
public static void Main(string[] args) { string filename = ""; string logs = ""; try { LOG.Trace($"Args: {string.Join(", ", args)}"); if (args[0] == "-c") { filename = args[1]; } if (args[2] == "-l") { logs = args[3]; } else { LOG.Warn("Use '-c <filename> -l <log_filename>' to pass a config file to program and set where logs should be"); } } catch (IndexOutOfRangeException) { LOG.Warn("Use '-c <filename> -l <log_filename>' to pass a config file to program and set where logs should be"); LOG.Warn("Using MockConfigurationParser instead"); } IConfigurationParser configurationParser; if (string.IsNullOrWhiteSpace(filename)) { configurationParser = new MockConfigurationParser(); } else { configurationParser = new XmlConfigurationParser(filename); } Configuration configuration = configurationParser.ParseConfiguration(); LoggingConfiguration config = new LoggingConfiguration(); ColoredConsoleTarget consoleTarget = new ColoredConsoleTarget { Name = "console", Layout = "[${time} | ${level:format=FirstCharacter} | ${logger}] ${message}" }; FileTarget fileTarget = new FileTarget { FileName = logs + "/CableCloud.log", DeleteOldFileOnStartup = true, Layout = "[${time} | ${level:format=FirstCharacter} | ${logger}] ${message}" }; config.AddRule(LogLevel.Trace, LogLevel.Fatal, consoleTarget); config.AddRule(LogLevel.Debug, LogLevel.Fatal, fileTarget); LogManager.Configuration = config; IClientWorkerFactory clientWorkerFactory = new ClientWorkerFactory(); IListener listener = new Listener(configuration, clientWorkerFactory); IPacketForwarder packetForwarder = new PacketForwarder(configuration); ICableCloudManager cableCloudManager = new CableCloudManager(configuration, listener, packetForwarder); ICommandParser commandParser = new CommandParser(configuration); IUserInterface userInterface = new UserInterface(commandParser, cableCloudManager); try { Console.Title = "CC"; } catch (Exception) { LOG.Trace("Could not set the title"); } userInterface.Start(); }
/// <summary> /// Configures the n log. /// </summary> /// <param name="logToFile">if set to <c>true</c> [log to file].</param> /// <param name="ruleNameAndFileSet">The rule name and < file name, Logging Level >. Key is rule name; value is file name (not full path).</param> public static void ConfigureNLog(bool logToFile, Dictionary <string, Tuple <string, LoggingLevel> > ruleNameAndFileSet) { // Step 1. Create configuration object var config = new LoggingConfiguration(); // Step 2. Create targets and add them to the configuration string format = @"${time}|${pad:padding=5:inner=${level:uppercase=true}}| ${message}"; // Step 3. Set target properties if (logToFile) { string format2 = @"${time}|${pad:padding=5:inner=${level:uppercase=true}}|${logger}| ${message}"; string fileName = "${shortdate}.log", logDir = LogDirectory; if (ruleNameAndFileSet != null && ruleNameAndFileSet.Count > 0) { var nullTarget = new NullTarget("BlackHole"); config.AddTarget("BlackHole", nullTarget); int i = 0; foreach (var item in ruleNameAndFileSet) { if (string.IsNullOrWhiteSpace(item.Key) || item.Key == "*") { continue; } if (!string.IsNullOrWhiteSpace(item.Value.Item1) && item.Value.Item1 != fileName) { var name = "file_" + (++i); var target = new FileTarget { EnableFileDelete = true, CreateDirs = true, Layout = format2, FileName = Path.Combine(logDir, item.Value.Item1), Name = name, }; config.AddTarget(name, target); var level = item.Value.Item2; config.LoggingRules.Add(new LoggingRule(item.Key, LogLevel.FromString(level.ToString()), target) { Final = true }); if (level != LoggingLevel.Trace) { config.LoggingRules.Add(new LoggingRule(item.Key, LogLevel.Trace, nullTarget) { Final = true }); } } } } var fileTarget = new FileTarget { EnableFileDelete = true, CreateDirs = true, Layout = format, FileName = Path.Combine(logDir, fileName), Name = "file", }; config.AddTarget("file", fileTarget); config.LoggingRules.Add(new LoggingRule("*", LogLevel.Trace, fileTarget)); } #if DEBUG var consoleTarget = new ColoredConsoleTarget { Name = "console", Layout = format, }; config.AddTarget("console", consoleTarget); config.LoggingRules.Add(new LoggingRule("*", LogLevel.Trace, consoleTarget)); var debugTarget = new DebuggerTarget { Name = "debug", Layout = format, }; config.AddTarget("debug", debugTarget); config.LoggingRules.Add(new LoggingRule("*", LogLevel.Trace, debugTarget)); #endif // Step 5. Activate the configuration LogManager.Configuration = config; }
internal void InitializeLoggers() { // default log directory. string logFolderBase; if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { string windrive = Environment.SystemDirectory.Substring(0, 2); logFolderBase = windrive + "\\clusterobserver_logs"; } else { // Linux logFolderBase = "clusterobserver_logs"; } // log directory supplied in config. Set in ObserverManager. if (!string.IsNullOrEmpty(this.LogFolderBasePath)) { logFolderBase = this.LogFolderBasePath; } string file = Path.Combine(logFolderBase, "cluster_observer.log"); if (!string.IsNullOrEmpty(this.FolderName) && !string.IsNullOrEmpty(this.Filename)) { string folderPath = Path.Combine(logFolderBase, this.FolderName); file = Path.Combine(folderPath, this.Filename); } this.FilePath = file; var targetName = this.loggerName + "LogFile"; if (LogManager.Configuration == null) { LogManager.Configuration = new LoggingConfiguration(); } if ((FileTarget)LogManager.Configuration?.FindTargetByName(targetName) == null) { var target = new FileTarget { Name = targetName, FileName = file, Layout = "${longdate}--${uppercase:${level}}--${message}", OpenFileCacheTimeout = 5, ArchiveNumbering = ArchiveNumberingMode.DateAndSequence, ArchiveEvery = FileArchivePeriod.Day, AutoFlush = true, }; LogManager.Configuration.AddTarget(this.loggerName + "LogFile", target); var ruleInfo = new LoggingRule(this.loggerName, NLog.LogLevel.Debug, target); LogManager.Configuration.LoggingRules.Add(ruleInfo); LogManager.ReconfigExistingLoggers(); } TimeSource.Current = new AccurateUtcTimeSource(); this.OLogger = LogManager.GetLogger(this.loggerName); }
private static void Start(string[] args) { // SE_VERSION is a private constant. Need to use reflection to get it. FieldInfo field = typeof(SpaceEngineersGame).GetField("SE_VERSION", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static); SeVersion = new Version(new MyVersion((int)field.GetValue(null)).FormattedText.ToString().Replace("_", ".")); //bool stableBuild = (bool)typeof(MyFinalBuildConstants).GetField("IS_STABLE").GetValue(null); ApplicationLog.BaseLog.Info($"SE version: {SeVersion}"); string versionMessage = $"Extender version: {Assembly.GetExecutingAssembly().GetName().Version}"; #if DEBUG //mark debug builds as such versionMessage += " DEBUG"; #endif ApplicationLog.BaseLog.Info(versionMessage); //warn users about SESE EOL and Torch migration if (SystemInformation.UserInteractive) { Task.Run(() => { AutoClosingMessageBox.Show("Support for SESE is ENDING. Ongoing compatability is not guaranteed. All servers should migrate to" + "Torch (SESE2) when it becomes available. Join our discord server to stay updated on Torch's status: " + "https://discord.gg/JPrcsWt or check regularly at https://github.com/TorchAPI/Torch", "SESE EOL", 20000); }); } BaseLog.Warn("Support for SESE is ENDING. Ongoing compatability is not guaranteed. All servers should migrate to" + "Torch (SESE2) when it becomes available. Join our discord server to stay updated on Torch's status: " + "https://discord.gg/JPrcsWt or check regularly at https://github.com/TorchAPI/Torch"); /* * if (stableBuild) * { * BaseLog.Info("Detected \"Stable\" branch!"); * //BaseLog.Error("WARNING: THIS BUILD OF SESE IS NOT COMPATIBLE WITH STABLE BRANCH"); * //if (SystemInformation.UserInteractive) * //{ * // var result = MessageBox.Show("This build of SESE is not compatible with stable branch!", * // "Fatal Error", * // MessageBoxButtons.OK, * // MessageBoxIcon.Error); * // if (result == DialogResult.OK) * // { * // Stop(); * // return; * // } * //} * //else * //{ * // Stop(); * // return; * //} * IsStable = true; * PluginManager.IsStable = true; * Server.IsStable = true; * } * else * BaseLog.Info("Detected \"Development\" branch!"); */ InitSandbox(); //Setup error handling for unmanaged exceptions AppDomain.CurrentDomain.UnhandledException += AppDomain_UnhandledException; Application.ThreadException += Application_ThreadException; Application.SetUnhandledExceptionMode(UnhandledExceptionMode.CatchException); //AppDomain.CurrentDomain.ClearEventInvocations("_unhandledException"); BaseLog.Info("Starting SEServerExtender with {0} arguments: {1}", args.Length, string.Join("\r\n\t", args)); CommandLineArgs extenderArgs = CommandLineArgs = new CommandLineArgs { ConsoleTitle = string.Empty, AutoStart = false, WorldName = string.Empty, InstanceName = string.Empty, NoGui = false, NoConsole = false, Debug = false, GamePath = new DirectoryInfo(PathManager.BasePath).Parent.FullName, //TODO: turn noWFC back to off by default whenever WCF gets fixed NoWcf = true, Autosave = 0, InstancePath = string.Empty, CloseOnCrash = false, RestartOnCrash = false, NoProfiler = false, Args = string.Join(" ", args.Select(x => string.Format("\"{0}\"", x))) }; if (ConfigurationManager.AppSettings["WCFChatMaxMessageHistoryAge"] != null) { if (!int.TryParse(ConfigurationManager.AppSettings["WCFChatMaxMessageHistoryAge"], out _maxChatHistoryMessageAge)) { ConfigurationManager.AppSettings.Add("WCFChatMaxMessageHistoryAge", "3600"); } } if (ConfigurationManager.AppSettings["WCFChatMaxMessageHistoryCount"] != null) { if (!int.TryParse(ConfigurationManager.AppSettings["WCFChatMaxMessageHistoryCount"], out _maxChatHistoryMessageCount)) { ConfigurationManager.AppSettings.Add("WCFChatMaxMessageHistoryCount", "100"); } } bool logPathSet = false; //Process the args foreach (string arg in args) { string[] splitAtEquals = arg.Split('='); if (splitAtEquals.Length > 1) { string argName = splitAtEquals[0]; string argValue = splitAtEquals[1]; string lowerCaseArgument = argName.ToLower( ); if (lowerCaseArgument.Equals("instance")) { if (argValue[argValue.Length - 1] == '"') { argValue = argValue.Substring(1, argValue.Length - 2); } //sanitize input because stupid people put full paths for this argument extenderArgs.InstanceName = argValue.Replace(@"\", "-").Replace(@":", "-"); //Only let this override log path if the log path wasn't already explicitly set if (!logPathSet) { FileTarget baseLogTarget = LogManager.Configuration.FindTargetByName("BaseLog") as FileTarget; if (baseLogTarget != null) { baseLogTarget.FileName = baseLogTarget.FileName.Render(new LogEventInfo { TimeStamp = DateTime.Now }).Replace("NoInstance", argValue.Replace(@"\", "-").Replace(@":", "-")); } FileTarget chatLogTarget = LogManager.Configuration.FindTargetByName("ChatLog") as FileTarget; if (chatLogTarget != null) { chatLogTarget.FileName = chatLogTarget.FileName.Render(new LogEventInfo { TimeStamp = DateTime.Now }).Replace("NoInstance", argValue.Replace(@"\", "-").Replace(@":", "-")); } FileTarget pluginLogTarget = LogManager.Configuration.FindTargetByName("PluginLog") as FileTarget; if (pluginLogTarget != null) { pluginLogTarget.FileName = pluginLogTarget.FileName.Render(new LogEventInfo { TimeStamp = DateTime.Now }).Replace("NoInstance", argValue.Replace(@"\", "-").Replace(@":", "-")); } } } else if (lowerCaseArgument.Equals("gamepath")) { if (argValue[argValue.Length - 1] == '"') { argValue = argValue.Substring(1, argValue.Length - 2); } extenderArgs.GamePath = argValue; } else if (lowerCaseArgument.Equals("autosave")) { if (!int.TryParse(argValue, out extenderArgs.Autosave)) { BaseLog.Warn("Autosave parameter was not a valid integer."); } } else if (lowerCaseArgument.Equals("path")) { if (argValue[argValue.Length - 1] == '"') { argValue = argValue.Substring(1, argValue.Length - 2); } extenderArgs.InstancePath = argValue; } else if (lowerCaseArgument.Equals("instancepath")) { if (argValue[argValue.Length - 1] == '"') { argValue = argValue.Substring(1, argValue.Length - 2); } extenderArgs.InstancePath = argValue; } else if (lowerCaseArgument.Equals("title")) { if (argValue[argValue.Length - 1] == '"') { argValue = argValue.Substring(1, argValue.Length - 2); } extenderArgs.ConsoleTitle = argValue; } else if (lowerCaseArgument == "logpath") { if (argValue[argValue.Length - 1] == '"') { argValue = argValue.Substring(1, argValue.Length - 2); } //This argument always prevails. FileTarget baseLogTarget = LogManager.Configuration.FindTargetByName("BaseLog") as FileTarget; if (baseLogTarget != null) { Layout l = new SimpleLayout(Path.Combine(argValue, "SEServerExtenderLog-${shortdate}.log")); baseLogTarget.FileName = l.Render(new LogEventInfo { TimeStamp = DateTime.Now }); ApplicationLog.BaseLog = BaseLog; } FileTarget chatLogTarget = LogManager.Configuration.FindTargetByName("ChatLog") as FileTarget; if (chatLogTarget != null) { Layout l = new SimpleLayout(Path.Combine(argValue, "ChatLog-${shortdate}.log")); chatLogTarget.FileName = l.Render(new LogEventInfo { TimeStamp = DateTime.Now }); ApplicationLog.ChatLog = ChatLog; } FileTarget pluginLogTarget = LogManager.Configuration.FindTargetByName("PluginLog") as FileTarget; if (pluginLogTarget != null) { Layout l = new SimpleLayout(Path.Combine(argValue, "PluginLog-${shortdate}.log")); pluginLogTarget.FileName = l.Render(new LogEventInfo { TimeStamp = DateTime.Now }); logPathSet = true; ApplicationLog.PluginLog = PluginLog; } } } else { string lowerCaseArgument = arg.ToLower( ); if (lowerCaseArgument.Equals("autostart")) { extenderArgs.AutoStart = true; } else if (lowerCaseArgument.Equals("nogui")) { extenderArgs.NoGui = true; //Implies autostart //extenderArgs.AutoStart = true; } else if (lowerCaseArgument.Equals("noconsole")) { extenderArgs.NoConsole = true; //Implies nogui and autostart extenderArgs.NoGui = true; extenderArgs.AutoStart = true; } else if (lowerCaseArgument.Equals("debug")) { extenderArgs.Debug = true; } else if (lowerCaseArgument.Equals("nowcf")) { extenderArgs.NoWcf = true; } else if (lowerCaseArgument.Equals("wcfon")) { extenderArgs.NoWcf = false; } else if (lowerCaseArgument.Equals("closeoncrash")) { extenderArgs.CloseOnCrash = true; } else if (lowerCaseArgument.Equals("autosaveasync")) { extenderArgs.AutoSaveSync = false; } else if (lowerCaseArgument.Equals("autosavesync")) { extenderArgs.AutoSaveSync = true; } else if (lowerCaseArgument.Equals("restartoncrash")) { extenderArgs.RestartOnCrash = true; } else if (lowerCaseArgument.Equals("noprofiler") && !IsStable) { extenderArgs.NoProfiler = true; Server.DisableProfiler = true; } //these things are legacy and don't work anyway /* * else if ( lowerCaseArgument.Equals( "wrr" ) ) * { * extenderArgs.WorldRequestReplace = true; * } * else if ( lowerCaseArgument.Equals( "wrm" ) ) * { * extenderArgs.WorldDataModify = true; * } * else if (lowerCaseArgument.Equals("wvm")) * { * extenderArgs.WorldVoxelModify = true; * } */ } } if (!Environment.UserInteractive) { extenderArgs.NoConsole = true; extenderArgs.NoGui = true; extenderArgs.AutoStart = true; } if (extenderArgs.Debug) { ExtenderOptions.IsDebugging = true; } try { bool unitTestResult = BasicUnitTestManager.Instance.Run( ); if (!unitTestResult) { ExtenderOptions.IsInSafeMode = true; } Server = Server.Instance; Server.CommandLineArgs = extenderArgs; Server.IsWCFEnabled = !extenderArgs.NoWcf; Server.Init( ); //if(!DedicatedServerAssemblyWrapper.IsStable) // InitSandbox(Path.Combine( GameInstallationInfo.GamePath, @"..\Content"), Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "SpaceEngineers")); ChatManager.ChatCommand guiCommand = new ChatManager.ChatCommand("gui", ChatCommand_GUI, false); ChatManager.Instance.RegisterChatCommand(guiCommand); if (!CommandLineArgs.NoConsole) { if (string.IsNullOrEmpty(extenderArgs.ConsoleTitle) || string.IsNullOrWhiteSpace(extenderArgs.ConsoleTitle)) { Console.Title = "SESE"; } else { Console.Title = extenderArgs.ConsoleTitle; } } if (extenderArgs.AutoStart) { Server.StartServer( ); } if (!extenderArgs.NoWcf) { string uriString = string.Format("{0}{1}", ConfigurationManager.AppSettings["WCFServerServiceBaseAddress"], CommandLineArgs.InstanceName); BaseLog.Info("Opening up WCF service listener at {0}", uriString); ServerServiceHost = new ServiceHost(typeof(ServerService.ServerService), new Uri(uriString, UriKind.Absolute)); ServerServiceHost.Open( ); ChatManager.Instance.ChatMessage += ChatManager_ChatMessage; } if (!extenderArgs.NoGui) { Thread uiThread = new Thread(StartGui); uiThread.SetApartmentState(ApartmentState.STA); uiThread.Start( ); } else if (Environment.UserInteractive) { Console.ReadLine( ); } } catch (AutoException eEx) { if (!extenderArgs.NoConsole) { BaseLog.Info("AutoException - {0}\n\r{1}", eEx.AdditionnalInfo, eEx.GetDebugString( )); } if (!extenderArgs.NoGui) { MessageBox.Show(string.Format("{0}\n\r{1}", eEx.AdditionnalInfo, eEx.GetDebugString( )), @"SEServerExtender", MessageBoxButtons.OK, MessageBoxIcon.Error); } if (extenderArgs.NoConsole && extenderArgs.NoGui) { throw eEx.GetBaseException( ); } } catch (TargetInvocationException ex) { if (!extenderArgs.NoConsole) { BaseLog.Info("TargetInvocationException - {0}\n\r{1}", ex, ex.InnerException); } if (!extenderArgs.NoGui) { MessageBox.Show(string.Format("{0}\n\r{1}", ex, ex.InnerException), @"SEServerExtender", MessageBoxButtons.OK, MessageBoxIcon.Error); } if (extenderArgs.NoConsole && extenderArgs.NoGui) { throw; } } catch (Exception ex) { if (!extenderArgs.NoConsole) { BaseLog.Info(ex, "Exception - {0}", ex); } if (!extenderArgs.NoGui) { MessageBox.Show(ex.ToString( ), @"SEServerExtender", MessageBoxButtons.OK, MessageBoxIcon.Error); } if (extenderArgs.NoConsole && extenderArgs.NoGui) { throw; } } }
protected override bool ResolveParameter(string param) { int equalPos = param.IndexOf('='); if (IsParam(param, "method", "m")) { if (equalPos == -1) throw new ArgumentException("--method must be specified with an Erasure " + "method GUID."); List<KeyValuePair<string, string> > subParams = GetSubParameters(param.Substring(equalPos + 1)); ErasureMethod = new Guid(subParams[0].Key); } else if (IsParam(param, "schedule", "s")) { if (equalPos == -1) throw new ArgumentException("--schedule must be specified with a Schedule " + "type."); List<KeyValuePair<string, string> > subParams = GetSubParameters(param.Substring(equalPos + 1)); switch (subParams[0].Key) { case "now": Schedule = Schedule.RunNow; break; case "manually": Schedule = Schedule.RunManually; break; case "restart": Schedule = Schedule.RunOnRestart; break; default: throw new ArgumentException("Unknown schedule type: " + subParams[0].Key); } } else if (IsParam(param, "recycled", "r")) { Targets.Add(new RecycleBinTarget()); } else if (IsParam(param, "unused", "u")) { if (equalPos == -1) throw new ArgumentException("--unused must be specified with the Volume " + "to erase."); UnusedSpaceTarget target = new UnusedSpaceTarget(); target.EraseClusterTips = false; List<KeyValuePair<string, string> > subParams = GetSubParameters(param.Substring(equalPos + 1)); foreach (KeyValuePair<string, string> kvp in subParams) if (kvp.Value == null && target.Drive == null) target.Drive = Path.GetFullPath(kvp.Key); else if (kvp.Key == "clusterTips") target.EraseClusterTips = true; else throw new ArgumentException("Unknown subparameter: " + kvp.Key); Targets.Add(target); } else if (IsParam(param, "dir", "d") || IsParam(param, "directory", null)) { if (equalPos == -1) throw new ArgumentException("--directory must be specified with the " + "directory to erase."); FolderTarget target = new FolderTarget(); List<KeyValuePair<string, string> > subParams = GetSubParameters(param.Substring(equalPos + 1)); foreach (KeyValuePair<string, string> kvp in subParams) if (kvp.Value == null && target.Path == null) target.Path = Path.GetFullPath(kvp.Key); else if (kvp.Key == "excludeMask") { if (kvp.Value == null) throw new ArgumentException("The exclude mask must be specified " + "if the excludeMask subparameter is specified"); target.ExcludeMask = kvp.Value; } else if (kvp.Key == "includeMask") { if (kvp.Value == null) throw new ArgumentException("The include mask must be specified " + "if the includeMask subparameter is specified"); target.IncludeMask = kvp.Value; } else if (kvp.Key == "delete") target.DeleteIfEmpty = true; else throw new ArgumentException("Unknown subparameter: " + kvp.Key); Targets.Add(target); } else if (IsParam(param, "file", "f")) { if (equalPos == -1) throw new ArgumentException("--file must be specified with the " + "file to erase."); FileTarget target = new FileTarget(); List<KeyValuePair<string, string> > subParams = GetSubParameters(param.Substring(equalPos + 1)); foreach (KeyValuePair<string, string> kvp in subParams) if (kvp.Value == null && target.Path == null) target.Path = Path.GetFullPath(kvp.Key); else throw new ArgumentException("Unknown subparameter: " + kvp.Key); Targets.Add(target); } else return false; return true; }
private static void SetupLogFatal(NLogConfig config, FileTarget tbTarget, LogLevel logLevel) { config.LoggingRules.Add(new LoggingRule("Breeze.*", logLevel, tbTarget)); }