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); }