public RunInitializationResult Initialize(RunInitializationRequest request)
{
if (request.Target.Type != LogsetTarget.File && request.Target.Type != LogsetTarget.Directory)
{
throw new ArgumentException("Request target must be a file or directory!", "request");
}
ExtractionResult extractionResult = ExtractLogset(request.Target, request.RunId);
var artifactProcessorLoader = new ArchiveArtifactProcessorLoader();
IArtifactProcessor artifactProcessor = artifactProcessorLoader.LoadArtifactProcessor(extractionResult.RootLogDirectory);
string logsetHash = ComputeLogsetHash(extractionResult.RootLogDirectory, artifactProcessor);
var pluginLoader = new PluginLoader(request.ArtifactProcessorOptions);
ISet <Type> pluginsToExecute = pluginLoader.LoadPlugins(request.RequestedPlugins, artifactProcessor);
var extractedTarget = new LogsharkRequestTarget(extractionResult.RootLogDirectory);
ISet <string> collectionDependencies;
if (request.ParseFullLogset)
{
collectionDependencies = GetAllSupportedCollections(artifactProcessor, extractionResult.RootLogDirectory);
}
else
{
collectionDependencies = pluginLoader.GetCollectionDependencies(pluginsToExecute);
}
return(new RunInitializationResult(extractedTarget, artifactProcessor, collectionDependencies, logsetHash, pluginsToExecute));
}
public RunInitializationRequest(LogsharkRequestTarget target, string runId, ISet <string> requestedPlugins, bool parseFullLogset, LogsharkArtifactProcessorOptions artifactProcessorOptions)
{
Target = target;
RunId = runId;
RequestedPlugins = requestedPlugins;
ParseFullLogset = parseFullLogset;
ArtifactProcessorOptions = artifactProcessorOptions;
}
public RunInitializationResult(LogsharkRequestTarget target, IArtifactProcessor artifactProcessor, ISet <string> collectionsRequested, string logsetHash, ISet <Type> pluginsToExecute)
{
Target = target;
ArtifactProcessor = artifactProcessor;
ArtifactProcessorVersion = artifactProcessor.GetType().Assembly.GetName().Version;
CollectionsRequested = collectionsRequested;
CollectionsRequested.UnionWith(artifactProcessor.RequiredCollections);
LogsetHash = logsetHash;
PluginTypesToExecute = pluginsToExecute;
}
protected string PrepareLogsetLocation(LogsharkRequestTarget target, string runTempDirectory, ISet <Regex> fileWhitelist)
{
// If target is a directory and/or exists on a remote drive, make a local copy to avoid
// destructive operations on the original & possibly improve extraction speed.
if (target.Type == LogsetTarget.Directory || !PathHelper.ExistsOnLocalDrive(target))
{
var logsetCopier = new LogsetCopier(fileWhitelist);
return(logsetCopier.CopyLogset(target, runTempDirectory));
}
return(target);
}
protected ExtractionResult ExtractLogset(LogsharkRequestTarget target, string runId)
{
string runTempDirectory = GetRunTempDirectory(runId);
ISet <Regex> extractionWhitelist = BuildExtractionWhitelist();
string logsetLocation = PrepareLogsetLocation(target, runTempDirectory, extractionWhitelist);
var extractor = new LogsetExtractor(extractionWhitelist);
return(extractor.Extract(logsetLocation, runTempDirectory));
}
private ExtractionResult ExtractLogset(LogsharkRequestTarget target)
{
var runTempDirectory = GetRunTempDirectory();
var extractionWhitelist = BuildExtractionWhitelist();
var logsetLocation = PrepareLogsetLocation(target, runTempDirectory, extractionWhitelist);
var extractor = new LogsetExtractor(extractionWhitelist);
return(extractor.Extract(logsetLocation, runTempDirectory));
}
/// <summary>
/// Computes a unique hash for the target logset.
/// </summary>
public static string ComputeLogsetHash(LogsharkRequestTarget target)
{
if (target.IsHashId)
{
return(target);
}
Log.Info("Computing Logset Hash..");
string logsetHash = LogsetHashUtil.GetLogSetHash(target);
Log.InfoFormat("Logset hash is '{0}'.", logsetHash);
return(logsetHash);
}
public static IRunInitializer GetRunInitializer(LogsharkRequestTarget target, LogsharkConfiguration config)
{
switch (target.Type)
{
case LogsetTarget.File:
case LogsetTarget.Directory:
return(new ArchiveRunInitializer(config.ApplicationTempDirectory));
case LogsetTarget.Hash:
return(new HashRunInitializer(config.MongoConnectionInfo));
default:
throw new ArgumentException($"Cannot get run initializer for unknown target type '{target.Type}'", nameof(target));
}
}
public static ILogsetProcessingStrategy GetLogsetProcessingStrategy(LogsharkRequestTarget target, Func <LogsetParsingRequest, LogsetParsingResult> parseLogset, Action <string> dropExistingLogset, LogsharkConfiguration config)
{
switch (target.Type)
{
case LogsetTarget.File:
case LogsetTarget.Directory:
return(new ArchiveTargetProcessingStrategy(parseLogset, dropExistingLogset, config));
case LogsetTarget.Hash:
return(new HashTargetProcessingStrategy());
default:
throw new ArgumentException(String.Format("Cannot get run processing strategy for unknown target type '{0}'", target.Type), "target");
}
}
public void InitializeFile(string archiveName)
{
var target = new LogsharkRequestTarget(TestDataHelper.GetResourcePath(archiveName));
var runId = "test_" + DateTime.Now.ToString("yyMMddHHmmssff");
var config = ControllerEntityHelper.GetMockConfiguration();
var initializationRequest = new RunInitializationRequest(target, runId, new HashSet <string> {
"default"
}, false, config.ArtifactProcessorOptions);
var archiveRunInitializer = new ArchiveRunInitializer(config.ApplicationTempDirectory);
var initializationResult = archiveRunInitializer.Initialize(initializationRequest);
initializationResult.Target.Should().NotBeNull();
PathHelper.IsDirectory(initializationResult.Target).Should().BeTrue();
initializationResult.ArtifactProcessor.Should().NotBeNull();
initializationResult.ArtifactProcessor.ArtifactType.Should().Be("Desktop", "Input is a fake Desktop logset");
initializationResult.ArtifactProcessorVersion.Should().NotBeNull();
initializationResult.LogsetHash.Should().NotBeNull();
}
