public PostprocessorOutputRecord(
ILogSourcePostprocessor metadata,
LogSourceRecord logSourceRecord,
Action scheduleRefresh,
Action fireChangeNotification,
LJTraceSource trace,
IHeartBeatTimer heartbeat,
ISynchronizationContext modelSyncContext,
ISynchronizationContext threadPoolSyncContext,
Telemetry.ITelemetryCollector telemetry,
IOutputDataDeserializer outputDataDeserializer)
{
this.metadata = metadata;
this.logSourceRecord = logSourceRecord;
state = new LoadingState(new PostprocessorOutputRecordState.Context()
{
owner = this,
scheduleRefresh = scheduleRefresh,
fireChangeNotification = fireChangeNotification,
tracer = trace,
telemetry = telemetry,
heartbeat = heartbeat,
modelSyncContext = modelSyncContext,
threadPoolSyncContext = threadPoolSyncContext,
outputDataDeserializer = outputDataDeserializer
}, null, null);
}
public PluginsManager(
IApplication entryPoint,
UI.Presenters.MainForm.IPresenter mainFormPresenter,
Telemetry.ITelemetryCollector telemetry,
IShutdown shutdown)
{
this.tracer = new LJTraceSource("Extensibility", "plugins-mgr");
this.entryPoint = entryPoint;
this.mainFormPresenter = mainFormPresenter;
InitPlugins(telemetry);
RegisterInteropClasses();
LoadTabExtensions();
mainFormPresenter.TabChanging += (sender, e) =>
{
var ext = e.CustomTabTag as IMainFormTabExtension;
if (ext == null)
{
return;
}
try
{
ext.OnTabPageSelected();
}
catch (Exception ex)
{
telemetry.ReportException(ex, "activation of plugin tab: " + ext.Caption);
tracer.Error(ex, "Failed to activate extension tab");
}
};
shutdown.Cleanup += (s, e) => Dispose();
}
public PostprocessorsManager(
ILogSourcesManager logSources,
Telemetry.ITelemetryCollector telemetry,
ISynchronizationContext modelSyncContext,
ISynchronizationContext threadPoolSyncContext,
IHeartBeatTimer heartbeat,
Progress.IProgressAggregator progressAggregator,
Settings.IGlobalSettingsAccessor settingsAccessor,
IOutputDataDeserializer outputDataDeserializer,
ITraceSourceFactory traceSourceFactory
)
{
this.logSources = logSources;
this.telemetry = telemetry;
this.progressAggregator = progressAggregator;
this.settingsAccessor = settingsAccessor;
this.modelSyncContext = modelSyncContext;
this.threadPoolSyncContext = threadPoolSyncContext;
this.heartbeat = heartbeat;
this.outputDataDeserializer = outputDataDeserializer;
this.tracer = traceSourceFactory.CreateTraceSource("App", "ppm");
this.updater = new AsyncInvokeHelper(modelSyncContext, Refresh);
logSources.OnLogSourceAdded += (sender, args) => updater.Invoke();
logSources.OnLogSourceRemoved += (sender, args) => updater.Invoke();
logSources.OnLogSourceAnnotationChanged += (sender, args) => updater.Invoke();
logSources.OnLogSourceStatsChanged += (object sender, LogSourceStatsEventArgs e) =>
{
if ((e.Flags & LogProviderStatsFlag.ContentsEtag) != 0)
{
updater.Invoke();
}
};
Refresh();
}
public PresenterFactory(
IHeartBeatTimer heartbeat,
IPresentersFacade presentationFacade,
IClipboardAccess clipboard,
IBookmarksFactory bookmarksFactory,
Telemetry.ITelemetryCollector telemetry,
ILogSourcesManager logSources,
IInvokeSynchronization modelInvoke,
IModelThreads modelThreads,
IFiltersList hlFilters,
IBookmarks bookmarks,
Settings.IGlobalSettingsAccessor settings,
ISearchManager searchManager,
IFiltersFactory filtersFactory
)
{
this.heartbeat = heartbeat;
this.presentationFacade = presentationFacade;
this.clipboard = clipboard;
this.bookmarksFactory = bookmarksFactory;
this.telemetry = telemetry;
this.logSources = logSources;
this.modelInvoke = modelInvoke;
this.modelThreads = modelThreads;
this.hlFilters = hlFilters;
this.bookmarks = bookmarks;
this.settings = settings;
this.searchManager = searchManager;
this.filtersFactory = filtersFactory;
}
public Factory(
ITempFilesManager tempFiles,
ITraceSourceFactory traceSourceFactory,
MultiInstance.IInstancesCounter mutualExecutionCounter,
IShutdown shutdown,
ISynchronizationContext synchronizationContext,
Persistence.IFirstStartDetector firstStartDetector,
Telemetry.ITelemetryCollector telemetry,
Persistence.IStorageManager storage,
IChangeNotification changeNotification,
string autoUpdateUrl,
string pluginsIndexUrl
)
{
this.tempFiles = tempFiles;
this.traceSourceFactory = traceSourceFactory;
this.shutdown = shutdown;
this.synchronizationContext = synchronizationContext;
this.mutualExecutionCounter = mutualExecutionCounter;
this.firstStartDetector = firstStartDetector;
this.telemetry = telemetry;
this.storage = storage;
this.changeNotification = changeNotification;
this.autoUpdateUrl = autoUpdateUrl;
this.pluginsIndexUrl = pluginsIndexUrl;
}
public MonoChecker(
Presenters.MainForm.IPresenter mainWindow,
Presenters.IAlertPopup alerts,
Telemetry.ITelemetryCollector telemetryCollector,
Presenters.IShellOpen shellOpen
)
{
mainWindow.Loaded += (sender, evt) => {
try {
CheckMono();
} catch (Exception ex) {
telemetryCollector.ReportException(ex, "mono checking");
if (alerts.ShowPopup(
"Error",
$"Required mono framework v{minMonoVersion}+ is not found on your system. " +
"The program will terminate. " +
"Do you want to start mono download before termination?",
Presenters.AlertFlags.YesNoCancel
) == Presenters.AlertFlags.Yes)
{
shellOpen.OpenInWebBrowser(
new Uri("http://download.mono-project.com/archive/mdk-latest.pkg"));
}
Environment.Exit(1);
}
};
}
public PostprocessorsManager(
ILogSourcesManager logSources,
Telemetry.ITelemetryCollector telemetry,
IInvokeSynchronization modelInvoke,
IHeartBeatTimer heartbeat,
Progress.IProgressAggregator progressAggregator,
IPostprocessorsManagerUserInteractions userInteractions,
Settings.IGlobalSettingsAccessor settingsAccessor
)
{
this.userInteractions = userInteractions;
this.logSources = logSources;
this.telemetry = telemetry;
this.progressAggregator = progressAggregator;
this.settingsAccessor = settingsAccessor;
logSources.OnLogSourceAdded += (sender, args) => { lazyUpdateTracker.Invalidate(); };
logSources.OnLogSourceRemoved += (sender, args) => { lazyUpdateTracker.Invalidate(); };
logSources.OnLogSourceAnnotationChanged += (sender, args) => { lazyUpdateTracker.Invalidate(); };
logSources.OnLogSourceStatsChanged += (object sender, LogSourceStatsEventArgs e) =>
{
if ((e.Flags & LogProviderStatsFlag.ContentsEtag) != 0)
{
modelInvoke.Invoke(() => RefreshInternal(assumeSourceChanged: sender as ILogSource));
}
};
heartbeat.OnTimer += (sender, args) =>
{
if (lazyUpdateTracker.Validate())
{
RefreshInternal();
}
};
RefreshInternal();
}
public LogSourcesPreprocessingManager(
ISynchronizationContext invokeSynchronize,
IFormatAutodetect formatAutodetect,
IExtensionsRegistry extensions,
IPreprocessingManagerExtension builtinStepsExtension,
Telemetry.ITelemetryCollector telemetry,
ITempFilesManager tempFilesManager,
ILogSourcesManager logSourcesManager,
IShutdown shutdown,
ITraceSourceFactory traceSourceFactory,
IChangeNotification changeNotification
)
{
this.traceSourceFactory = traceSourceFactory;
this.trace = traceSourceFactory.CreateTraceSource("PreprocessingManager", "prepr");
this.invokeSynchronize = invokeSynchronize;
this.formatAutodetect = formatAutodetect;
this.providerYieldedCallback = prov => logSourcesManager.Create(prov.Factory, prov.ConnectionParams).Visible = !prov.IsHiddenLog;
this.extensions = extensions;
this.telemetry = telemetry;
this.tempFilesManager = tempFilesManager;
this.logSourcesManager = logSourcesManager;
this.changeNotification = changeNotification;
extensions.Register(builtinStepsExtension);
shutdown.Cleanup += (sender, e) =>
{
shutdown.AddCleanupTask(this.DeleteAllPreprocessings());
};
}
public Presenter(
IView view,
IManager postprocessorsManager,
IPostprocessorOutputFormFactory outputFormsFactory,
ILogSourcesManager logSourcesManager,
ITempFilesManager tempFiles,
IShellOpen shellOpen,
NewLogSourceDialog.IPresenter newLogSourceDialog,
Telemetry.ITelemetryCollector telemetry,
IChangeNotification changeNotification,
MainForm.IPresenter mainFormPresenter
)
{
this.view = view;
this.postprocessorsManager = postprocessorsManager;
this.outputFormsFactory = outputFormsFactory;
this.tempFiles = tempFiles;
this.shellOpen = shellOpen;
this.newLogSourceDialog = newLogSourceDialog;
this.telemetry = telemetry;
this.changeNotification = changeNotification.CreateChainedChangeNotification(false);
this.view.SetViewModel(this);
logSourcesManager.OnLogSourceAnnotationChanged += (sender, e) =>
{
RefreshView();
};
// todo: create when there a least one postprocessor exists. Postprocessors may come from plugins or it can be internal trace.
mainFormPresenter.AddCustomTab(view.UIControl, TabCaption, this);
mainFormPresenter.TabChanging += (sender, e) => OnTabPageSelected(e.CustomTabTag == this);
}
public PluggableProtocolManager(
ITraceSourceFactory traceSourceFactory,
MultiInstance.IInstancesCounter instancesCounter,
IShutdown shutdown,
Telemetry.ITelemetryCollector telemetryCollector,
Persistence.IFirstStartDetector firstStartDetector,
ILaunchUrlParser launchUrlParser
)
{
this.tracer = traceSourceFactory.CreateTraceSource("PluggableProtocol");
this.launchUrlParser = launchUrlParser;
if (instancesCounter.IsPrimaryInstance)
{
this.regUpdater = RegistryUpdater(shutdown.ShutdownToken, telemetryCollector, firstStartDetector.IsFirstStartDetected);
}
shutdown.Cleanup += (s, e) =>
{
if (regUpdater != null)
{
shutdown.AddCleanupTask(regUpdater.WithTimeout(TimeSpan.FromSeconds(1)));
}
};
}
public void BeforeEach()
{
logSources = Substitute.For <ILogSourcesManager>();
telemetry = Substitute.For <Telemetry.ITelemetryCollector>();
mockedSyncContext = new ManualSynchronizationContext();
heartbeat = Substitute.For <IHeartBeatTimer>();
progressAggregator = Substitute.For <Progress.IProgressAggregator>();
settingsAccessor = Substitute.For <Settings.IGlobalSettingsAccessor>();
logSource1 = Substitute.For <ILogSource>();
logProviderFac1 = Substitute.For <ILogProviderFactory>();
logSource1.Provider.Factory.Returns(logProviderFac1);
logSource1.Provider.ConnectionParams.Returns(new ConnectionParams($"{ConnectionParamsKeys.PathConnectionParam}=/log.txt"));
logSource1.Provider.Stats.Returns(new LogProviderStats()
{
ContentsEtag = null
});
logSourcePP1 = Substitute.For <ILogSourcePostprocessor>();
logSourcePP1.Kind.Returns(PostprocessorKind.SequenceDiagram);
pp1outputXmlSection = Substitute.For <Persistence.ISaxXMLStorageSection>();
logSource1.LogSourceSpecificStorageEntry.OpenSaxXMLSection("postproc-sequencediagram.xml", Persistence.StorageSectionOpenFlag.ReadOnly).Returns(pp1outputXmlSection);
pp1outputXmlSection.Reader.Returns(Substitute.For <XmlReader>());
pp1PostprocessorOutput = Substitute.For <IPostprocessorOutputETag>();
outputDataDeserializer = Substitute.For <IOutputDataDeserializer>();
outputDataDeserializer.Deserialize(PostprocessorKind.SequenceDiagram, Arg.Any <LogSourcePostprocessorDeserializationParams>()).Returns(pp1PostprocessorOutput);
pp1RunSummary = Substitute.For <IPostprocessorRunSummary>();
logSourcePP1.Run(null).ReturnsForAnyArgs(Task.FromResult(pp1RunSummary));
pp1RunSummary.GetLogSpecificSummary(null).ReturnsForAnyArgs((IPostprocessorRunSummary)null);
manager = new LogJoint.Postprocessing.PostprocessorsManager(
logSources, telemetry, mockedSyncContext, mockedSyncContext, heartbeat, progressAggregator, settingsAccessor, outputDataDeserializer, new TraceSourceFactory());
manager.RegisterLogType(new LogSourceMetadata(logProviderFac1, logSourcePP1));
}
async Task RegistryUpdater(CancellationToken cancel, Telemetry.ITelemetryCollector telemetryCollector, bool skipWaiting)
{
try
{
tracer.Info("pluggable protocol registration updater started");
if (!skipWaiting)
{
await Task.Delay(TimeSpan.FromSeconds(15), cancel).ConfigureAwait(continueOnCapturedContext: false);
tracer.Info("waited enough. waking up");
}
if (!TestRegEntries())
{
var exePath = Application.ExecutablePath;
if (IsGoodExeToRegister(exePath))
{
UpdateRegEntries(exePath);
}
}
}
catch (TaskCanceledException)
{
}
catch (Exception e)
{
telemetryCollector.ReportException(e, "failed to register pluggable protocol");
}
}
public PluginTabPagePresenter(
IView view,
IPostprocessorsManager postprocessorsManager,
IPostprocessorOutputFormFactory outputFormsFactory,
ILogSourcesManager logSourcesManager,
ITempFilesManager tempFiles,
IShellOpen shellOpen,
NewLogSourceDialog.IPresenter newLogSourceDialog,
Telemetry.ITelemetryCollector telemetry
)
{
this.view = view;
this.view.SetEventsHandler(this);
this.postprocessorsManager = postprocessorsManager;
this.outputFormsFactory = outputFormsFactory;
this.tempFiles = tempFiles;
this.shellOpen = shellOpen;
this.newLogSourceDialog = newLogSourceDialog;
this.telemetry = telemetry;
logSourcesManager.OnLogSourceAnnotationChanged += (sender, e) =>
{
RefreshView();
};
}
public Presenter(
IBookmarks bookmarks,
IFiltersList hlFilters,
IView view,
LogViewer.IPresenterInternal viewerPresenter,
IPresentersFacade navHandler,
IColorTheme theme,
IChangeNotification parentChangeNotification,
Telemetry.ITelemetryCollector telemetryCollector
)
{
this.hlFilters = hlFilters;
this.bookmarks = bookmarks;
this.view = view;
this.viewerPresenter = viewerPresenter;
this.navHandler = navHandler;
this.changeNotification = parentChangeNotification.CreateChainedChangeNotification(false);
this.getFocusedMessage = Selectors.Create(() => viewerPresenter.FocusedMessage,
message => message?.GetLogSource() == null ? null : message);
var getBookmarkData = bookmarks == null ? () => (null, null) :
Selectors.Create(getFocusedMessage, () => bookmarks.Items, (focused, bmks) =>
{
if (focused == null)
{
return(noSelection, null);
}
var isBookmarked = IsMessageBookmarked(focused);
return(isBookmarked ? "yes" : "no", isBookmarked ? "clear bookmark" : "set bookmark");
});
public FieldsProcessorImpl(
InitializationParams initializationParams,
IEnumerable <string> inputFieldNames,
IEnumerable <ExtensionInfo> extensions,
Persistence.IStorageEntry cacheEntry,
LJTraceSource trace,
Telemetry.ITelemetryCollector telemetryCollector,
IMetadataReferencesProvider metadataReferencesProvider,
IAssemblyLoader assemblyLoader
)
{
if (inputFieldNames == null)
{
throw new ArgumentNullException(nameof(inputFieldNames));
}
initializationParams.InitializeInstance(this);
if (extensions != null)
{
this.extensions.AddRange(extensions);
}
this.inputFieldNames = inputFieldNames.Select((name, idx) => name ?? string.Format("Field{0}", idx)).ToList();
this.cacheEntry = cacheEntry;
this.trace = trace;
this.telemetryCollector = telemetryCollector;
this.metadataReferencesProvider = metadataReferencesProvider;
this.assemblyLoader = assemblyLoader;
}
static IReadOnlyList <IPluginInfo> MakePluginInfoList(
IPluginsIndex index,
ImmutableArray <IPluginManifest> installedPluginsManifests,
Telemetry.ITelemetryCollector telemetryCollector
)
{
Dictionary <string, PluginInfo> map = new Dictionary <string, PluginInfo>();
var installedPluginsMap = installedPluginsManifests.ToLookup(p => p.Id);
foreach (var indexedPlugin in index.Plugins)
{
map[indexedPlugin.Id] = new PluginInfo
{
id = indexedPlugin.Id,
version = indexedPlugin.Version,
name = indexedPlugin.Name,
description = indexedPlugin.Description,
indexItem = indexedPlugin,
installedPluginManifest = installedPluginsMap[indexedPlugin.Id].FirstOrDefault(),
dependenciesIds = indexedPlugin.Dependencies,
};
}
installedPluginsManifests
.Where(installedPlugin => !map.ContainsKey(installedPlugin.Id))
.Select(installedPlugin => new PluginInfo
{
id = installedPlugin.Id,
version = installedPlugin.Version,
name = installedPlugin.Name,
description = installedPlugin.Description,
indexItem = null,
installedPluginManifest = installedPlugin,
dependenciesIds = installedPlugin.Dependencies
})
.ToList()
.ForEach(p => map[p.id] = p);
foreach (var p in map.Values.ToArray())
{
var deps = p.dependenciesIds.Select(depId =>
{
bool resolved = map.TryGetValue(depId, out var dep);
return(resolved, depId, dep);
}).ToArray();
var unresolvedDeps = deps.Where(d => !d.resolved).Select(d => d.depId).ToArray();
if (unresolvedDeps.Length > 0)
{
telemetryCollector.ReportException(new Exception("Bad plug-ins index"),
$"Plug-in {p.id} depends on non-indexed plug-in(s) {string.Join(",", unresolvedDeps)}");
}
var resolvedDeps = deps.Where(d => d.resolved).Select(d => d.dep).ToList();
p.dependencies = resolvedDeps.AsReadOnly();
resolvedDeps.ForEach(d => d.dependants = d.dependants.Add(p));
}
return(ImmutableArray.CreateRange(map.Values));
}
public Factory(
Persistence.IStorageManager storageManager,
Telemetry.ITelemetryCollector telemetryCollector
)
{
this.cacheEntry = storageManager.GetEntry("user-code-cache", 0x81012232);
this.telemetryCollector = telemetryCollector;
}
public NavigationManager(
LJTraceSource tracer,
Telemetry.ITelemetryCollector telemetry
)
{
this.tracer = tracer;
this.telemetry = telemetry;
}
public Model(
IInvokeSynchronization threadSync,
Telemetry.ITelemetryCollector telemetryCollector,
Persistence.IWebContentCache webCache,
Persistence.IContentCache contentCache,
Persistence.IStorageManager storageManager,
IBookmarks bookmarks,
ILogSourcesManager sourcesManager,
IModelThreads threads,
ITempFilesManager tempFilesManager,
Preprocessing.IPreprocessingManagerExtensionsRegistry preprocessingManagerExtentionsRegistry,
Preprocessing.ILogSourcesPreprocessingManager logSourcesPreprocessingManager,
Preprocessing.IPreprocessingStepsFactory preprocessingStepsFactory,
Progress.IProgressAggregator progressAggregator,
ILogProviderFactoryRegistry logProviderFactoryRegistry,
IUserDefinedFormatsManager userDefinedFormatsManager,
MRU.IRecentlyUsedEntities mru,
Progress.IProgressAggregatorFactory progressAggregatorsFactory,
IHeartBeatTimer heartbeat,
ILogSourcesController logSourcesController,
IShutdown shutdown,
WebBrowserDownloader.IDownloader webBrowserDownloader,
AppLaunch.ICommandLineHandler commandLineHandler,
Postprocessing.IPostprocessorsManager postprocessorsManager,
Postprocessing.IUserNamesProvider analyticsShortNames,
Analytics.TimeSeries.ITimeSeriesTypesAccess timeSeriesTypes,
Postprocessing.IAggregatingLogSourceNamesProvider logSourceNamesProvider
)
{
this.ModelThreadSynchronization = threadSync;
this.Telemetry = telemetryCollector;
this.WebContentCache = webCache;
this.ContentCache = contentCache;
this.StorageManager = storageManager;
this.Bookmarks = bookmarks;
this.SourcesManager = sourcesManager;
this.Threads = threads;
this.TempFilesManager = tempFilesManager;
this.PreprocessingManagerExtensionsRegistry = preprocessingManagerExtentionsRegistry;
this.PreprocessingStepsFactory = preprocessingStepsFactory;
this.LogSourcesPreprocessingManager = logSourcesPreprocessingManager;
this.ProgressAggregator = progressAggregator;
this.LogProviderFactoryRegistry = logProviderFactoryRegistry;
this.UserDefinedFormatsManager = userDefinedFormatsManager;
this.ProgressAggregatorsFactory = progressAggregatorsFactory;
this.MRU = mru;
this.Heartbeat = heartbeat;
this.LogSourcesController = logSourcesController;
this.Shutdown = shutdown;
this.WebBrowserDownloader = webBrowserDownloader;
this.CommandLineHandler = commandLineHandler;
this.PostprocessorsManager = postprocessorsManager;
this.ShortNames = analyticsShortNames;
this.TimeSeriesTypes = timeSeriesTypes;
this.LogSourceNamesProvider = logSourceNamesProvider;
}
public NSOutlineViewController(NSOutlineView treeView, Telemetry.ITelemetryCollector telemetryCollector)
{
this.treeView = treeView;
this.telemetryCollector = telemetryCollector;
this.dataSource = new DataSource(this, treeView);
this.@delegate = new Delegate(this);
this.treeView.Delegate = @delegate;
this.treeView.DataSource = dataSource;
}
public NSTableViewController(NSTableView tableView, Telemetry.ITelemetryCollector telemetryCollector)
{
this.tableView = tableView;
this.telemetryCollector = telemetryCollector;
this.dataSource = new DataSource(this, tableView);
this.@delegate = new Delegate(this, this.dataSource);
this.tableView.Delegate = @delegate;
this.tableView.DataSource = dataSource;
}
public NavigationManager(
LJTraceSource tracer,
Telemetry.ITelemetryCollector telemetry,
IChangeNotification changeNotification
)
{
this.tracer = tracer;
this.telemetry = telemetry;
this.changeNotification = changeNotification;
}
public Presenter(
Telemetry.ITelemetryCollector telemetryCollector,
Telemetry.ITelemetryUploader telemetryUploader,
IPromptDialog promptDialog
)
{
this.telemetryCollector = telemetryCollector;
this.telemetryUploader = telemetryUploader;
this.promptDialog = promptDialog;
}
internal SearchWorker(
ILogSource logSource,
SearchAllOptions options,
Telemetry.ITelemetryCollector telemetryCollector
)
{
this.logSource = logSource;
this.options = options;
this.worker = Worker();
this.telemetryCollector = telemetryCollector;
}
public Factory(
Persistence.IStorageManager storageManager,
Telemetry.ITelemetryCollector telemetryCollector,
IMetadataReferencesProvider metadataReferencesProvider,
IAssemblyLoader assemblyLoader
)
{
this.cacheEntry = storageManager.GetEntry("user-code-cache", 0x81012232);
this.telemetryCollector = telemetryCollector;
this.metadataReferencesProvider = metadataReferencesProvider ?? new DefaultMetadataReferencesProvider();
this.assemblyLoader = assemblyLoader ?? new DefaultAssemblyLoader();
}
public SearchObjectsFactory(
Progress.IProgressAggregatorFactory progressAggregatorFactory,
IInvokeSynchronization modelSynchronization,
Settings.IGlobalSettingsAccessor settings,
Telemetry.ITelemetryCollector telemetryCollector
)
{
this.progressAggregatorFactory = progressAggregatorFactory;
this.modelSynchronization = modelSynchronization;
this.settings = settings;
this.telemetryCollector = telemetryCollector;
}
public PostprocessorsManager(
ILogSourcesManager logSources,
Telemetry.ITelemetryCollector telemetry,
ISynchronizationContext modelSyncContext,
ISynchronizationContext threadPoolSyncContext,
IHeartBeatTimer heartbeat,
Progress.IProgressAggregator progressAggregator,
Settings.IGlobalSettingsAccessor settingsAccessor,
IOutputDataDeserializer outputDataDeserializer,
ITraceSourceFactory traceSourceFactory,
ILogPartTokenFactories logPartTokenFactories,
Correlation.ISameNodeDetectionTokenFactories sameNodeDetectionTokenFactories,
IChangeNotification changeNotification,
LogMedia.IFileSystem logFileSystem
)
{
this.logSources = logSources;
this.telemetry = telemetry;
this.progressAggregator = progressAggregator;
this.settingsAccessor = settingsAccessor;
this.modelSyncContext = modelSyncContext;
this.threadPoolSyncContext = threadPoolSyncContext;
this.heartbeat = heartbeat;
this.outputDataDeserializer = outputDataDeserializer;
this.logPartTokenFactories = logPartTokenFactories;
this.sameNodeDetectionTokenFactories = sameNodeDetectionTokenFactories;
this.changeNotification = changeNotification;
this.logFileSystem = logFileSystem;
this.tracer = traceSourceFactory.CreateTraceSource("App", "ppm");
this.updater = new AsyncInvokeHelper(modelSyncContext, Refresh);
logSources.OnLogSourceAdded += (sender, args) => updater.Invoke();
logSources.OnLogSourceRemoved += (sender, args) => updater.Invoke();
logSources.OnLogSourceAnnotationChanged += (sender, args) => updater.Invoke();
logSources.OnLogSourceStatsChanged += (object sender, LogSourceStatsEventArgs e) =>
{
if ((e.Flags & LogProviderStatsFlag.ContentsEtag) != 0)
{
updater.Invoke();
}
};
this.visiblePostprocessorsOutputs = Selectors.Create(
() => postprocessorsOutputs,
() => logSources.Items,
(outputs, sources) => {
var sourcesMap = sources.ToLookup(s => s);
return(ImmutableArray.CreateRange(outputs.Where(output => sourcesMap.Contains(output.LogSource))));
}
);
Refresh();
}
public SearchObjectsFactory(
Progress.IProgressAggregatorFactory progressAggregatorFactory,
ISynchronizationContext modelSynchronization,
Settings.IGlobalSettingsAccessor settings,
Telemetry.ITelemetryCollector telemetryCollector,
ITraceSourceFactory traceSourceFactory
)
{
this.progressAggregatorFactory = progressAggregatorFactory;
this.modelSynchronization = modelSynchronization;
this.settings = settings;
this.telemetryCollector = telemetryCollector;
this.traceSourceFactory = traceSourceFactory;
}
public SearchManager(
ILogSourcesManager sources,
Progress.IProgressAggregatorFactory progressAggregatorFactory,
IInvokeSynchronization modelSynchronization,
Settings.IGlobalSettingsAccessor settings,
Telemetry.ITelemetryCollector telemetryCollector,
IHeartBeatTimer heartBeat
) : this(
sources,
modelSynchronization,
heartBeat,
new SearchObjectsFactory(progressAggregatorFactory, modelSynchronization, settings, telemetryCollector)
)
{
}
private PluginsIndex(XDocument doc, string etag, Telemetry.ITelemetryCollector telemetryCollector)
{
this.etag = etag;
var tmp = new Dictionary <string, Item>();
foreach (var pluginNode in doc.Elements("plugins").Elements("plugin"))
{
var id = pluginNode.Element("id")?.Value;
var versionStr = pluginNode.Element("version")?.Value;
var name = pluginNode.Element("name")?.Value;
var platform = pluginNode.Element("platform")?.Value;
var locationStr = pluginNode.Element("location")?.Value;
var description = pluginNode.Element("description")?.Value;
var pluginEtag = pluginNode.Element("etag")?.Value;
if (string.IsNullOrEmpty(id) || string.IsNullOrEmpty(name) || string.IsNullOrEmpty(platform) || string.IsNullOrEmpty(pluginEtag) ||
!Uri.TryCreate(locationStr ?? "", UriKind.Absolute, out var location) ||
!Version.TryParse(versionStr, out var version))
{
telemetryCollector.ReportException(new Exception("Bad entry in plug-ins index"), pluginNode.ToString());
continue;
}
string thisPlatform =
#if WIN
"win";
#elif MONOMAC
"mac";
#else
"<unk>";
#endif
if (thisPlatform != platform)
{
continue;
}
tmp[id] = new Item
{
id = id,
version = version,
name = name,
description = description ?? "",
location = location,
etag = pluginEtag,
dependencies = ImmutableArray.CreateRange(pluginNode.Elements("dependency").Select(d => d.Value))
};
}
this.items = ImmutableArray.CreateRange(tmp.Values);
}
