public LogSource(ILogSourcesManagerInternal owner, int id,
ILogProviderFactory providerFactory, IConnectionParams connectionParams,
IModelThreads threads, ITempFilesManager tempFilesManager, Persistence.IStorageManager storageManager,
IInvokeSynchronization invoker, Settings.IGlobalSettingsAccessor globalSettingsAccess, IBookmarks bookmarks)
{
this.owner = owner;
this.tracer = new LJTraceSource("LogSource", string.Format("ls{0:D2}", id));
this.tempFilesManager = tempFilesManager;
this.invoker = invoker;
this.globalSettingsAccess = globalSettingsAccess;
this.bookmarks = bookmarks;
try
{
this.logSourceThreads = new LogSourceThreads(this.tracer, threads, this);
this.timeGaps = new TimeGapsDetector(tracer, invoker, new LogSourceGapsSource(this));
this.timeGaps.OnTimeGapsChanged += timeGaps_OnTimeGapsChanged;
this.logSourceSpecificStorageEntry = CreateLogSourceSpecificStorageEntry(providerFactory, connectionParams, storageManager);
var extendedConnectionParams = connectionParams.Clone(true);
this.LoadPersistedSettings(extendedConnectionParams);
this.provider = providerFactory.CreateFromConnectionParams(this, extendedConnectionParams);
}
catch (Exception e)
{
tracer.Error(e, "Failed to initialize log source");
((ILogSource)this).Dispose();
throw;
}
this.owner.Container.Add(this);
this.owner.FireOnLogSourceAdded(this);
this.LoadBookmarks();
}
static void InitLogFactories(LJTraceSource tracer, IUserDefinedFormatsManager userDefinedFormatsManager, ILogProviderFactoryRegistry factoryRegistry)
{
using (tracer.NewFrame)
{
var asmsToAnalize = new Assembly[] {
Assembly.GetEntryAssembly(),
typeof(ILogSourcesManager).Assembly
};
var factoryTypes = asmsToAnalize.SelectMany(a => a.GetTypes())
.Where(t => t.IsClass && typeof(ILogProviderFactory).IsAssignableFrom(t));
foreach (Type t in factoryTypes)
{
tracer.Info("initing factory {0}", t.FullName);
System.Runtime.CompilerServices.RuntimeHelpers.RunClassConstructor(t.TypeHandle);
var registrationMethod = (
from m in t.GetMethods(BindingFlags.Static | BindingFlags.Public)
where m.GetCustomAttributes(typeof(RegistrationMethodAttribute), true).Length == 1
let args = m.GetParameters()
where args.Length == 1
let isUserDefined = typeof(IUserDefinedFormatsManager) == args[0].ParameterType
let isBuiltin = typeof(ILogProviderFactoryRegistry) == args[0].ParameterType
where isUserDefined || isBuiltin
select new { Method = m, Arg = isUserDefined ? (object)userDefinedFormatsManager : (object)factoryRegistry }
).FirstOrDefault();
if (registrationMethod != null)
{
t.InvokeMember(registrationMethod.Method.Name,
BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Static,
null, null, new object[] { registrationMethod.Arg });
}
}
}
}
public MessagesPostprocessor(SearchAllOccurencesParams searchParams, LJTraceSource trace)
{
this.bulkProcessing = searchParams.Filters.StartBulkProcessing(
searchParams.SearchInRawText, reverseMatchDirection: false);
this.filteringTime = new Stopwatch();
this.tid = Thread.CurrentThread.ManagedThreadId;
this.trace = trace;
}
public Helper(TimeGapsDetector owner)
{
this.owner = owner;
this.invoke = owner.syncInvoke;
this.trace = new LJTraceSource("GapsDetector",
string.Format("{0}.h{1}", owner.trace.Prefix, ++owner.lastHelperId));
this.source = owner.source;
}
public Helper(TimeGapsDetector owner)
{
this.owner = owner;
this.invoke = owner.modelSynchronizationContext;
this.trace = owner.traceSourceFactory.CreateTraceSource("GapsDetector",
string.Format("{0}.h{1}", owner.trace.Prefix, ++owner.lastHelperId));
this.source = owner.source;
}
public AppInitializer(
LJTraceSource tracer,
IUserDefinedFormatsManager userDefinedFormatsManager,
ILogProviderFactoryRegistry factoryRegistry,
ITempFilesManager tempFiles)
{
InitializePlatform(tracer);
InitLogFactories(userDefinedFormatsManager, factoryRegistry, tempFiles);
userDefinedFormatsManager.ReloadFactories();
}
static IEnumerable <Checkpoint> EnumCheckpoints(
ITextAccessIterator tai, PlainTextMatcher matcher,
ProgressAndCancellation progressAndCancellation,
LJTraceSource trace)
{
var advanceTime = new Stopwatch();
long advancesCount = 0;
var matchingTime = new Stopwatch();
long matchCount = 0;
for (;;)
{
StringSlice buf = new StringSlice(tai.CurrentBuffer);
for (int startIdx = 0; ;)
{
matchingTime.Start();
var match = matcher.Match(buf, startIdx);
matchingTime.Stop();
++matchCount;
if (!match.HasValue)
{
break;
}
yield return(new Checkpoint()
{
Position = tai.CharIndexToPosition(match.Value.MatchBegin),
EndPosition = tai.CharIndexToPosition(match.Value.MatchEnd),
IsMatch = true
});
startIdx = match.Value.MatchEnd;
progressAndCancellation.CheckTextIterationCancellation();
}
advanceTime.Start();
bool stop = !tai.Advance(Math.Max(0, tai.CurrentBuffer.Length - matcher.MaxMatchLength));
advanceTime.Stop();
++advancesCount;
if (stop)
{
break;
}
yield return(new Checkpoint()
{
EndPosition = tai.CharIndexToPosition(0),
IsMatch = false
});
progressAndCancellation.CheckTextIterationCancellation();
}
trace.Info("Stats: text buffer matching time: {0} ({1} times)",
matchingTime.Elapsed, matchCount);
trace.Info("Stats: text buffer advance time: {0}/{1}={2}",
advanceTime.Elapsed, advancesCount,
TimeSpan.FromTicks(advanceTime.ElapsedTicks / Math.Max(1, advancesCount)));
}
public UpdateCacheCommandHandler(
IAsyncLogProvider owner,
LJTraceSource tracer,
MessagesContainers.RangesManagingCollection buffer,
Settings.IGlobalSettingsAccessor settingsAccessor
)
{
this.owner = owner;
this.buffer = buffer;
this.tracer = tracer;
this.settingsAccessor = settingsAccessor;
}
public TimeGapsDetector(LJTraceSource tracer, IInvokeSynchronization modelThreadInvoke, ITimeGapsSource source)
{
this.trace = new LJTraceSource("GapsDetector", tracer.Prefix + ".gaps");
using (trace.NewFrame)
{
this.syncInvoke = modelThreadInvoke;
this.source = source;
trace.Info("starting worker thread");
thread = Task.Run((Func <Task>)ThreadProc);
}
}
public Command(
CommandType t,
LogProviderCommandPriority priority,
LJTraceSource trace,
CancellationToken cancellation,
IAsyncLogProviderCommandHandler handler)
{
Type = t;
Priority = priority;
Cancellation = cancellation;
Handler = handler;
Perfop = new LogJoint.Profiling.Operation(trace, this.ToString());
}
public Command(
CommandType t,
LogProviderCommandPriority priority,
LJTraceSource trace,
CancellationToken cancellation,
IAsyncLogProviderCommandHandler handler)
{
Type = t;
Id = Interlocked.Increment(ref lastCommandId);
Priority = priority;
Cancellation = cancellation;
Handler = handler;
Perfop = new Profiling.Operation(trace, this.ToString());
}
public RollingFilesMedia(
LogMedia.IFileSystem fileSystem,
Type logReaderType,
StreamBasedFormatInfo logFormatInfo,
LJTraceSource traceSource,
IRollingFilesMediaStrategy rollingStrategy,
ITempFilesManager tempFilesManager,
ITraceSourceFactory traceSourceFactory)
{
this.traceSourceFactory = traceSourceFactory;
trace = traceSource;
using (trace.NewFrame)
{
if (fileSystem == null)
{
throw new ArgumentNullException("fileSystem");
}
this.rollingStrategy = rollingStrategy;
this.logReaderType = logReaderType;
this.logFormatInfo = logFormatInfo;
this.tempFilesManager = tempFilesManager;
try
{
this.fileSystem = fileSystem;
this.baseDirectory = rollingStrategy.BaseDirectory;
trace.Info("Base file directory: {0}", baseDirectory);
this.concatStream = new ConcatReadingStream();
this.tempThreads = new LogSourceThreads(LJTraceSource.EmptyTracer, new ModelThreads(), null);
this.fsWatcher = fileSystem.CreateWatcher();
this.fsWatcher.Path = this.baseDirectory;
this.fsWatcher.Created += new FileSystemEventHandler(fsWatcher_Created);
this.fsWatcher.Renamed += new RenamedEventHandler(fsWatcher_Renamed);
this.fsWatcher.EnableRaisingEvents = true;
trace.Info("Watcher enabled");
this.folderNeedsRescan = 1;
}
catch
{
trace.Error("Initialization failed. Disposing.");
Dispose();
throw;
}
}
}
public static async Task LogAndThrowOnFailure(this HttpWebResponse rsp, LJTraceSource trace)
{
if ((int)rsp.StatusCode >= 200 && (int)rsp.StatusCode < 300)
{
return;
}
using (var responseStream = rsp.GetResponseStream())
using (var responseReader = new StreamReader(responseStream))
{
trace.Error("http failed. {0} {1} {2}",
rsp.Method, rsp.ResponseUri, await responseReader.ReadToEndAsync());
}
throw new WebException("http request failed");
}
void WriteBeginFrame(string fmt, params object[] args)
{
ThreadData d = Data;
XmlWriter writer = d.writer;
Token t = NewToken();
writer.WriteStartElement("f");
writer.WriteAttributeString("d", FormatDate(t.DateIssued));
writer.WriteAttributeString("t", d.IDStr);
writer.WriteString("\n\t");
writer.WriteString(LJTraceSource.SafeFormat(fmt, args));
writer.WriteString("\n");
writer.WriteEndElement();
Flush(d, t);
}
public LiveLogProvider(ILogProviderHost host, ILogProviderFactory factory, IConnectionParams originalConnectionParams, DejitteringParams?dejitteringParams = null)
:
base(
host,
factory,
CreateConnectionParams(originalConnectionParams, host.TempFilesManager),
@params => new XmlFormat.MessagesReader(
@params,
XmlFormat.XmlFormatInfo.MakeNativeFormatInfo(LiveLogXMLWriter.OutputEncoding.EncodingName, dejitteringParams, new FormatViewOptions(rawViewAllowed: false), host.RegexFactory),
host.RegexFactory,
host.TraceSourceFactory
)
)
{
this.trace = base.tracer;
this.originalConnectionParams = new ConnectionParamsReadOnlyView(originalConnectionParams);
using (trace.NewFrame)
{
try
{
string fileName = base.connectionParamsReadonlyView[ConnectionParamsKeys.PathConnectionParam];
XmlWriterSettings xmlSettings = new XmlWriterSettings();
xmlSettings.CloseOutput = true;
xmlSettings.ConformanceLevel = ConformanceLevel.Fragment;
xmlSettings.OmitXmlDeclaration = false;
xmlSettings.Indent = true;
output = new LiveLogXMLWriter(
new FileStream(fileName, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.Read),
xmlSettings,
defaultBackupMaxFileSize
);
trace.Info("Output created");
stopEvt = new CancellationTokenSource();
listeningThread = new Thread(ListeningThreadProc);
}
catch (Exception e)
{
trace.Error(e, "Failed to inistalize live log reader. Disposing what has been created so far.");
Dispose();
throw;
}
}
}
void WriteMessage(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string fmt, params object[] args)
{
ThreadData d = Data;
XmlWriter writer = d.writer;
Token t = NewToken();
writer.WriteStartElement("m");
writer.WriteAttributeString("d", FormatDate(t.DateIssued));
writer.WriteAttributeString("t", d.IDStr);
switch (eventType)
{
case TraceEventType.Warning:
writer.WriteAttributeString("s", "w");
break;
case TraceEventType.Error:
case TraceEventType.Critical:
writer.WriteAttributeString("s", "e");
break;
}
writer.WriteString(newLine);
writer.WriteString("\t");
writer.WriteString(LJTraceSource.SafeFormat(fmt, args));
writer.WriteString(newLine);
if ((this.TraceOutputOptions & TraceOptions.Callstack) != 0)
{
writer.WriteString(Environment.StackTrace);
writer.WriteString(newLine);
}
if ((this.TraceOutputOptions & TraceOptions.LogicalOperationStack) != 0)
{
writer.WriteString("LogicalOperationStack=");
foreach (string op in Trace.CorrelationManager.LogicalOperationStack)
{
writer.WriteString(op);
writer.WriteString("-");
}
writer.WriteString(newLine);
}
if ((this.TraceOutputOptions & TraceOptions.Timestamp) != 0)
{
writer.WriteString(string.Format("Timestamp={0}", Stopwatch.GetTimestamp()));
writer.WriteString(newLine);
}
writer.WriteEndElement();
Flush(d, t);
}
static void InitializePlatform(LJTraceSource tracer)
{
Thread.CurrentThread.Name = "Main thread";
AppDomain.CurrentDomain.UnhandledException += delegate(object sender, UnhandledExceptionEventArgs e)
{
string msg = "Unhahdled domain exception occured";
if (e.ExceptionObject is Exception)
{
tracer.Error((Exception)e.ExceptionObject, msg);
}
else
{
tracer.Error("{0}: ({1}) {2}", msg, e.ExceptionObject.GetType(), e.ExceptionObject);
}
};
}
public SearchingParser(
IPositionedMessagesReader owner,
CreateSearchingParserParams p,
TextStreamPositioningParams textStreamPositioningParams,
DejitteringParams?dejitteringParams,
Stream rawStream,
Encoding streamEncoding,
bool allowPlainTextSearchOptimization,
LoadedRegex headerRe,
ILogSourceThreads threads,
ITraceSourceFactory traceSourceFactory,
RegularExpressions.IRegexFactory regexFactory
)
{
this.owner = owner;
this.parserParams = p;
this.plainTextSearchOptimizationAllowed = allowPlainTextSearchOptimization && ((p.Flags & MessagesParserFlag.DisablePlainTextSearchOptimization) == 0);
this.threads = threads;
this.requestedRange = p.Range;
this.textStreamPositioningParams = textStreamPositioningParams;
this.dejitteringParams = dejitteringParams;
this.rawStream = rawStream;
this.streamEncoding = streamEncoding;
this.regexFactory = regexFactory;
this.trace = traceSourceFactory.CreateTraceSource("LogSource", "srchp." + GetHashCode().ToString("x"));
this.dummyFilter = new Filter(FilterAction.Include, "", true, new Search.Options(), null, regexFactory);
var continuationToken = p.ContinuationToken as ContinuationToken;
if (continuationToken != null)
{
this.requestedRange = new FileRange.Range(continuationToken.NextPosition, requestedRange.End);
}
this.aligmentTextAccess = new StreamTextAccess(rawStream, streamEncoding, textStreamPositioningParams);
this.aligmentSplitter = new MessagesSplitter(aligmentTextAccess, headerRe.Clone().Regex, headerRe.GetHeaderReSplitterFlags());
this.aligmentCapture = new TextMessageCapture();
this.progressAndCancellation = new ProgressAndCancellation()
{
progressHandler = p.ProgressHandler,
cancellationToken = p.Cancellation,
continuationToken = new ContinuationToken()
{
NextPosition = requestedRange.Begin
}
};
this.impl = Enum();
}
public TimeGapsDetector(
LJTraceSource tracer,
ISynchronizationContext modelSynchronizationContext,
ITimeGapsSource source,
ITraceSourceFactory traceSourceFactory
)
{
this.traceSourceFactory = traceSourceFactory;
this.trace = traceSourceFactory.CreateTraceSource("GapsDetector", tracer.Prefix + ".gaps");
using (trace.NewFrame)
{
this.modelSynchronizationContext = modelSynchronizationContext;
this.source = source;
trace.Info("starting worker thread");
thread = Task.Run((Func <Task>)ThreadProc);
}
}
public RollingFilesMedia(
LogMedia.IFileSystem fileSystem,
Func <MediaBasedReaderParams, IPositionedMessagesReader> readerCreator,
LJTraceSource traceSource,
IRollingFilesMediaStrategy rollingStrategy)
{
trace = traceSource;
using (trace.NewFrame)
{
if (fileSystem == null)
{
throw new ArgumentNullException(nameof(fileSystem));
}
this.rollingStrategy = rollingStrategy;
this.readerCreator = readerCreator;
try
{
this.fileSystem = fileSystem;
this.baseDirectory = rollingStrategy.BaseDirectory;
trace.Info("Base file directory: {0}", baseDirectory);
this.concatStream = new ConcatReadingStream();
this.tempThreads = new LogSourceThreads(LJTraceSource.EmptyTracer, new ModelThreads(), null);
this.fsWatcher = fileSystem.CreateWatcher();
this.fsWatcher.Path = this.baseDirectory;
this.fsWatcher.Created += new FileSystemEventHandler(fsWatcher_Created);
this.fsWatcher.Renamed += new RenamedEventHandler(fsWatcher_Renamed);
this.fsWatcher.EnableRaisingEvents = true;
trace.Info("Watcher enabled");
this.folderNeedsRescan = 1;
}
catch
{
trace.Error("Initialization failed. Disposing.");
Dispose();
throw;
}
}
}
public TempFilesManager()
{
var tracer = new LJTraceSource("App", "tmp");
using (tracer.NewFrame)
{
#if !SILVERLIGHT
folder = Path.Combine(Path.GetTempPath(), "LogJoint");
#else
#endif
bool thisIsTheOnlyInstance = false;
runningInstanceMutex = new Mutex(true, "LogJoint/TempFilesManager", out thisIsTheOnlyInstance);
tracer.Info("Temp directory: {0}", folder);
if (!Directory.Exists(folder))
{
tracer.Info("Temp directory doesn't exist. Creating it.");
Directory.CreateDirectory(folder);
}
else
{
if (!thisIsTheOnlyInstance)
{
tracer.Info("Temp directory exists and I am NOT the only instance in the system. Skipping temp cleanup.");
}
else
{
tracer.Info("Temp directory exists. Deleting it first.");
try
{
Directory.Delete(folder, true);
}
catch (Exception e)
{
tracer.Error(e, "Failed to delete tempdir");
}
}
tracer.Info("Creating temp directory.");
Directory.CreateDirectory(folder);
}
}
}
public SearchResult(
ISearchManagerInternal owner,
SearchAllOptions options,
IFilter optionsFilter,
IList <ILogSourceSearchWorkerInternal> workers,
Progress.IProgressAggregatorFactory progressAggregatorFactory,
ISynchronizationContext modelSynchronization,
Settings.IGlobalSettingsAccessor settings,
int id,
ISearchObjectsFactory factory,
ITraceSourceFactory traceSourceFactory
)
{
this.owner = owner;
this.options = options;
this.optionsFilter = optionsFilter;
this.factory = factory;
this.modelSynchronization = modelSynchronization;
this.id = id;
this.cancellation = new CancellationTokenSource();
this.results = new List <ISourceSearchResultInternal>();
this.progressAggregator = progressAggregatorFactory.CreateProgressAggregator();
this.updateInvokationHelper = new AsyncInvokeHelper(modelSynchronization, UpdateStatus);
this.hitsLimit = settings.MaxNumberOfHitsInSearchResultsView;
this.visible = true;
this.trace = traceSourceFactory.CreateTraceSource("SearchManager", "sr." + id.ToString());
this.timeGapsDetector = new TimeGapsDetector(trace, modelSynchronization, this, traceSourceFactory);
this.timeGapsDetector.OnTimeGapsChanged += (s, e) =>
{
owner.OnResultChanged(this, SearchResultChangeFlag.TimeGapsChanged);
};
this.progressAggregator.ProgressChanged += HandleProgressChanged;
this.searchTime = Stopwatch.StartNew();
this.results.AddRange(workers.Select(w => factory.CreateSourceSearchResults(w, this, cancellation.Token, progressAggregator)));
if (results.Count == 0)
{
status = SearchResultStatus.Finished;
HandleFinalStateTransition();
}
}
public BookmarkController(
IBookmarks bookmarks,
IModelThreads threads,
IHeartBeatTimer heartbeat
)
{
tracer = LJTraceSource.EmptyTracer;
threads.OnThreadListChanged += (s, e) =>
{
bookmarksNeedPurgeFlag.Invalidate();
};
heartbeat.OnTimer += (sender, args) =>
{
if (args.IsNormalUpdate && bookmarksNeedPurgeFlag.Validate())
{
bookmarks.PurgeBookmarksForDisposedThreads();
}
};
bookmarks.OnBookmarksChanged += (sender, e) =>
{
if (e.Type == BookmarksChangedEventArgs.ChangeType.Added || e.Type == BookmarksChangedEventArgs.ChangeType.Removed ||
e.Type == BookmarksChangedEventArgs.ChangeType.RemovedAll || e.Type == BookmarksChangedEventArgs.ChangeType.Purged)
{
foreach (var affectedSource in
e.AffectedBookmarks
.Select(b => b.GetLogSource())
.Where(s => s.LogSourceStateIsOkToChangePersistentState())
.Distinct())
{
try
{
affectedSource.StoreBookmarks();
}
catch (Persistence.StorageException storageException)
{
tracer.Error(storageException, "Failed to store bookmarks for log {0}",
affectedSource.GetSafeConnectionId());
}
}
}
};
}
public FieldsProcessor(
InitializationParams initializationParams,
IEnumerable <string> inputFieldNames,
IEnumerable <ExtensionInfo> extensions,
ITempFilesManager tempFilesManager,
LJTraceSource trace)
{
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.tempFilesManager = tempFilesManager;
this.trace = trace;
}
public LogSource(ILogSourcesManagerInternal owner, int id,
ILogProviderFactory providerFactory, IConnectionParams connectionParams,
IModelThreadsInternal threads, ITempFilesManager tempFilesManager, Persistence.IStorageManager storageManager,
ISynchronizationContext modelSyncContext, Settings.IGlobalSettingsAccessor globalSettingsAccess, IBookmarks bookmarks,
ITraceSourceFactory traceSourceFactory, RegularExpressions.IRegexFactory regexFactory, LogMedia.IFileSystem fileSystem)
{
this.owner = owner;
this.tracer = traceSourceFactory.CreateTraceSource("LogSource", string.Format("ls{0:D2}", id));
this.tempFilesManager = tempFilesManager;
this.modelSyncContext = modelSyncContext;
this.globalSettingsAccess = globalSettingsAccess;
this.bookmarks = bookmarks;
this.traceSourceFactory = traceSourceFactory;
this.regexFactory = regexFactory;
this.fileSystem = fileSystem;
try
{
this.logSourceThreads = new LogSourceThreads(this.tracer, threads, this);
this.timeGaps = new TimeGapsDetector(tracer, modelSyncContext, new LogSourceGapsSource(this), traceSourceFactory);
this.timeGaps.OnTimeGapsChanged += timeGaps_OnTimeGapsChanged;
this.logSourceSpecificStorageEntry = CreateLogSourceSpecificStorageEntry(providerFactory, connectionParams, storageManager);
var extendedConnectionParams = connectionParams.Clone(true);
this.LoadPersistedSettings(extendedConnectionParams);
this.provider = providerFactory.CreateFromConnectionParams(this, extendedConnectionParams);
}
catch (Exception e)
{
tracer.Error(e, "Failed to initialize log source");
((ILogSource)this).Dispose();
throw;
}
this.owner.Add(this);
this.owner.FireOnLogSourceAdded(this);
this.LoadBookmarks();
}
public BookmarkController(
IBookmarks bookmarks,
IModelThreads threads,
IHeartBeatTimer heartbeat,
ISynchronizationContext synchronization
)
{
tracer = LJTraceSource.EmptyTracer;
bookmarksPurge = new AsyncInvokeHelper(synchronization, bookmarks.PurgeBookmarksForDisposedThreads);
threads.OnThreadListChanged += (s, e) =>
{
bookmarksPurge.Invoke();
};
bookmarks.OnBookmarksChanged += (sender, e) =>
{
if (e.Type == BookmarksChangedEventArgs.ChangeType.Added || e.Type == BookmarksChangedEventArgs.ChangeType.Removed ||
e.Type == BookmarksChangedEventArgs.ChangeType.RemovedAll || e.Type == BookmarksChangedEventArgs.ChangeType.Purged)
{
foreach (var affectedSource in
e.AffectedBookmarks
.Select(b => b.GetLogSource())
.Where(s => s.LogSourceStateIsOkToChangePersistentState())
.Distinct())
{
try
{
affectedSource.StoreBookmarks();
}
catch (Persistence.StorageException storageException)
{
tracer.Error(storageException, "Failed to store bookmarks for log {0}",
affectedSource.GetSafeConnectionId());
}
}
}
};
}
static DetectedFormat DetectFormat(
string fileName,
string loggableName,
Func <ILogProviderFactory, int> mruIndexGetter,
ILogProviderFactoryRegistry factoriesRegistry,
CancellationToken cancellation,
IFormatAutodetectionProgress progress,
ITempFilesManager tempFilesManager)
{
if (string.IsNullOrEmpty(fileName))
{
throw new ArgumentException("fileName");
}
if (mruIndexGetter == null)
{
throw new ArgumentNullException("mru");
}
Func <SimpleFileMedia> createFileMedia = () => new SimpleFileMedia(SimpleFileMedia.CreateConnectionParamsFromFileName(fileName));
var log = new LJTraceSource("App", string.Format("fdtc.{0}", Interlocked.Increment(ref lastPerfOp)));
using (new Profiling.Operation(log, string.Format("format detection of {0}", loggableName)))
using (ILogSourceThreads threads = new LogSourceThreads())
using (var localCancellation = CancellationTokenSource.CreateLinkedTokenSource(cancellation))
{
var ret = GetOrderedListOfRelevantFactories(fileName, mruIndexGetter, factoriesRegistry).AsParallel().Select(factory =>
{
try
{
using (var perfOp = new Profiling.Operation(log, factory.ToString()))
using (var fileMedia = createFileMedia())
using (var reader = ((IMediaBasedReaderFactory)factory).CreateMessagesReader(
new MediaBasedReaderParams(threads, fileMedia, tempFilesManager, MessagesReaderFlags.QuickFormatDetectionMode, parentLoggingPrefix: log.Prefix)))
{
if (progress != null)
{
progress.Trying(factory);
}
if (localCancellation.IsCancellationRequested)
{
perfOp.Milestone("cancelled");
return(null);
}
reader.UpdateAvailableBounds(false);
perfOp.Milestone("bounds detected");
using (var parser = reader.CreateParser(new CreateParserParams(0, null,
MessagesParserFlag.DisableMultithreading | MessagesParserFlag.DisableDejitter, MessagesParserDirection.Forward)))
{
if (parser.ReadNext() != null)
{
log.Info("Autodetected format of {0}: {1}", fileName, factory);
localCancellation.Cancel();
return(new DetectedFormat(factory, ((IFileBasedLogProviderFactory)factory).CreateParams(fileName)));
}
}
}
}
catch (Exception e)
{
log.Error(e, "Failed to load '{0}' as {1}", fileName, factory);
}
return(null);
}).FirstOrDefault(x => x != null);
if (ret != null)
{
return(ret);
}
using (var fileMedia = createFileMedia())
{
if (!IOUtils.IsBinaryFile(fileMedia.DataStream))
{
log.Info("File does not look binary");
var factory = factoriesRegistry.Find(
PlainText.Factory.CompanyName, PlainText.Factory.FormatName) as IFileBasedLogProviderFactory;
if (factory != null)
{
log.Info("Fall back to plaintext format");
return(new DetectedFormat(factory, factory.CreateParams(fileName)));
}
}
}
}
return(null);
}
public LogSourceThreads(LJTraceSource tracer, IModelThreads modelThreads, ILogSource threadsSource)
{
this.tracer = tracer;
this.modelThreads = modelThreads;
this.logSource = threadsSource;
}
static Form WireupDependenciesAndCreateMainForm()
{
var tracer = new LJTraceSource("App", "app");
using (tracer.NewFrame)
{
ILogProviderFactoryRegistry logProviderFactoryRegistry = new LogProviderFactoryRegistry();
IFormatDefinitionsRepository formatDefinitionsRepository = new DirectoryFormatsRepository(null);
ITempFilesManager tempFilesManager = LogJoint.TempFilesManager.GetInstance();
IUserDefinedFormatsManager userDefinedFormatsManager = new UserDefinedFormatsManager(
formatDefinitionsRepository, logProviderFactoryRegistry, tempFilesManager);
var appInitializer = new AppInitializer(tracer, userDefinedFormatsManager, logProviderFactoryRegistry);
tracer.Info("app initializer created");
var mainForm = new UI.MainForm();
tracer.Info("main form created");
IInvokeSynchronization invokingSynchronization = new InvokeSynchronization(mainForm);
UI.HeartBeatTimer heartBeatTimer = new UI.HeartBeatTimer(mainForm);
UI.Presenters.IViewUpdates viewUpdates = heartBeatTimer;
IFiltersFactory filtersFactory = new FiltersFactory();
IBookmarksFactory bookmarksFactory = new BookmarksFactory();
var bookmarks = bookmarksFactory.CreateBookmarks();
var persistentUserDataFileSystem = Persistence.Implementation.DesktopFileSystemAccess.CreatePersistentUserDataFileSystem();
Persistence.Implementation.IStorageManagerImplementation userDataStorage = new Persistence.Implementation.StorageManagerImplementation();
IShutdown shutdown = new Shutdown();
Persistence.IStorageManager storageManager = new Persistence.PersistentUserDataManager(userDataStorage, shutdown);
Settings.IGlobalSettingsAccessor globalSettingsAccessor = new Settings.GlobalSettingsAccessor(storageManager);
userDataStorage.Init(
new Persistence.Implementation.RealTimingAndThreading(),
persistentUserDataFileSystem,
new Persistence.PersistentUserDataManager.ConfigAccess(globalSettingsAccessor)
);
Persistence.IFirstStartDetector firstStartDetector = persistentUserDataFileSystem;
Persistence.Implementation.IStorageManagerImplementation contentCacheStorage = new Persistence.Implementation.StorageManagerImplementation();
contentCacheStorage.Init(
new Persistence.Implementation.RealTimingAndThreading(),
Persistence.Implementation.DesktopFileSystemAccess.CreateCacheFileSystemAccess(),
new Persistence.ContentCacheManager.ConfigAccess(globalSettingsAccessor)
);
Properties.WebContentConfig webContentConfig = new Properties.WebContentConfig();
Persistence.IContentCache contentCache = new Persistence.ContentCacheManager(contentCacheStorage);
Persistence.IWebContentCache webContentCache = new Persistence.WebContentCache(
contentCache,
webContentConfig
);
MultiInstance.IInstancesCounter instancesCounter = new MultiInstance.InstancesCounter(shutdown);
Progress.IProgressAggregatorFactory progressAggregatorFactory = new Progress.ProgressAggregator.Factory(heartBeatTimer, invokingSynchronization);
Progress.IProgressAggregator progressAggregator = progressAggregatorFactory.CreateProgressAggregator();
IAdjustingColorsGenerator colorGenerator = new AdjustingColorsGenerator(
new PastelColorsGenerator(),
globalSettingsAccessor.Appearance.ColoringBrightness
);
IModelThreads modelThreads = new ModelThreads(colorGenerator);
ILogSourcesManager logSourcesManager = new LogSourcesManager(
heartBeatTimer,
invokingSynchronization,
modelThreads,
tempFilesManager,
storageManager,
bookmarks,
globalSettingsAccessor
);
Telemetry.ITelemetryUploader telemetryUploader =
new Telemetry.ConfiguredAzureTelemetryUploader();
Telemetry.ITelemetryCollector telemetryCollector = new Telemetry.TelemetryCollector(
storageManager,
telemetryUploader,
invokingSynchronization,
instancesCounter,
shutdown,
logSourcesManager,
new MemBufferTraceAccess()
);
tracer.Info("telemetry created");
MRU.IRecentlyUsedEntities recentlyUsedLogs = new MRU.RecentlyUsedEntities(
storageManager,
logProviderFactoryRegistry,
telemetryCollector
);
IFormatAutodetect formatAutodetect = new FormatAutodetect(
recentlyUsedLogs,
logProviderFactoryRegistry,
tempFilesManager
);
Workspaces.IWorkspacesManager workspacesManager = new Workspaces.WorkspacesManager(
logSourcesManager,
logProviderFactoryRegistry,
storageManager,
new Workspaces.Backend.AzureWorkspacesBackend(),
tempFilesManager,
recentlyUsedLogs,
shutdown
);
AppLaunch.ILaunchUrlParser launchUrlParser = new AppLaunch.LaunchUrlParser();
var pluggableProtocolManager = new PluggableProtocolManager(
instancesCounter,
shutdown,
telemetryCollector,
firstStartDetector,
launchUrlParser
);
Preprocessing.IPreprocessingManagerExtensionsRegistry preprocessingManagerExtensionsRegistry =
new Preprocessing.PreprocessingManagerExtentionsRegistry();
Preprocessing.ICredentialsCache preprocessingCredentialsCache = new UI.LogsPreprocessorCredentialsCache(
invokingSynchronization,
storageManager.GlobalSettingsEntry,
mainForm
);
WebBrowserDownloader.IDownloader webBrowserDownloader = new UI.Presenters.WebBrowserDownloader.Presenter(
new LogJoint.UI.WebBrowserDownloader.WebBrowserDownloaderForm(),
invokingSynchronization,
webContentCache,
shutdown
);
Preprocessing.IPreprocessingStepsFactory preprocessingStepsFactory = new Preprocessing.PreprocessingStepsFactory(
workspacesManager,
launchUrlParser,
invokingSynchronization,
preprocessingManagerExtensionsRegistry,
progressAggregator,
webContentCache,
preprocessingCredentialsCache,
logProviderFactoryRegistry,
webBrowserDownloader,
webContentConfig
);
Preprocessing.ILogSourcesPreprocessingManager logSourcesPreprocessings = new Preprocessing.LogSourcesPreprocessingManager(
invokingSynchronization,
formatAutodetect,
preprocessingManagerExtensionsRegistry,
new Preprocessing.BuiltinStepsExtension(preprocessingStepsFactory),
telemetryCollector,
tempFilesManager
);
ISearchManager searchManager = new SearchManager(
logSourcesManager,
progressAggregatorFactory,
invokingSynchronization,
globalSettingsAccessor,
telemetryCollector,
heartBeatTimer
);
IUserDefinedSearches userDefinedSearches = new UserDefinedSearchesManager(storageManager, filtersFactory, invokingSynchronization);
ISearchHistory searchHistory = new SearchHistory(storageManager.GlobalSettingsEntry, userDefinedSearches);
ILogSourcesController logSourcesController = new LogSourcesController(
logSourcesManager,
logSourcesPreprocessings,
recentlyUsedLogs,
shutdown
);
IBookmarksController bookmarksController = new BookmarkController(
bookmarks,
modelThreads,
heartBeatTimer
);
IFiltersManager filtersManager = new FiltersManager(
filtersFactory,
globalSettingsAccessor,
logSourcesManager,
colorGenerator,
shutdown
);
Postprocessing.IUserNamesProvider analyticsShortNames = new Postprocessing.CodenameUserNamesProvider(
logSourcesManager
);
Analytics.TimeSeries.ITimeSeriesTypesAccess timeSeriesTypesAccess = new Analytics.TimeSeries.TimeSeriesTypesLoader();
Postprocessing.IPostprocessorsManager postprocessorsManager = new Postprocessing.PostprocessorsManager(
logSourcesManager,
telemetryCollector,
invokingSynchronization,
heartBeatTimer,
progressAggregator,
null // todo
);
Postprocessing.InternalTracePostprocessors.Register(
postprocessorsManager,
userDefinedFormatsManager
);
tracer.Info("model creation completed");
var presentersFacade = new UI.Presenters.Facade();
UI.Presenters.IPresentersFacade navHandler = presentersFacade;
UI.Presenters.IClipboardAccess clipboardAccess = new ClipboardAccess(telemetryCollector);
UI.Presenters.IShellOpen shellOpen = new ShellOpen();
UI.Presenters.LogViewer.IPresenterFactory logViewerPresenterFactory = new UI.Presenters.LogViewer.PresenterFactory(
heartBeatTimer,
presentersFacade,
clipboardAccess,
bookmarksFactory,
telemetryCollector,
logSourcesManager,
invokingSynchronization,
modelThreads,
filtersManager.HighlightFilters,
bookmarks,
globalSettingsAccessor,
searchManager,
filtersFactory
);
UI.Presenters.LoadedMessages.IView loadedMessagesView = mainForm.loadedMessagesControl;
UI.Presenters.LoadedMessages.IPresenter loadedMessagesPresenter = new UI.Presenters.LoadedMessages.Presenter(
logSourcesManager,
bookmarks,
loadedMessagesView,
heartBeatTimer,
logViewerPresenterFactory
);
UI.Presenters.LogViewer.IPresenter viewerPresenter = loadedMessagesPresenter.LogViewerPresenter;
UI.Presenters.ITabUsageTracker tabUsageTracker = new UI.Presenters.TabUsageTracker();
UI.Presenters.StatusReports.IPresenter statusReportsPresenter = new UI.Presenters.StatusReports.Presenter(
new UI.StatusReportView(
mainForm,
mainForm.toolStripStatusLabel,
mainForm.cancelLongRunningProcessDropDownButton,
mainForm.cancelLongRunningProcessLabel
),
heartBeatTimer
);
UI.Presenters.StatusReports.IPresenter statusReportFactory = statusReportsPresenter;
UI.Presenters.Timeline.IPresenter timelinePresenter = new UI.Presenters.Timeline.Presenter(
logSourcesManager,
logSourcesPreprocessings,
searchManager,
bookmarks,
mainForm.timeLinePanel.TimelineControl,
viewerPresenter,
statusReportFactory,
tabUsageTracker,
heartBeatTimer);
UI.Presenters.TimelinePanel.IPresenter timelinePanelPresenter = new UI.Presenters.TimelinePanel.Presenter(
logSourcesManager,
bookmarks,
mainForm.timeLinePanel,
timelinePresenter,
heartBeatTimer);
UI.Presenters.SearchResult.IPresenter searchResultPresenter = new UI.Presenters.SearchResult.Presenter(
searchManager,
bookmarks,
filtersManager.HighlightFilters,
mainForm.searchResultView,
navHandler,
loadedMessagesPresenter,
heartBeatTimer,
invokingSynchronization,
statusReportFactory,
logViewerPresenterFactory
);
UI.Presenters.ThreadsList.IPresenter threadsListPresenter = new UI.Presenters.ThreadsList.Presenter(
modelThreads,
logSourcesManager,
mainForm.threadsListView,
viewerPresenter,
navHandler,
viewUpdates,
heartBeatTimer);
tracer.Info("threads list presenter created");
var dialogs = new Alerts();
UI.Presenters.IAlertPopup alertPopup = dialogs;
UI.Presenters.IFileDialogs fileDialogs = dialogs;
UI.Presenters.SearchEditorDialog.IPresenter searchEditorDialog = new UI.Presenters.SearchEditorDialog.Presenter(
new SearchEditorDialogView(),
userDefinedSearches,
(filtersList, dialogView) =>
{
UI.Presenters.FilterDialog.IPresenter filterDialogPresenter = new UI.Presenters.FilterDialog.Presenter(
null,
filtersList,
new UI.FilterDialogView()
);
return(new UI.Presenters.FiltersManager.Presenter(
filtersList,
dialogView.FiltersManagerView,
new UI.Presenters.FiltersListBox.Presenter(
filtersList,
dialogView.FiltersManagerView.FiltersListView,
filterDialogPresenter
),
filterDialogPresenter,
null,
viewUpdates,
heartBeatTimer,
filtersFactory,
alertPopup
));
},
alertPopup
);
UI.Presenters.SearchesManagerDialog.IPresenter searchesManagerDialogPresenter = new UI.Presenters.SearchesManagerDialog.Presenter(
new UI.SearchesManagerDialogView(),
userDefinedSearches,
alertPopup,
fileDialogs,
searchEditorDialog
);
UI.Presenters.SearchPanel.IPresenter searchPanelPresenter = new UI.Presenters.SearchPanel.Presenter(
mainForm.searchPanelView,
searchManager,
searchHistory,
userDefinedSearches,
logSourcesManager,
filtersFactory,
new UI.SearchResultsPanelView()
{
container = mainForm.splitContainer_Log_SearchResults
},
loadedMessagesPresenter,
searchResultPresenter,
statusReportFactory,
searchEditorDialog,
searchesManagerDialogPresenter,
alertPopup
);
tracer.Info("search panel presenter created");
UI.Presenters.SourcePropertiesWindow.IPresenter sourcePropertiesWindowPresenter =
new UI.Presenters.SourcePropertiesWindow.Presenter(
new UI.SourceDetailsWindowView(),
logSourcesManager,
logSourcesPreprocessings,
navHandler,
alertPopup,
clipboardAccess,
shellOpen
);
UI.Presenters.SourcesList.IPresenter sourcesListPresenter = new UI.Presenters.SourcesList.Presenter(
logSourcesManager,
mainForm.sourcesListView.SourcesListView,
logSourcesPreprocessings,
sourcePropertiesWindowPresenter,
viewerPresenter,
navHandler,
alertPopup,
fileDialogs,
clipboardAccess,
shellOpen
);
UI.LogsPreprocessorUI logsPreprocessorUI = new UI.LogsPreprocessorUI(
logSourcesPreprocessings,
mainForm,
statusReportsPresenter);
UI.Presenters.Help.IPresenter helpPresenter = new UI.Presenters.Help.Presenter(shellOpen);
AppLaunch.ICommandLineHandler commandLineHandler = new AppLaunch.CommandLineHandler(
logSourcesPreprocessings,
preprocessingStepsFactory);
UI.Presenters.SharingDialog.IPresenter sharingDialogPresenter = new UI.Presenters.SharingDialog.Presenter(
logSourcesManager,
workspacesManager,
logSourcesPreprocessings,
alertPopup,
clipboardAccess,
new UI.ShareDialog()
);
UI.Presenters.HistoryDialog.IView historyDialogView = new UI.HistoryDialog();
UI.Presenters.HistoryDialog.IPresenter historyDialogPresenter = new UI.Presenters.HistoryDialog.Presenter(
logSourcesController,
historyDialogView,
logSourcesPreprocessings,
preprocessingStepsFactory,
recentlyUsedLogs,
new UI.Presenters.QuickSearchTextBox.Presenter(historyDialogView.QuickSearchTextBox),
alertPopup
);
UI.Presenters.NewLogSourceDialog.IPagePresentersRegistry newLogPagesPresentersRegistry =
new UI.Presenters.NewLogSourceDialog.PagePresentersRegistry();
UI.Presenters.NewLogSourceDialog.IPresenter newLogSourceDialogPresenter = new UI.Presenters.NewLogSourceDialog.Presenter(
logProviderFactoryRegistry,
newLogPagesPresentersRegistry,
recentlyUsedLogs,
new UI.NewLogSourceDialogView(),
userDefinedFormatsManager,
() => new UI.Presenters.NewLogSourceDialog.Pages.FormatDetection.Presenter(
new UI.Presenters.NewLogSourceDialog.Pages.FormatDetection.AnyLogFormatUI(),
logSourcesPreprocessings,
preprocessingStepsFactory
),
new UI.Presenters.FormatsWizard.Presenter(
new UI.Presenters.FormatsWizard.ObjectsFactory(
alertPopup,
fileDialogs,
helpPresenter,
logProviderFactoryRegistry,
formatDefinitionsRepository,
userDefinedFormatsManager,
tempFilesManager,
logViewerPresenterFactory,
new UI.Presenters.FormatsWizard.ObjectsFactory.ViewFactories()
{
CreateFormatsWizardView = () => new ManageFormatsWizard(),
CreateChooseOperationPageView = () => new ChooseOperationPage(),
CreateImportLog4NetPagePageView = () => new ImportLog4NetPage(),
CreateFormatIdentityPageView = () => new FormatIdentityPage(),
CreateFormatAdditionalOptionsPage = () => new FormatAdditionalOptionsPage(),
CreateSaveFormatPageView = () => new SaveFormatPage(),
CreateImportNLogPage = () => new ImportNLogPage(),
CreateNLogGenerationLogPageView = () => new NLogGenerationLogPage(),
CreateChooseExistingFormatPageView = () => new ChooseExistingFormatPage(),
CreateFormatDeleteConfirmPageView = () => new FormatDeleteConfirmPage(),
CreateRegexBasedFormatPageView = () => new RegexBasedFormatPage(),
CreateEditSampleDialogView = () => new EditSampleLogForm(),
CreateTestDialogView = () => new TestParserForm(),
CreateEditRegexDialog = () => new EditRegexForm(),
CreateEditFieldsMappingDialog = () => new FieldsMappingForm(),
CreateXmlBasedFormatPageView = () => new XmlBasedFormatPage(),
CreateXsltEditorDialog = () => new EditXsltForm(),
}
)
)
);
newLogPagesPresentersRegistry.RegisterPagePresenterFactory(
StdProviderFactoryUIs.FileBasedProviderUIKey,
f => new UI.Presenters.NewLogSourceDialog.Pages.FileBasedFormat.Presenter(
new UI.Presenters.NewLogSourceDialog.Pages.FileBasedFormat.FileLogFactoryUI(),
(IFileBasedLogProviderFactory)f,
logSourcesController,
alertPopup,
fileDialogs
)
);
newLogPagesPresentersRegistry.RegisterPagePresenterFactory(
StdProviderFactoryUIs.DebugOutputProviderUIKey,
f => new UI.Presenters.NewLogSourceDialog.Pages.DebugOutput.Presenter(
new UI.Presenters.NewLogSourceDialog.Pages.DebugOutput.DebugOutputFactoryUI(),
f,
logSourcesController
)
);
newLogPagesPresentersRegistry.RegisterPagePresenterFactory(
StdProviderFactoryUIs.WindowsEventLogProviderUIKey,
f => new UI.Presenters.NewLogSourceDialog.Pages.WindowsEventsLog.Presenter(
new UI.Presenters.NewLogSourceDialog.Pages.WindowsEventsLog.EVTFactoryUI(),
f,
logSourcesController
)
);
UI.Presenters.SourcesManager.IPresenter sourcesManagerPresenter = new UI.Presenters.SourcesManager.Presenter(
logSourcesManager,
userDefinedFormatsManager,
recentlyUsedLogs,
logSourcesPreprocessings,
logSourcesController,
mainForm.sourcesListView,
preprocessingStepsFactory,
workspacesManager,
sourcesListPresenter,
newLogSourceDialogPresenter,
heartBeatTimer,
sharingDialogPresenter,
historyDialogPresenter,
presentersFacade,
sourcePropertiesWindowPresenter,
alertPopup
);
UI.Presenters.MessagePropertiesDialog.IPresenter messagePropertiesDialogPresenter = new UI.Presenters.MessagePropertiesDialog.Presenter(
bookmarks,
filtersManager.HighlightFilters,
new MessagePropertiesDialogView(mainForm),
viewerPresenter,
navHandler);
Func <IFiltersList, UI.Presenters.FiltersManager.IView, UI.Presenters.FiltersManager.IPresenter> createFiltersManager = (filters, view) =>
{
var dialogPresenter = new UI.Presenters.FilterDialog.Presenter(logSourcesManager, filters, new UI.FilterDialogView());
UI.Presenters.FiltersListBox.IPresenter listPresenter = new UI.Presenters.FiltersListBox.Presenter(filters, view.FiltersListView, dialogPresenter);
UI.Presenters.FiltersManager.IPresenter managerPresenter = new UI.Presenters.FiltersManager.Presenter(
filters,
view,
listPresenter,
dialogPresenter,
viewerPresenter,
viewUpdates,
heartBeatTimer,
filtersFactory,
alertPopup
);
return(managerPresenter);
};
UI.Presenters.FiltersManager.IPresenter hlFiltersManagerPresenter = createFiltersManager(
filtersManager.HighlightFilters,
mainForm.hlFiltersManagementView);
UI.Presenters.BookmarksList.IPresenter bookmarksListPresenter = new UI.Presenters.BookmarksList.Presenter(
bookmarks,
logSourcesManager,
mainForm.bookmarksManagerView.ListView,
heartBeatTimer,
loadedMessagesPresenter,
clipboardAccess);
UI.Presenters.BookmarksManager.IPresenter bookmarksManagerPresenter = new UI.Presenters.BookmarksManager.Presenter(
bookmarks,
mainForm.bookmarksManagerView,
viewerPresenter,
searchResultPresenter,
bookmarksListPresenter,
statusReportFactory,
navHandler,
viewUpdates,
alertPopup
);
AutoUpdate.IAutoUpdater autoUpdater = new AutoUpdate.AutoUpdater(
instancesCounter,
new AutoUpdate.ConfiguredAzureUpdateDownloader(),
tempFilesManager,
shutdown,
invokingSynchronization,
firstStartDetector,
telemetryCollector,
storageManager
);
var unhandledExceptionsReporter = new Telemetry.WinFormsUnhandledExceptionsReporter(
telemetryCollector
);
UI.Presenters.Options.Dialog.IPresenter optionsDialogPresenter = new UI.Presenters.Options.Dialog.Presenter(
new OptionsDialogView(),
pageView => new UI.Presenters.Options.MemAndPerformancePage.Presenter(globalSettingsAccessor, recentlyUsedLogs, searchHistory, pageView),
pageView => new UI.Presenters.Options.Appearance.Presenter(globalSettingsAccessor, pageView, logViewerPresenterFactory),
pageView => new UI.Presenters.Options.UpdatesAndFeedback.Presenter(autoUpdater, globalSettingsAccessor, pageView)
);
DragDropHandler dragDropHandler = new DragDropHandler(
logSourcesController,
logSourcesPreprocessings,
preprocessingStepsFactory
);
UI.Presenters.About.IPresenter aboutDialogPresenter = new UI.Presenters.About.Presenter(
new AboutBox(),
new AboutDialogConfig(),
clipboardAccess,
autoUpdater
);
UI.Presenters.TimestampAnomalyNotification.IPresenter timestampAnomalyNotificationPresenter = new UI.Presenters.TimestampAnomalyNotification.Presenter(
logSourcesManager,
logSourcesPreprocessings,
invokingSynchronization,
heartBeatTimer,
presentersFacade,
statusReportsPresenter
);
UI.Presenters.IPromptDialog promptDialog = new UI.PromptDialog.Presenter();
UI.Presenters.IssueReportDialogPresenter.IPresenter issueReportDialogPresenter =
new UI.Presenters.IssueReportDialogPresenter.Presenter(telemetryCollector, telemetryUploader, promptDialog);
UI.Presenters.MainForm.IPresenter mainFormPresenter = new UI.Presenters.MainForm.Presenter(
logSourcesManager,
logSourcesPreprocessings,
mainForm,
viewerPresenter,
searchResultPresenter,
searchPanelPresenter,
sourcesListPresenter,
sourcesManagerPresenter,
messagePropertiesDialogPresenter,
loadedMessagesPresenter,
bookmarksManagerPresenter,
heartBeatTimer,
tabUsageTracker,
statusReportFactory,
dragDropHandler,
navHandler,
autoUpdater,
progressAggregator,
alertPopup,
sharingDialogPresenter,
issueReportDialogPresenter,
shutdown
);
tracer.Info("main form presenter created");
var postprocessingViewsFactory = new UI.Postprocessing.PostprocessorOutputFormFactory();
UI.Presenters.Postprocessing.MainWindowTabPage.IView postprocessingTabPage = new UI.Postprocessing.MainWindowTabPage.TabPage(
mainFormPresenter
);
UI.Presenters.Postprocessing.MainWindowTabPage.IPresenter postprocessingTabPagePresenter = new UI.Presenters.Postprocessing.MainWindowTabPage.PluginTabPagePresenter(
postprocessingTabPage,
postprocessorsManager,
postprocessingViewsFactory,
logSourcesManager,
tempFilesManager,
shellOpen,
newLogSourceDialogPresenter,
telemetryCollector
);
Postprocessing.IAggregatingLogSourceNamesProvider logSourceNamesProvider = new Postprocessing.AggregatingLogSourceNamesProvider();
Extensibility.IApplication pluginEntryPoint = new Extensibility.Application(
new Extensibility.Model(
invokingSynchronization,
telemetryCollector,
webContentCache,
contentCache,
storageManager,
bookmarks,
logSourcesManager,
modelThreads,
tempFilesManager,
preprocessingManagerExtensionsRegistry,
logSourcesPreprocessings,
preprocessingStepsFactory,
progressAggregator,
logProviderFactoryRegistry,
userDefinedFormatsManager,
recentlyUsedLogs,
progressAggregatorFactory,
heartBeatTimer,
logSourcesController,
shutdown,
webBrowserDownloader,
commandLineHandler,
postprocessorsManager,
analyticsShortNames,
timeSeriesTypesAccess,
logSourceNamesProvider
),
new Extensibility.Presentation(
loadedMessagesPresenter,
clipboardAccess,
presentersFacade,
sourcesManagerPresenter,
newLogSourceDialogPresenter,
shellOpen,
alertPopup,
promptDialog,
mainFormPresenter,
postprocessingTabPagePresenter,
postprocessingViewsFactory
),
new Extensibility.View(
mainForm
)
);
var pluginsManager = new Extensibility.PluginsManager(
pluginEntryPoint,
mainFormPresenter,
telemetryCollector,
shutdown
);
tracer.Info("plugin manager created");
appInitializer.WireUpCommandLineHandler(mainFormPresenter, commandLineHandler);
postprocessingViewsFactory.Init(pluginEntryPoint);
presentersFacade.Init(
messagePropertiesDialogPresenter,
threadsListPresenter,
sourcesListPresenter,
bookmarksManagerPresenter,
mainFormPresenter,
aboutDialogPresenter,
optionsDialogPresenter,
historyDialogPresenter
);
return(mainForm);
}
}
public AutoFrame(LJTraceSource owner)
{
this.owner = owner;
}
