private static void ProcessMethodCoverage(TraceFile trace, Archive archive, Config.ConfigForProcess processConfig, IUpload upload)
{
string version = trace.FindVersion(processConfig.VersionAssembly);
if (version == null)
{
logger.Info("Archiving {trace} because it does not contain the version assembly {versionAssembly}",
trace.FilePath, processConfig.VersionAssembly);
archive.ArchiveFileWithoutVersionAssembly(trace.FilePath);
return;
}
string prefixedVersion = processConfig.VersionPrefix + version;
logger.Info("Uploading {trace} to {upload} with version {version}", trace.FilePath, upload.Describe(), prefixedVersion);
if (RunSync(upload.UploadAsync(trace.FilePath, prefixedVersion)))
{
archive.ArchiveUploadedFile(trace.FilePath);
}
else
{
logger.Error("Upload of {trace} to {upload} failed. 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);
}
}
public IUpload CreateUpload(Config.ConfigForProcess config, IFileSystem fileSystem)
{
if (config.Teamscale != null)
{
return(new TeamscaleUpload(config.Teamscale));
}
if (config.AzureFileStorage != null)
{
return(new AzureUpload(config.AzureFileStorage));
}
return(new FileSystemUpload(config.Directory, fileSystem));
}
/// <summary>
/// Tries to read and convert the trace file. Logs and returns null if this fails.
/// Empty trace files are archived and null is returned as well.
/// </summary>
private Dictionary <string, FileCoverage> ConvertTraceFileToLineCoverage(TraceFile trace, Archive archive, Config.ConfigForProcess processConfig)
{
ParsedTraceFile parsedTraceFile = new ParsedTraceFile(trace.Lines, trace.FilePath);
Dictionary <string, FileCoverage> lineCoverage;
try
{
lineCoverage = lineCoverageSynthesizer.ConvertToLineCoverage(parsedTraceFile, processConfig.PdbDirectory, processConfig.AssemblyPatterns);
}
catch (Exception e)
{
logger.Error(e, "Failed to convert {traceFile} to line coverage. Will retry later", trace.FilePath);
return(null);
}
if (lineCoverage == null)
{
logger.Info("Archiving {trace} because it did not produce any line coverage after conversion", trace.FilePath);
archive.ArchiveFileWithoutLineCoverage(trace.FilePath);
return(null);
}
return(lineCoverage);
}
/// <summary>
/// Tries to read the revision file based on the config. Logs and returns null if this fails.
/// </summary>
private RevisionFileUtils.RevisionOrTimestamp ParseRevisionFile(TraceFile trace, Config.ConfigForProcess processConfig)
{
try
{
return(RevisionFileUtils.Parse(fileSystem.File.ReadAllLines(processConfig.RevisionFile), processConfig.RevisionFile));
}
catch (Exception e)
{
logger.Error(e, "Failed to read revision file {revisionFile} while processing {traceFile}. Will retry later",
processConfig.RevisionFile, trace.FilePath);
return(null);
}
}
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());
}
}
/// <inheritdoc/>
public IUpload CreateUpload(Config.ConfigForProcess config, IFileSystem fileSystem)
{
return(uploadMock.Object);
}
