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