private void InitializeOutputFile(TOptions analyzeOptions, TContext context, ISet <string> targets)
{
string filePath = analyzeOptions.OutputFilePath;
AggregatingLogger aggregatingLogger = (AggregatingLogger)context.Logger;
if (!string.IsNullOrEmpty(filePath))
{
InvokeCatchingRelevantIOExceptions
(
() =>
{
LogFilePersistenceOptions logFilePersistenceOptions = analyzeOptions.ConvertToLogFilePersistenceOptions();
OptionallyEmittedData dataToInsert = analyzeOptions.DataToInsert.ToFlags();
OptionallyEmittedData dataToRemove = analyzeOptions.DataToRemove.ToFlags();
SarifLogger sarifLogger;
if (analyzeOptions.SarifOutputVersion != SarifVersion.OneZeroZero)
{
sarifLogger = new SarifLogger(
analyzeOptions.OutputFilePath,
logFilePersistenceOptions,
dataToInsert,
dataToRemove,
tool: _tool,
run: null,
analysisTargets: targets,
invocationTokensToRedact: GenerateSensitiveTokensList(),
invocationPropertiesToLog: analyzeOptions.InvocationPropertiesToLog,
levels: analyzeOptions.Level,
kinds: analyzeOptions.Kind);
}
else
{
sarifLogger = new SarifOneZeroZeroLogger(
analyzeOptions.OutputFilePath,
logFilePersistenceOptions,
dataToInsert,
dataToRemove,
tool: _tool,
run: null,
analysisTargets: targets,
invocationTokensToRedact: GenerateSensitiveTokensList(),
invocationPropertiesToLog: analyzeOptions.InvocationPropertiesToLog,
levels: analyzeOptions.Level,
kinds: analyzeOptions.Kind);
}
_pathToHashDataMap = sarifLogger.AnalysisTargetToHashDataMap;
sarifLogger.AnalysisStarted();
aggregatingLogger.Loggers.Add(sarifLogger);
},
(ex) =>
{
Errors.LogExceptionCreatingLogFile(context, filePath, ex);
ThrowExitApplicationException(context, ExitReason.ExceptionCreatingLogFile, ex);
}
);
}
}
/// <summary>Converts a tool log file into the SARIF format.</summary>
/// <exception cref="ArgumentNullException">Thrown when one or more required arguments are null.</exception>
/// <exception cref="ArgumentException">Thrown when one or more arguments have unsupported or
/// illegal values.</exception>
/// <exception cref="InvalidOperationException">Thrown when the requested operation is invalid.</exception>
/// <param name="toolFormat">The tool format of the input file.</param>
/// <param name="inputFileName">The input log file name.</param>
/// <param name="outputFileName">The name of the file to which the resulting SARIF log shall be
/// written. This cannot be a directory.</param>
/// <param name="conversionOptions">Options for controlling the conversion.</param>
/// <param name="pluginAssemblyPath">Path to plugin assembly containing converter types.</param>
public void ConvertToStandardFormat(
string toolFormat,
string inputFileName,
string outputFileName,
LogFilePersistenceOptions logFilePersistenceOptions = LogFilePersistenceOptions.None,
OptionallyEmittedData dataToInsert = OptionallyEmittedData.None,
string pluginAssemblyPath = null)
{
if (inputFileName == null)
{
throw new ArgumentNullException(nameof(inputFileName));
}
if (outputFileName == null)
{
throw new ArgumentNullException(nameof(outputFileName));
}
// FileMode settings here will results in an exception being raised if the input
// file does not exist, and that an existing output file will be overwritten
using (FileStream input = File.OpenRead(inputFileName))
using (FileStream outputTextStream = File.Create(outputFileName))
using (var outputTextWriter = new StreamWriter(outputTextStream))
using (var outputJson = new JsonTextWriter(outputTextWriter))
{
if (logFilePersistenceOptions.HasFlag(LogFilePersistenceOptions.PrettyPrint))
{
outputJson.Formatting = Formatting.Indented;
}
using (var output = new ResultLogJsonWriter(outputJson))
{
ConvertToStandardFormat(toolFormat, input, output, dataToInsert, pluginAssemblyPath);
}
}
}
public SarifOneZeroZeroLogger(
string outputFilePath,
LogFilePersistenceOptions logFilePersistenceOptions = SarifLogger.DefaultLogFilePersistenceOptions,
OptionallyEmittedData dataToInsert = OptionallyEmittedData.None,
OptionallyEmittedData dataToRemove = OptionallyEmittedData.None,
Tool tool = null,
Run run = null,
IEnumerable <string> analysisTargets = null,
IEnumerable <string> invocationTokensToRedact = null,
IEnumerable <string> invocationPropertiesToLog = null,
string defaultFileEncoding = null,
IEnumerable <FailureLevel> levels = null,
IEnumerable <ResultKind> kinds = null)
: base(new StreamWriter(new FileStream(outputFilePath, FileMode.Create, FileAccess.Write, FileShare.None)),
logFilePersistenceOptions: logFilePersistenceOptions,
dataToInsert: dataToInsert,
dataToRemove: dataToRemove,
defaultFileEncoding: defaultFileEncoding,
tool: tool,
run: run,
analysisTargets: analysisTargets,
invocationTokensToRedact: invocationTokensToRedact,
invocationPropertiesToLog: invocationPropertiesToLog,
levels: levels,
kinds: kinds)
{
_outputFilePath = outputFilePath;
}
private SarifLogger(
TextWriter textWriter,
LogFilePersistenceOptions logFilePersistenceOptions,
bool closeWriterOnDipose,
IEnumerable <FailureLevel> levels,
IEnumerable <ResultKind> kinds) : base(failureLevels: levels, resultKinds: kinds)
{
_textWriter = textWriter;
_closeWriterOnDispose = closeWriterOnDipose;
_jsonTextWriter = new JsonTextWriter(_textWriter);
_logFilePersistenceOptions = logFilePersistenceOptions;
if (PrettyPrint)
{
// Indented output is preferable for debugging
_jsonTextWriter.Formatting = Newtonsoft.Json.Formatting.Indented;
}
_jsonTextWriter.DateFormatString = DateTimeConverter.DateTimeFormat;
_jsonTextWriter.CloseOutput = _closeWriterOnDispose;
_issueLogJsonWriter = new ResultLogJsonWriter(_jsonTextWriter);
RuleToIndexMap = new Dictionary <ReportingDescriptor, int>(ReportingDescriptor.ValueComparer);
}
public SarifLogger(
TextWriter textWriter,
LogFilePersistenceOptions logFilePersistenceOptions = DefaultLogFilePersistenceOptions,
OptionallyEmittedData dataToInsert = OptionallyEmittedData.None,
OptionallyEmittedData dataToRemove = OptionallyEmittedData.None,
Tool tool = null,
Run run = null,
IEnumerable <string> analysisTargets = null,
IEnumerable <string> invocationTokensToRedact = null,
IEnumerable <string> invocationPropertiesToLog = null,
string defaultFileEncoding = null,
bool closeWriterOnDispose = true,
IEnumerable <FailureLevel> levels = null,
IEnumerable <ResultKind> kinds = null) : this(textWriter, logFilePersistenceOptions, closeWriterOnDispose, levels, kinds)
{
if (dataToInsert.HasFlag(OptionallyEmittedData.Hashes))
{
AnalysisTargetToHashDataMap = HashUtilities.MultithreadedComputeTargetFileHashes(analysisTargets);
}
_run = run ?? new Run();
if (dataToInsert.HasFlag(OptionallyEmittedData.RegionSnippets) || dataToInsert.HasFlag(OptionallyEmittedData.ContextRegionSnippets))
{
_insertOptionalDataVisitor = new InsertOptionalDataVisitor(dataToInsert, _run);
}
EnhanceRun(
analysisTargets,
dataToInsert,
dataToRemove,
invocationTokensToRedact,
invocationPropertiesToLog,
defaultFileEncoding,
AnalysisTargetToHashDataMap);
tool = tool ?? Tool.CreateFromAssemblyData();
_run.Tool = tool;
_dataToInsert = dataToInsert;
_dataToRemove = dataToRemove;
_issueLogJsonWriter.Initialize(_run);
// Map existing Rules to ensure duplicates aren't created
if (_run.Tool.Driver?.Rules != null)
{
for (int i = 0; i < _run.Tool.Driver.Rules.Count; ++i)
{
RuleToIndexMap[_run.Tool.Driver.Rules[i]] = i;
}
}
_persistArtifacts =
(_dataToInsert & OptionallyEmittedData.Hashes) != 0 ||
(_dataToInsert & OptionallyEmittedData.TextFiles) != 0 ||
(_dataToInsert & OptionallyEmittedData.BinaryFiles) != 0;
}
public static LogFilePersistenceOptions ConvertToLogFilePersistenceOptions(this AnalyzeOptionsBase analyzeOptions)
{
LogFilePersistenceOptions logFilePersistenceOptions = LogFilePersistenceOptions.PrettyPrint;
if (analyzeOptions.Force)
{
logFilePersistenceOptions |= LogFilePersistenceOptions.OverwriteExistingOutputFile;
}
if (analyzeOptions.Minify)
{
logFilePersistenceOptions ^= LogFilePersistenceOptions.PrettyPrint;
}
if (analyzeOptions.Optimize)
{
logFilePersistenceOptions |= LogFilePersistenceOptions.Optimize;
}
if (analyzeOptions.PrettyPrint)
{
logFilePersistenceOptions |= LogFilePersistenceOptions.PrettyPrint;
}
return(logFilePersistenceOptions);
}
public int Run(ConvertOptions convertOptions, IFileSystem fileSystem = null)
{
fileSystem ??= Sarif.FileSystem.Instance;
try
{
if (string.IsNullOrEmpty(convertOptions.OutputFilePath))
{
convertOptions.OutputFilePath = convertOptions.InputFilePath + SarifConstants.SarifFileExtension;
}
if (fileSystem.DirectoryExists(convertOptions.OutputFilePath))
{
Console.Error.WriteLine(
string.Format(
CultureInfo.CurrentCulture,
"The output path '{0}' is a directory.",
convertOptions.OutputFilePath));
return(FAILURE);
}
if (!ValidateOptions(convertOptions, fileSystem))
{
return(FAILURE);
}
LogFilePersistenceOptions logFilePersistenceOptions = LogFilePersistenceOptions.None;
OptionallyEmittedData dataToInsert = convertOptions.DataToInsert.ToFlags();
if (convertOptions.PrettyPrint)
{
logFilePersistenceOptions |= LogFilePersistenceOptions.PrettyPrint;
}
if (convertOptions.Force)
{
logFilePersistenceOptions |= LogFilePersistenceOptions.OverwriteExistingOutputFile;
}
new ToolFormatConverter().ConvertToStandardFormat(
convertOptions.ToolFormat,
convertOptions.InputFilePath,
convertOptions.OutputFilePath,
logFilePersistenceOptions,
dataToInsert,
convertOptions.PluginAssemblyPath);
if (convertOptions.NormalizeForGitHub)
{
SarifLog sarifLog;
JsonSerializer serializer = new JsonSerializer()
{
Formatting = convertOptions.PrettyPrint ? Formatting.Indented : 0,
};
using (JsonTextReader reader = new JsonTextReader(new StreamReader(convertOptions.OutputFilePath)))
{
sarifLog = serializer.Deserialize <SarifLog>(reader);
}
var visitor = new GitHubIngestionVisitor();
visitor.VisitSarifLog(sarifLog);
using (FileStream stream = File.Create(convertOptions.OutputFilePath))
using (StreamWriter streamWriter = new StreamWriter(stream))
using (JsonTextWriter writer = new JsonTextWriter(streamWriter))
{
serializer.Serialize(writer, sarifLog);
}
}
}
catch (Exception ex) when(!Debugger.IsAttached)
{
Console.WriteLine(ex);
return(FAILURE);
}
return(SUCCESS);
}
