public static int Main(string[] args)
{
// The following code ensures that only one Tailviewer window is shown to the user.
// The code tries to find out if an already running process can still be used
// (after all the user might have started tailviewer again because it froze or because
// its window is not showing, but the process still running.
//
// Once a decision has been made, either all other application instances are forcefully closed
// or this process terminates peacefully.
SingleApplicationHelper.IMutex mutex = null;
try
{
mutex = SingleApplicationHelper.AcquireMutex();
if (mutex == null)
{
Console.WriteLine("WARN: Unable to acquire mutex, another Tailviewer is already running!");
var processes = SingleApplicationHelper.FindOtherTailviewers();
Process primaryProcess;
if (SingleApplicationHelper.ShouldTakeOver(processes, out primaryProcess))
{
Console.WriteLine(
"INFO: Tailviewer with pid {0} has been determined to not be usable anymore",
primaryProcess?.Id);
SingleApplicationHelper.KillAllOtherInstances(processes);
Console.WriteLine("INFO: Trying to take over mutex...");
mutex = SingleApplicationHelper.AcquireMutex();
}
else
{
Console.WriteLine("INFO: Tailviewer with pid {0} has been determined to still be usable",
primaryProcess?.Id);
// I guess the already running process
// is good enough for the user: We should
// kill ourselves so we don't interfere with
// it.
//
// But before we do that, we have to send the files
// we were supposed to open to the other process.
SingleApplicationHelper.OpenFile(args);
SingleApplicationHelper.BringToFront();
Console.WriteLine("INFO: Signing off...");
return(0);
}
}
SetupLoggers();
return(App.Start(mutex, args));
}
finally
{
mutex?.Dispose();
}
}
public static int Start(SingleApplicationHelper.IMutex mutex, string[] args, Stopwatch stopwatch)
{
try
{
return(StartInternal(mutex, args, stopwatch));
}
catch (Exception e)
{
Log.ErrorFormat("Caught unexpected exception: {0}", e);
return(-1);
}
}
private static int StartInternal(SingleApplicationHelper.IMutex mutex, string[] args, Stopwatch stopwatch)
{
InstallExceptionHandlers();
Log.InfoFormat("Starting {0}...", Constants.ApplicationTitle);
Log.InfoFormat("Commandline arguments: {0}", string.Join(" ", args));
LogEnvironment();
var arguments = ArgumentParser.TryParse(args);
switch (arguments.Mode)
{
case ArgumentParser.Modes.TestLoadPlugin:
return(TestLoadPlugin(arguments.FileToOpen, arguments.PluginInterface));
default:
return(StartApplication(mutex, arguments.FileToOpen, stopwatch));
}
}
private static int StartApplication(SingleApplicationHelper.IMutex mutex, string fileToOpen, Stopwatch stopwatch)
{
ApplicationSettings settings = ApplicationSettings.Create();
settings.Restore(out var neededPatching);
settings.AllowSave = false; //< We will allow saving once the app is fully booted
if (neededPatching)
{
// TODO: Save settings right again to complete the upgrade
// (maybe we should preserve an old version)
}
var bookmarks = Bookmarks.Create();
bookmarks.Restore();
var services = new ServiceContainer();
services.RegisterInstance <ILogFileSettings>(settings.LogFile);
var actionCenter = new ActionCenter();
using (var taskScheduler = new DefaultTaskScheduler())
using (var serialTaskScheduler = new SerialTaskScheduler())
{
services.RegisterInstance <ITaskScheduler>(taskScheduler);
services.RegisterInstance <ISerialTaskScheduler>(serialTaskScheduler);
var navigationService = new NavigationService();
services.RegisterInstance <INavigationService>(navigationService);
var filesystem = new Filesystem(taskScheduler);
services.RegisterInstance <IFilesystem>(filesystem);
using (var pluginArchiveLoader = new PluginArchiveLoader(filesystem, Constants.PluginPath, Constants.DownloadedPluginsPath))
{
var pluginUpdater = new PluginUpdater(pluginArchiveLoader);
services.RegisterInstance <IPluginUpdater>(pluginUpdater);
var pluginSystem = CreatePluginSystem(pluginArchiveLoader);
services.RegisterInstance <IPluginLoader>(pluginSystem);
var logFileFormatRegistry = new LogFileFormatRegistry(pluginSystem, settings.CustomFormats);
services.RegisterInstance <ILogFileFormatRepository>(logFileFormatRegistry);
services.RegisterInstance <ILogFileFormatRegistry>(logFileFormatRegistry);
var logFileFormatMatcher = new LogFileFormatMatcher(services);
services.RegisterInstance <ILogFileFormatMatcher>(logFileFormatMatcher);
var textLogFileParserPlugin = new LogEntryParserFactory(services);
services.RegisterInstance <ILogEntryParserPlugin>(textLogFileParserPlugin);
var propertyPresenter = new PropertyPresenterRegistry(pluginSystem);
services.RegisterInstance <IPropertyPresenterPlugin>(propertyPresenter);
var fileLogSourceFactory = new StreamingTextLogSourceFactory(filesystem, taskScheduler);
services.RegisterInstance <IRawFileLogSourceFactory>(fileLogSourceFactory);
var parsingLogSourceFactory = new ParsingLogSourceFactory(services);
services.RegisterInstance <ILogSourceParserPlugin>(parsingLogSourceFactory);
var customDataSourcePlugins = pluginSystem.LoadAllOfTypeWithDescription <ICustomDataSourcePlugin>();
var logFileFactory = new PluginLogSourceFactory(services, customDataSourcePlugins);
using (var dataSources = new DataSources(logFileFactory, taskScheduler, filesystem, settings.DataSources, bookmarks))
using (var updater = new AutoUpdater(actionCenter, settings.AutoUpdate))
{
if (fileToOpen != null)
{
if (File.Exists(fileToOpen))
{
// Not only do we want to add this file to the list of data sources,
// but we also want to select it so the user can view it immediately, regardless
// of what was selected previously.
var dataSource = dataSources.AddFile(fileToOpen);
settings.DataSources.SelectedItem = dataSource.Id;
}
else
{
Log.ErrorFormat("File '{0}' does not exist, won't open it!", fileToOpen);
}
}
if (settings.AutoUpdate.CheckForUpdates)
{
// Our initial check for updates is not due to a user action
// and therefore we don't need to show a notification when the
// application is up-to-date.
updater.CheckForUpdates(addNotificationWhenUpToDate: false);
}
var quickFilters = new QuickFilters(settings.QuickFilters);
var highlighters = new HighlighterCollection();
services.RegisterInstance <IHighlighters>(highlighters);
actionCenter.Add(Build.Current);
actionCenter.Add(Change.Merge(Changelog.MostRecentPatches));
var application = new App();
var dispatcher = Dispatcher.CurrentDispatcher;
var uiDispatcher = new UiDispatcher(dispatcher);
services.RegisterInstance <IDispatcher>(uiDispatcher);
dispatcher.UnhandledException += actionCenter.ReportUnhandledException;
TaskScheduler.UnobservedTaskException += actionCenter.ReportUnhandledException;
var windowViewModel = new MainWindowViewModel(services,
settings,
dataSources,
quickFilters,
actionCenter,
updater);
navigationService.MainWindow = windowViewModel;
var window = new MainWindow(settings, windowViewModel);
settings.MainWindow.ClipToBounds(Desktop.Current);
settings.MainWindow.RestoreTo(window);
settings.AllowSave = true;
stopwatch.Stop();
Log.InfoFormat("Tailviewer started (took {0}ms), showing window...", stopwatch.ElapsedMilliseconds);
window.Show();
mutex?.SetListener(window);
return(application.Run());
}
}
}
}
private static int StartInternal(SingleApplicationHelper.IMutex mutex, string[] args)
{
InstallExceptionHandlers();
Log.InfoFormat("Starting tailviewer...");
Log.InfoFormat("Commandline arguments: {0}", string.Join(" ", args));
LogEnvironment();
ApplicationSettings settings = ApplicationSettings.Create();
settings.Restore(out var neededPatching);
if (neededPatching)
{
// TODO: Save settings right again to complete the upgrade
// (maybe we should preserve an old version)
}
var actionCenter = new ActionCenter();
using (var taskScheduler = new DefaultTaskScheduler())
using (var serialTaskScheduler = new SerialTaskScheduler())
{
var filesystem = new Filesystem(serialTaskScheduler);
using (var pluginArchiveLoader = new PluginArchiveLoader(filesystem, Constants.PluginPath))
{
var pluginSystem = CreatePluginSystem(pluginArchiveLoader);
var fileFormatPlugins = pluginSystem.LoadAllOfType <IFileFormatPlugin>();
var logFileFactory = new PluginLogFileFactory(taskScheduler, fileFormatPlugins);
using (var dataSources = new DataSources(logFileFactory, taskScheduler, settings.DataSources))
using (var updater = new AutoUpdater(actionCenter, settings.AutoUpdate))
using (var logAnalyserEngine = new LogAnalyserEngine(taskScheduler, pluginSystem))
using (var dataSourceAnalyserEngine = new DataSourceAnalyserEngine(taskScheduler, logAnalyserEngine, pluginSystem))
using (var analysisStorage = new AnalysisStorage(taskScheduler, filesystem, dataSourceAnalyserEngine, CreateTypeFactory(pluginSystem)))
{
var arguments = ArgumentParser.TryParse(args);
if (arguments.FileToOpen != null)
{
if (File.Exists(arguments.FileToOpen))
{
// Not only do we want to add this file to the list of data sources,
// but we also want to select it so the user can view it immediately, regardless
// of what was selected previously.
var dataSource = dataSources.AddDataSource(arguments.FileToOpen);
settings.DataSources.SelectedItem = dataSource.Id;
}
else
{
Log.ErrorFormat("File '{0}' does not exist, won't open it!", arguments.FileToOpen);
}
}
if (settings.AutoUpdate.CheckForUpdates)
{
// Our initial check for updates is not due to a user action
// and therefore we don't need to show a notification when the
// application is up-to-date.
updater.CheckForUpdates(addNotificationWhenUpToDate: false);
}
var quickFilters = new QuickFilters(settings.QuickFilters);
actionCenter.Add(Build.Current);
actionCenter.Add(Change.Merge(Changelog.MostRecentPatches));
var application = new App();
var dispatcher = Dispatcher.CurrentDispatcher;
var uiDispatcher = new UiDispatcher(dispatcher);
dispatcher.UnhandledException += actionCenter.ReportUnhandledException;
TaskScheduler.UnobservedTaskException += actionCenter.ReportUnhandledException;
var window = new MainWindow(settings)
{
DataContext = new MainWindowViewModel(settings,
dataSources,
quickFilters,
actionCenter,
updater,
taskScheduler,
analysisStorage,
uiDispatcher,
pluginSystem)
};
settings.MainWindow.RestoreTo(window);
window.Show();
mutex.SetListener(window);
return(application.Run());
}
}
}
}
