/// <summary>Converts a tool log file represented as a stream 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> /// <param name="toolFormat">The tool format of the input file.</param> /// <param name="inputStream">A stream that contains tool log contents.</param> /// <param name="outputStream">A stream to which the converted output should be written.</param> public void ConvertToStandardFormat( ToolFormat toolFormat, Stream inputStream, IResultLogWriter outputStream) { if (toolFormat == ToolFormat.PREfast) { throw new ArgumentException("Cannot convert PREfast XML from stream. Call ConvertPREfastToStandardFormat helper instead."); } ; if (inputStream == null) { throw new ArgumentNullException("inputStream"); } ; if (outputStream == null) { throw new ArgumentNullException("outputStream"); } ; Lazy <IToolFileConverter> converter; if (_converters.TryGetValue(toolFormat, out converter)) { converter.Value.Convert(inputStream, outputStream); } else { throw new ArgumentException("Unrecognized tool specified: " + toolFormat.ToString(), "toolFormat"); } }
/// <summary>Converts a tool log file to the SARIF format.</summary> /// <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> public void ConvertToStandardFormat( ToolFormat toolFormat, string inputFileName, string outputFileName) { ConvertToStandardFormat(toolFormat, inputFileName, outputFileName, ToolFormatConversionOptions.None); }
/// <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> public void ConvertToStandardFormat( ToolFormat toolFormat, string inputFileName, string outputFileName, ToolFormatConversionOptions conversionOptions) { if (toolFormat == ToolFormat.PREfast) { string sarif = ConvertPREfastToStandardFormat(inputFileName); File.WriteAllText(outputFileName, sarif); } if (inputFileName == null) { throw new ArgumentNullException("inputFileName"); } ; if (outputFileName == null) { throw new ArgumentNullException("outputFileName"); } ; if (Directory.Exists(outputFileName)) { throw new ArgumentException("Specified file output path exists but is a directory.", "outputFileName"); } if (!conversionOptions.HasFlag(ToolFormatConversionOptions.OverwriteExistingOutputFile) && File.Exists(outputFileName)) { throw new InvalidOperationException("Output file already exists and option to overwrite was not specified."); } // 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 (var input = File.OpenRead(inputFileName)) using (var outputTextStream = File.Create(outputFileName)) using (var outputTextWriter = new StreamWriter(outputTextStream)) using (var outputJson = new JsonTextWriter(outputTextWriter)) { if (conversionOptions.HasFlag(ToolFormatConversionOptions.PrettyPrint)) { outputJson.Formatting = Formatting.Indented; } using (var output = new ResultLogJsonWriter(outputJson)) { ConvertToStandardFormat(toolFormat, input, output); } } }
/// <summary>Converts a tool log file to the SARIF format.</summary> /// <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> public void ConvertToStandardFormat( ToolFormat toolFormat, string inputFileName, string outputFileName) { if (toolFormat == ToolFormat.PREfast) { string sarif = ConvertPREfastToStandardFormat(inputFileName); File.WriteAllText(outputFileName, sarif); return; } ConvertToStandardFormat(toolFormat, inputFileName, outputFileName, ToolFormatConversionOptions.None); }
public static void ProcessLogFile(string filePath, ToolFormat toolFormat = ToolFormat.None) { SarifLog log; JsonSerializerSettings settings = new JsonSerializerSettings() { ContractResolver = SarifContractResolver.Instance, }; string logText; if (toolFormat == ToolFormat.None) { logText = File.ReadAllText(filePath); } else if (toolFormat == ToolFormat.PREfast) { logText = ToolFormatConverter.ConvertPREfastToStandardFormat(filePath); } else { // We have conversion to do var converter = new ToolFormatConverter(); var sb = new StringBuilder(); using (var input = new MemoryStream(File.ReadAllBytes(filePath))) { var outputTextWriter = new StringWriter(sb); var outputJson = new JsonTextWriter(outputTextWriter); var output = new ResultLogJsonWriter(outputJson); input.Seek(0, SeekOrigin.Begin); converter.ConvertToStandardFormat(toolFormat, input, output); // This is serving as a flush mechanism output.Dispose(); logText = sb.ToString(); } } log = JsonConvert.DeserializeObject<SarifLog>(logText, settings); ProcessSarifLog(log, filePath); }
public static void ProcessLogFile(string filePath, ToolFormat toolFormat = ToolFormat.None) { SarifLog log; JsonSerializerSettings settings = new JsonSerializerSettings() { ContractResolver = SarifContractResolver.Instance, }; string logText; if (toolFormat == ToolFormat.None) { logText = File.ReadAllText(filePath); } else if (toolFormat == ToolFormat.PREfast) { logText = ToolFormatConverter.ConvertPREfastToStandardFormat(filePath); } else { // We have conversion to do var converter = new ToolFormatConverter(); var sb = new StringBuilder(); using (var input = new MemoryStream(File.ReadAllBytes(filePath))) { var outputTextWriter = new StringWriter(sb); var outputJson = new JsonTextWriter(outputTextWriter); var output = new ResultLogJsonWriter(outputJson); input.Seek(0, SeekOrigin.Begin); converter.ConvertToStandardFormat(toolFormat, input, output); // This is serving as a flush mechanism output.Dispose(); logText = sb.ToString(); } } log = JsonConvert.DeserializeObject <SarifLog>(logText, settings); ProcessSarifLog(log); }
private void RunConverter(StringBuilder sb, ToolFormat toolFormat, string inputFileName, TestMode testMode) { string expectedFileName = inputFileName + ".sarif"; string generatedFileName = inputFileName + ".actual.sarif"; try { this.converter.ConvertToStandardFormat(toolFormat, inputFileName, generatedFileName, ToolFormatConversionOptions.OverwriteExistingOutputFile | ToolFormatConversionOptions.PrettyPrint); } catch (Exception ex) { sb.AppendLine(string.Format(CultureInfo.InvariantCulture, "The converter {0} threw an exception for input \"{1}\".", toolFormat, inputFileName)); sb.AppendLine(ex.ToString()); return; } string expectedSarif = File.ReadAllText(expectedFileName); string actualSarif = File.ReadAllText(generatedFileName); if (expectedSarif == actualSarif) { JsonSerializerSettings settings = new JsonSerializerSettings() { ContractResolver = SarifContractResolver.Instance, Formatting = Formatting.Indented }; // Make sure we can successfully deserialize what was just generated SarifLog actualLog = JsonConvert.DeserializeObject<SarifLog>(actualSarif, settings); actualSarif = JsonConvert.SerializeObject(actualLog, settings); bool success; switch (testMode) { case TestMode.CompareFileContents: success = expectedSarif == actualSarif; break; case TestMode.CompareObjectModels: SarifLog expectedLog = JsonConvert.DeserializeObject<SarifLog>(expectedSarif, settings); success = SarifLogEqualityComparer.Instance.Equals(expectedLog, actualLog); break; default: throw new ArgumentException($"Invalid test mode: {testMode}", nameof(testMode)); } if (success) { return; } else { File.WriteAllText(generatedFileName, actualSarif); } } string errorMessage = "The output of the {0} converter did not match for input {1}."; sb.AppendLine(string.Format(CultureInfo.CurrentCulture, errorMessage, toolFormat, inputFileName)); sb.AppendLine("Check differences with:"); sb.AppendLine(GenerateDiffCommand(expectedFileName, generatedFileName)); }
private void BatchRunConverter(ToolFormat tool, string inputFilter, TestMode testMode) { var sb = new StringBuilder(); string toolName = Enum.GetName(typeof(ToolFormat), tool); string testDirectory = SarifConverterTests.TestDirectory + "\\" + toolName; string[] testFiles = Directory.GetFiles(testDirectory, inputFilter); foreach (string file in testFiles) { RunConverter(sb, tool, file, testMode); } sb.Length.Should().Be(0, FormatFailureReason(sb, toolName)); }
private void BatchRunConverter(ToolFormat tool, TestMode testMode) { BatchRunConverter(tool, "*.xml", testMode); }
private static void CreateConverterRecord <T>(IDictionary <ToolFormat, Lazy <IToolFileConverter> > dict, ToolFormat format) where T : IToolFileConverter, new() { dict.Add(format, new Lazy <IToolFileConverter>(() => new T(), LazyThreadSafetyMode.ExecutionAndPublication)); }
/// <summary> /// This function is the callback used to execute the command when the menu item is clicked. /// See the constructor to see how the menu item is associated with this function using /// OleMenuCommandService service and MenuCommand class. /// </summary> /// <param name="sender">Event sender.</param> /// <param name="e">Event args.</param> private void MenuItemCallback(object sender, EventArgs e) { OleMenuCommand menuCommand = (OleMenuCommand)sender; OleMenuCmdEventArgs menuCmdEventArgs = (OleMenuCmdEventArgs)e; string inputFile = menuCmdEventArgs.InValue as String; string logFile = null; if (!String.IsNullOrWhiteSpace(inputFile)) { // If the input file is a URL, download the file. if (Uri.IsWellFormedUriString(inputFile, UriKind.Absolute)) { TryDownloadFile(inputFile, out logFile); } else { // Verify if the input file is valid. i.e. it exists and has a valid file extension. string logFileExtension = Path.GetExtension(inputFile); // Since we don't have a tool format, only accept *.sarif and *.json files as command input files. if (logFileExtension.Equals(".sarif", StringComparison.OrdinalIgnoreCase) || logFileExtension.Equals(".json", StringComparison.OrdinalIgnoreCase)) { if (File.Exists(inputFile)) { logFile = inputFile; } } } } ToolFormat toolFormat = ToolFormat.None; if (logFile == null) { string title = "Open Static Analysis Results Interchange Format (SARIF) file"; string filter = "SARIF files (*.sarif;*.sarif.json)|*.sarif;*.sarif.json"; switch (menuCommand.CommandID.ID) { // These constants expressed in our VSCT case OpenSarifFileCommandId: { // Native SARIF. All our defaults above are fine break; } case OpenPREfastFileCommandId: { toolFormat = ToolFormat.PREfast; title = "Open PREfast XML log file"; filter = "PREfast log files (*.xml)|*.xml"; break; } case OpenFxCopFileCommandId: { // FxCop. TODO. We need project file support. FxCop // fullMessages look broken. toolFormat = ToolFormat.FxCop; title = "Open FxCop XML log file"; filter = "FxCop report and project files (*.xml)|*.xml"; break; } case OpenCppCheckFileCommandId: { toolFormat = ToolFormat.CppCheck; title = "Open CppCheck XML log file"; filter = "CppCheck log files (*.xml)|*.xml"; break; } case OpenClangFileCommandId: { toolFormat = ToolFormat.ClangAnalyzer; title = "Open Clang XML log file"; filter = "Clang log files (*.xml)|*.xml"; break; } case OpenAndroidStudioFileCommandId: { toolFormat = ToolFormat.AndroidStudio; title = "Open Android Studio XML log file"; filter = "Android Studio log files (*.xml)|*.xml"; break; } } OpenFileDialog openFileDialog = new OpenFileDialog(); openFileDialog.Title = title; openFileDialog.Filter = filter; openFileDialog.RestoreDirectory = true; if (!String.IsNullOrWhiteSpace(inputFile)) { openFileDialog.FileName = Path.GetFileName(inputFile); openFileDialog.InitialDirectory = Path.GetDirectoryName(inputFile); } if (openFileDialog.ShowDialog() != DialogResult.OK) { return; } logFile = openFileDialog.FileName; } ErrorListService.ProcessLogFile(logFile, toolFormat); }