private void ScanDirectory(string traceDirectory, Config config)
{
logger.Debug("Scanning trace directory {traceDirectory}", traceDirectory);
TraceFileScanner scanner = new TraceFileScanner(traceDirectory, fileSystem);
Archive archive = new Archive(traceDirectory, fileSystem, new DefaultDateTimeProvider());
LineCoverageMerger coverageMerger = new LineCoverageMerger();
IEnumerable <TraceFile> traces = scanner.ListTraceFilesReadyForUpload();
foreach (TraceFile trace in traces)
{
try
{
ProcessTraceFile(trace, archive, config, coverageMerger);
}
catch (Exception e)
{
logger.Error(e, "Failed to process trace file {trace}. Will retry later", trace.FilePath);
}
}
UploadMergedCoverage(archive, coverageMerger, config);
logger.Debug("Finished scan");
}
private static void UploadMergedCoverage(Archive archive, LineCoverageMerger coverageMerger, Config config)
{
IEnumerable <LineCoverageMerger.CoverageBatch> batches = coverageMerger.GetBatches();
if (batches.Count() == 0)
{
logger.Debug("Skipping upload of merged coverage since none was recorded");
return;
}
logger.Debug("Uploading line coverage of {count} batches", batches.Count());
foreach (LineCoverageMerger.CoverageBatch batch in batches)
{
UploadCoverageBatch(archive, config, batch);
}
}
private void ProcessLineCoverage(TraceFile trace, Archive archive, Config config, Config.ConfigForProcess processConfig, IUpload upload, LineCoverageMerger coverageMerger)
{
logger.Debug("Preparing line coverage from {traceFile} for {upload}", trace.FilePath, upload.Describe());
RevisionFileUtils.RevisionOrTimestamp timestampOrRevision = ParseRevisionFile(trace, processConfig);
Dictionary <string, FileCoverage> lineCoverage = ConvertTraceFileToLineCoverage(trace, archive, processConfig);
if (timestampOrRevision == null || lineCoverage == null)
{
return;
}
if (config.ArchiveLineCoverage)
{
archive.ArchiveLineCoverage(Path.GetFileName(trace.FilePath) + ".simple",
LineCoverageSynthesizer.ConvertToLineCoverageReport(lineCoverage));
}
if (processConfig.MergeLineCoverage)
{
logger.Debug("Merging line coverage from {traceFile} into previous line coverage", trace.FilePath);
coverageMerger.AddLineCoverage(trace.FilePath, timestampOrRevision, upload, lineCoverage);
return;
}
logger.Debug("Uploading line coverage from {traceFile} to {upload}", trace.FilePath, upload.Describe());
string report = LineCoverageSynthesizer.ConvertToLineCoverageReport(lineCoverage);
if (RunSync(upload.UploadLineCoverageAsync(trace.FilePath, report, timestampOrRevision)))
{
archive.ArchiveUploadedFile(trace.FilePath);
}
else
{
logger.Error("Failed to upload line coverage from {traceFile} to {upload}. Will retry later", trace.FilePath, upload.Describe());
}
}
private void ProcessTraceFile(TraceFile trace, Archive archive, Config config, LineCoverageMerger coverageMerger)
{
if (trace.IsEmpty())
{
logger.Info("Archiving {trace} because it does not contain any coverage", trace.FilePath);
archive.ArchiveEmptyFile(trace.FilePath);
return;
}
string processPath = trace.FindProcessPath();
if (processPath == null)
{
logger.Info("Archiving {trace} because it does not contain a Process= line", trace.FilePath);
archive.ArchiveFileWithoutProcess(trace.FilePath);
return;
}
Config.ConfigForProcess processConfig = config.CreateConfigForProcess(processPath);
IUpload upload = uploadFactory.CreateUpload(processConfig, fileSystem);
if (processConfig.PdbDirectory == null)
{
ProcessMethodCoverage(trace, archive, processConfig, upload);
}
else
{
ProcessLineCoverage(trace, archive, config, processConfig, upload, coverageMerger);
}
}
