public void TestLoadAllOfType1()
        {
            using (var stream = new MemoryStream())
            {
                using (var packer = PluginPacker.Create(stream, true))
                {
                    var builder = new PluginBuilder("Kittyfisto", "SomePlugin", "none of your business", "get of my lawn");
                    builder.ImplementInterface <ILogEntryParserPlugin>("Plugin.FileFormatPlugin");
                    builder.Save();

                    packer.AddPluginAssembly(builder.FileName);
                }

                stream.Position = 0;
                _filesystem.Write(Path.Combine(Constants.PluginPath, "Kittyfisto.SomePlugin.1.tvp"), stream);

                using (var loader = new PluginArchiveLoader(_filesystem, Constants.PluginPath))
                {
                    var plugins = loader.LoadAllOfType <ILogEntryParserPlugin>()?.ToList();
                    plugins.Should().NotBeNull();
                    plugins.Should().HaveCount(1);
                    plugins[0].Should().NotBeNull();
                    plugins[0].GetType().FullName.Should().Be("Plugin.FileFormatPlugin");
                }
            }
        }
Beispiel #2
0
        public void TestLoadAllOfType1()
        {
            using (var stream = new MemoryStream())
            {
                using (var packer = PluginPacker.Create(stream, true))
                {
                    var builder = new PluginBuilder("Kittyfisto", "SomePlugin", "none of your business", "get of my lawn");
                    builder.ImplementInterface <IFileFormatPlugin>("Plugin.FileFormatPlugin");
                    builder.Save();

                    packer.AddPluginAssembly(builder.FileName);
                }

                stream.Position = 0;

                using (var loader = new PluginArchiveLoader(null))
                {
                    var description = loader.ReflectPlugin(stream, true);
                    var plugins     = loader.LoadAllOfType <IFileFormatPlugin>()?.ToList();
                    plugins.Should().NotBeNull();
                    plugins.Should().HaveCount(1);
                    plugins[0].Should().NotBeNull();
                    plugins[0].GetType().FullName.Should().Be("Plugin.FileFormatPlugin");
                }
            }
        }
        public void TestLoadDifferentVersions()
        {
            CreatePlugin("Kittyfisto", "Foobar", new Version(1, 0));
            CreatePlugin("Kittyfisto", "Foobar", new Version(1, 1));

            using (var loader = new PluginArchiveLoader(_filesystem, Constants.PluginPath))
            {
                loader.Plugins.Should().HaveCount(1);
                loader.Plugins.First().Version.Should().Be(new Version(1, 1));

                var plugins = loader.LoadAllOfType <ILogEntryParserPlugin>();
                plugins.Should().HaveCount(1);
            }
        }
Beispiel #4
0
        public void TestLoadDifferentVersions()
        {
            var plugin1 = CreatePlugin("Kittyfisto", "Foobar", new Version(1, 0));
            var plugin2 = CreatePlugin("Kittyfisto", "Foobar", new Version(1, 1));

            using (var loader = new PluginArchiveLoader(null))
            {
                loader.ReflectPlugin(plugin1);
                loader.ReflectPlugin(plugin2);

                loader.Plugins.Should().HaveCount(1);
                loader.Plugins.First().Version.Should().Be(new Version(1, 1));

                var plugins = loader.LoadAllOfType <IFileFormatPlugin>();
                plugins.Should().HaveCount(1);
            }
        }
        public void TestLoadAllOfType()
        {
            using (var stream = new MemoryStream())
            {
                using (var packer = PluginPacker.Create(stream, true))
                {
                    var builder = new PluginBuilder("Kittyfisto", "Simon", "none of your business", "get of my lawn");
                    builder.ImplementInterface <ILogEntryParserPlugin>("Plugin.FileFormatPlugin");
                    builder.Save();

                    packer.AddPluginAssembly(builder.FileName);
                }

                stream.Position = 0;
                var path = Path.Combine(Constants.PluginPath, "Kittyfisto.Simon.1.0.tvp");
                _filesystem.WriteAllBytes(path, stream.ToArray());

                using (var loader = new PluginArchiveLoader(_filesystem, Constants.PluginPath))
                {
                    var plugins = loader.LoadAllOfType <ILogEntryParserPlugin>();
                    plugins.Should().HaveCount(1, "because we've added one plugin which implements the IFileFormatPlugin interface");
                }
            }
        }
Beispiel #6
0
        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();
            bool neededPatching;

            settings.Restore(out 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())
                    using (var scanner = new PluginArchiveLoader(Constants.PluginPath))
                    {
                        var fileFormatPlugins = scanner.LoadAllOfType <IFileFormatPlugin>();
                        var filesystem        = new Filesystem(serialTaskScheduler);

                        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))
                                    using (var analysisStorage = new AnalysisStorage(taskScheduler, filesystem, logAnalyserEngine))
                                    //using (var analyses = new Analyses(taskScheduler, filesystem, logAnalyserEngine))
                                    {
                                        logAnalyserEngine.RegisterFactory(new LogEntryCountAnalyserPlugin());
                                        logAnalyserEngine.RegisterFactory(new QuickInfoAnalyserPlugin());
                                        logAnalyserEngine.RegisterFactory(new EventsLogAnalyserPlugin());

                                        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();
                                        Dispatcher 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,
                                                                                  scanner.Plugins)
                                        };

                                        settings.MainWindow.RestoreTo(window);

                                        window.Show();
                                        mutex.SetListener(window);

                                        return(application.Run());
                                    }
                    }
        }