Merge pull request #14243 from tamasvajk/parallelize-restore

tamasvajk · web-flow · commit 011391bd27a2 · 2023-09-21T08:04:27.000+02:00
C#: Parallelize restore logic of missing packages
diff --git a/csharp/autobuilder/Semmle.Autobuild.Shared/Autobuilder.cs b/csharp/autobuilder/Semmle.Autobuild.Shared/Autobuilder.cs
@@ -267,7 +267,7 @@ protected string RequireEnvironmentVariable(string name)
 
         protected DiagnosticClassifier DiagnosticClassifier { get; }
 
-        private readonly ILogger logger = new ConsoleLogger(Verbosity.Info);
+        private readonly ILogger logger = new ConsoleLogger(Verbosity.Info, logThreadId: false);
 
         private readonly IDiagnosticsWriter diagnostics;
 
diff --git a/csharp/autobuilder/Semmle.Autobuild.Shared/BuildActions.cs b/csharp/autobuilder/Semmle.Autobuild.Shared/BuildActions.cs
@@ -187,12 +187,12 @@ public class SystemBuildActions : IBuildActions
 
         bool IBuildActions.FileExists(string file) => File.Exists(file);
 
-        private static ProcessStartInfo GetProcessStartInfo(string exe, string arguments, string? workingDirectory, IDictionary<string, string>? environment, bool redirectStandardOutput)
+        private static ProcessStartInfo GetProcessStartInfo(string exe, string arguments, string? workingDirectory, IDictionary<string, string>? environment)
         {
             var pi = new ProcessStartInfo(exe, arguments)
             {
                 UseShellExecute = false,
-                RedirectStandardOutput = redirectStandardOutput
+                RedirectStandardOutput = true
             };
             if (workingDirectory is not null)
                 pi.WorkingDirectory = workingDirectory;
@@ -204,40 +204,22 @@ private static ProcessStartInfo GetProcessStartInfo(string exe, string arguments
 
         int IBuildActions.RunProcess(string exe, string args, string? workingDirectory, System.Collections.Generic.IDictionary<string, string>? env, BuildOutputHandler onOutput, BuildOutputHandler onError)
         {
-            var pi = GetProcessStartInfo(exe, args, workingDirectory, env, true);
-            using var p = new Process
-            {
-                StartInfo = pi
-            };
-            p.StartInfo.RedirectStandardError = true;
-            p.OutputDataReceived += new DataReceivedEventHandler((sender, e) => onOutput(e.Data));
-            p.ErrorDataReceived += new DataReceivedEventHandler((sender, e) => onError(e.Data));
-
-            p.Start();
+            var pi = GetProcessStartInfo(exe, args, workingDirectory, env);
+            pi.RedirectStandardError = true;
 
-            p.BeginErrorReadLine();
-            p.BeginOutputReadLine();
-
-            p.WaitForExit();
-            return p.ExitCode;
+            return pi.ReadOutput(out _, onOut: s => onOutput(s), onError: s => onError(s));
         }
 
         int IBuildActions.RunProcess(string cmd, string args, string? workingDirectory, IDictionary<string, string>? environment)
         {
-            var pi = GetProcessStartInfo(cmd, args, workingDirectory, environment, false);
-            using var p = Process.Start(pi);
-            if (p is null)
-            {
-                return -1;
-            }
-            p.WaitForExit();
-            return p.ExitCode;
+            var pi = GetProcessStartInfo(cmd, args, workingDirectory, environment);
+            return pi.ReadOutput(out _, onOut: Console.WriteLine, onError: null);
         }
 
         int IBuildActions.RunProcess(string cmd, string args, string? workingDirectory, IDictionary<string, string>? environment, out IList<string> stdOut)
         {
-            var pi = GetProcessStartInfo(cmd, args, workingDirectory, environment, true);
-            return pi.ReadOutput(out stdOut);
+            var pi = GetProcessStartInfo(cmd, args, workingDirectory, environment);
+            return pi.ReadOutput(out stdOut, onOut: null, onError: null);
         }
 
         void IBuildActions.DirectoryDelete(string dir, bool recursive) => Directory.Delete(dir, recursive);
diff --git a/csharp/extractor/Semmle.Extraction.CIL.Driver/Program.cs b/csharp/extractor/Semmle.Extraction.CIL.Driver/Program.cs
@@ -38,7 +38,7 @@ public static void Main(string[] args)
             }
 
             var options = new ExtractorOptions(args);
-            using var logger = new ConsoleLogger(options.Verbosity);
+            using var logger = new ConsoleLogger(options.Verbosity, logThreadId: false);
 
             var actions = options.AssembliesToExtract
                 .Select(asm => asm.Filename)
diff --git a/csharp/extractor/Semmle.Extraction.CSharp.DependencyFetching/DependencyManager.cs b/csharp/extractor/Semmle.Extraction.CSharp.DependencyFetching/DependencyManager.cs
@@ -219,7 +219,7 @@ private void GenerateSourceFilesFromWebViews(List<FileInfo> allFiles)
             }
         }
 
-        public DependencyManager(string srcDir) : this(srcDir, DependencyOptions.Default, new ConsoleLogger(Verbosity.Info)) { }
+        public DependencyManager(string srcDir) : this(srcDir, DependencyOptions.Default, new ConsoleLogger(Verbosity.Info, logThreadId: true)) { }
 
         private IEnumerable<FileInfo> GetAllFiles()
         {
@@ -430,8 +430,8 @@ private void AnalyseProject(FileInfo project)
 
         }
 
-        private bool RestoreProject(string project, out string stdout, string? pathToNugetConfig = null) =>
-            dotnet.RestoreProjectToDirectory(project, packageDirectory.DirInfo.FullName, out stdout, pathToNugetConfig);
+        private bool RestoreProject(string project, string? pathToNugetConfig = null) =>
+            dotnet.RestoreProjectToDirectory(project, packageDirectory.DirInfo.FullName, pathToNugetConfig);
 
         private bool RestoreSolution(string solution, out IEnumerable<string> projects) =>
             dotnet.RestoreSolutionToDirectory(solution, packageDirectory.DirInfo.FullName, out projects);
@@ -454,25 +454,14 @@ private IEnumerable<string> RestoreSolutions(IEnumerable<string> solutions) =>
         /// <summary>
         /// Executes `dotnet restore` on all projects in projects.
         /// This is done in parallel for performance reasons.
-        /// To ensure that output is not interleaved, the output of each
-        /// restore is collected and printed.
         /// </summary>
         /// <param name="projects">A list of paths to project files.</param>
         private void RestoreProjects(IEnumerable<string> projects)
         {
-            var stdoutLines = projects
-                .AsParallel()
-                .WithDegreeOfParallelism(options.Threads)
-                .Select(project =>
-                    {
-                        RestoreProject(project, out var stdout);
-                        return stdout;
-                    })
-                .ToList();
-            foreach (var line in stdoutLines)
+            Parallel.ForEach(projects, new ParallelOptions { MaxDegreeOfParallelism = options.Threads }, project =>
             {
-                Console.WriteLine(line);
-            }
+                RestoreProject(project);
+            });
         }
 
         private void DownloadMissingPackages(List<FileInfo> allFiles)
@@ -499,30 +488,30 @@ private void DownloadMissingPackages(List<FileInfo> allFiles)
             var alreadyDownloadedPackages = Directory.GetDirectories(packageDirectory.DirInfo.FullName)
                 .Select(d => Path.GetFileName(d).ToLowerInvariant());
             var notYetDownloadedPackages = fileContent.AllPackages.Except(alreadyDownloadedPackages);
-            foreach (var package in notYetDownloadedPackages)
+
+            Parallel.ForEach(notYetDownloadedPackages, new ParallelOptions { MaxDegreeOfParallelism = options.Threads }, package =>
             {
                 progressMonitor.NugetInstall(package);
-                using var tempDir = new TemporaryDirectory(GetTemporaryWorkingDirectory(package));
+                using var tempDir = new TemporaryDirectory(ComputeTempDirectory(package));
                 var success = dotnet.New(tempDir.DirInfo.FullName);
                 if (!success)
                 {
-                    continue;
+                    return;
                 }
+
                 success = dotnet.AddPackage(tempDir.DirInfo.FullName, package);
                 if (!success)
                 {
-                    continue;
+                    return;
                 }
 
-                success = RestoreProject(tempDir.DirInfo.FullName, out var stdout, nugetConfig);
-                Console.WriteLine(stdout);
-
+                success = RestoreProject(tempDir.DirInfo.FullName, nugetConfig);
                 // TODO: the restore might fail, we could retry with a prerelease (*-* instead of *) version of the package.
                 if (!success)
                 {
                     progressMonitor.FailedToRestoreNugetPackage(package);
                 }
-            }
+            });
         }
 
         private void AnalyseSolutions(IEnumerable<string> solutions)
diff --git a/csharp/extractor/Semmle.Extraction.CSharp.DependencyFetching/DotNet.cs b/csharp/extractor/Semmle.Extraction.CSharp.DependencyFetching/DotNet.cs
@@ -40,16 +40,15 @@ private void Info()
         private static string GetRestoreArgs(string projectOrSolutionFile, string packageDirectory) =>
             $"restore --no-dependencies \"{projectOrSolutionFile}\" --packages \"{packageDirectory}\" /p:DisableImplicitNuGetFallbackFolder=true";
 
-        public bool RestoreProjectToDirectory(string projectFile, string packageDirectory, out string stdout, string? pathToNugetConfig = null)
+        public bool RestoreProjectToDirectory(string projectFile, string packageDirectory, string? pathToNugetConfig = null)
         {
             var args = GetRestoreArgs(projectFile, packageDirectory);
             if (pathToNugetConfig != null)
             {
                 args += $" --configfile \"{pathToNugetConfig}\"";
             }
-            var success = dotnetCliInvoker.RunCommand(args, out var output);
-            stdout = string.Join("\n", output);
-            return success;
+
+            return dotnetCliInvoker.RunCommand(args);
         }
 
         public bool RestoreSolutionToDirectory(string solutionFile, string packageDirectory, out IEnumerable<string> projects)
@@ -90,7 +89,6 @@ private IList<string> GetListed(string args, string artifact)
         {
             if (dotnetCliInvoker.RunCommand(args, out var artifacts))
             {
-                progressMonitor.LogInfo($"Found {artifact}s: {string.Join("\n", artifacts)}");
                 return artifacts;
             }
             return new List<string>();
diff --git a/csharp/extractor/Semmle.Extraction.CSharp.DependencyFetching/DotNetCliInvoker.cs b/csharp/extractor/Semmle.Extraction.CSharp.DependencyFetching/DotNetCliInvoker.cs
@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using Semmle.Util;
@@ -19,23 +20,33 @@ public DotNetCliInvoker(ProgressMonitor progressMonitor, string exec)
             this.Exec = exec;
         }
 
-        private ProcessStartInfo MakeDotnetStartInfo(string args, bool redirectStandardOutput)
+        private ProcessStartInfo MakeDotnetStartInfo(string args)
         {
             var startInfo = new ProcessStartInfo(Exec, args)
             {
                 UseShellExecute = false,
-                RedirectStandardOutput = redirectStandardOutput
+                RedirectStandardOutput = true,
+                RedirectStandardError = true
             };
             // Set the .NET CLI language to English to avoid localized output.
             startInfo.EnvironmentVariables["DOTNET_CLI_UI_LANGUAGE"] = "en";
             return startInfo;
         }
 
-        private bool RunCommandAux(string args, bool redirectStandardOutput, out IList<string> output)
+        private bool RunCommandAux(string args, out IList<string> output)
         {
             progressMonitor.RunningProcess($"{Exec} {args}");
-            var pi = MakeDotnetStartInfo(args, redirectStandardOutput);
-            var exitCode = pi.ReadOutput(out output);
+            var pi = MakeDotnetStartInfo(args);
+            var threadId = $"[{Environment.CurrentManagedThreadId:D3}]";
+            void onOut(string s)
+            {
+                Console.Out.WriteLine($"{threadId} {s}");
+            }
+            void onError(string s)
+            {
+                Console.Error.WriteLine($"{threadId} {s}");
+            }
+            var exitCode = pi.ReadOutput(out output, onOut, onError);
             if (exitCode != 0)
             {
                 progressMonitor.CommandFailed(Exec, args, exitCode);
@@ -45,9 +56,9 @@ private bool RunCommandAux(string args, bool redirectStandardOutput, out IList<s
         }
 
         public bool RunCommand(string args) =>
-            RunCommandAux(args, redirectStandardOutput: false, out _);
+            RunCommandAux(args, out _);
 
         public bool RunCommand(string args, out IList<string> output) =>
-            RunCommandAux(args, redirectStandardOutput: true, out output);
+            RunCommandAux(args, out output);
     }
 }
diff --git a/csharp/extractor/Semmle.Extraction.CSharp.DependencyFetching/IDotNet.cs b/csharp/extractor/Semmle.Extraction.CSharp.DependencyFetching/IDotNet.cs
@@ -4,7 +4,7 @@ namespace Semmle.Extraction.CSharp.DependencyFetching
 {
     internal interface IDotNet
     {
-        bool RestoreProjectToDirectory(string project, string directory, out string stdout, string? pathToNugetConfig = null);
+        bool RestoreProjectToDirectory(string project, string directory, string? pathToNugetConfig = null);
         bool RestoreSolutionToDirectory(string solutionFile, string packageDirectory, out IEnumerable<string> projects);
         bool New(string folder);
         bool AddPackage(string folder, string package);
diff --git a/csharp/extractor/Semmle.Extraction.CSharp.Standalone/Extractor.cs b/csharp/extractor/Semmle.Extraction.CSharp.Standalone/Extractor.cs
@@ -119,7 +119,7 @@ public static ExitCode Run(Options options)
             var stopwatch = new Stopwatch();
             stopwatch.Start();
 
-            using var logger = new ConsoleLogger(options.Verbosity);
+            using var logger = new ConsoleLogger(options.Verbosity, logThreadId: true);
             logger.Log(Severity.Info, "Running C# standalone extractor");
             using var a = new Analysis(logger, options);
             var sourceFileCount = a.Extraction.Sources.Count;
diff --git a/csharp/extractor/Semmle.Extraction.CSharp.Standalone/Options.cs b/csharp/extractor/Semmle.Extraction.CSharp.Standalone/Options.cs
@@ -2,6 +2,7 @@
 using Semmle.Util;
 using Semmle.Util.Logging;
 using Semmle.Extraction.CSharp.DependencyFetching;
+using System;
 
 namespace Semmle.Extraction.CSharp.Standalone
 {
@@ -64,15 +65,15 @@ public override bool HandleArgument(string arg)
             var fi = new FileInfo(dependencies.SolutionFile);
             if (!fi.Exists)
             {
-                System.Console.WriteLine("Error: The solution {0} does not exist", fi.FullName);
+                System.Console.WriteLine($"[{Environment.CurrentManagedThreadId:D3}] Error: The solution {fi.FullName} does not exist");
                 Errors = true;
             }
             return true;
         }
 
         public override void InvalidArgument(string argument)
         {
-            System.Console.WriteLine($"Error: Invalid argument {argument}");
+            System.Console.WriteLine($"[{Environment.CurrentManagedThreadId:D3}] Error: Invalid argument {argument}");
             Errors = true;
         }
 
diff --git a/csharp/extractor/Semmle.Extraction.CSharp/Extractor/Extractor.cs b/csharp/extractor/Semmle.Extraction.CSharp/Extractor/Extractor.cs
@@ -71,9 +71,9 @@ public static void SetInvariantCulture()
 
         public static ILogger MakeLogger(Verbosity verbosity, bool includeConsole)
         {
-            var fileLogger = new FileLogger(verbosity, GetCSharpLogPath());
+            var fileLogger = new FileLogger(verbosity, GetCSharpLogPath(), logThreadId: true);
             return includeConsole
-                ? new CombinedLogger(new ConsoleLogger(verbosity), fileLogger)
+                ? new CombinedLogger(new ConsoleLogger(verbosity, logThreadId: true), fileLogger)
                 : (ILogger)fileLogger;
         }
 
diff --git a/csharp/extractor/Semmle.Extraction.Tests/DotNet.cs b/csharp/extractor/Semmle.Extraction.Tests/DotNet.cs
@@ -99,7 +99,7 @@ public void TestDotnetRestoreProjectToDirectory1()
             var dotnet = MakeDotnet(dotnetCliInvoker);
 
             // Execute
-            dotnet.RestoreProjectToDirectory("myproject.csproj", "mypackages", out var _);
+            dotnet.RestoreProjectToDirectory("myproject.csproj", "mypackages");
 
             // Verify
             var lastArgs = dotnetCliInvoker.GetLastArgs();
@@ -114,7 +114,7 @@ public void TestDotnetRestoreProjectToDirectory2()
             var dotnet = MakeDotnet(dotnetCliInvoker);
 
             // Execute
-            dotnet.RestoreProjectToDirectory("myproject.csproj", "mypackages", out var _, "myconfig.config");
+            dotnet.RestoreProjectToDirectory("myproject.csproj", "mypackages", "myconfig.config");
 
             // Verify
             var lastArgs = dotnetCliInvoker.GetLastArgs();
diff --git a/csharp/extractor/Semmle.Extraction.Tests/Runtime.cs b/csharp/extractor/Semmle.Extraction.Tests/Runtime.cs
@@ -19,11 +19,7 @@ public DotNetStub(IList<string> runtimes, IList<string> sdks)
 
         public bool New(string folder) => true;
 
-        public bool RestoreProjectToDirectory(string project, string directory, out string stdout, string? pathToNugetConfig = null)
-        {
-            stdout = "";
-            return true;
-        }
+        public bool RestoreProjectToDirectory(string project, string directory, string? pathToNugetConfig = null) => true;
 
         public bool RestoreSolutionToDirectory(string solution, string directory, out IEnumerable<string> projects)
         {
diff --git a/csharp/extractor/Semmle.Util/Logger.cs b/csharp/extractor/Semmle.Util/Logger.cs
@@ -59,10 +59,12 @@ public sealed class FileLogger : ILogger
     {
         private readonly StreamWriter writer;
         private readonly Verbosity verbosity;
+        private readonly bool logThreadId;
 
-        public FileLogger(Verbosity verbosity, string outputFile)
+        public FileLogger(Verbosity verbosity, string outputFile, bool logThreadId)
         {
             this.verbosity = verbosity;
+            this.logThreadId = logThreadId;
 
             try
             {
@@ -93,7 +95,10 @@ private static string GetSeverityPrefix(Severity s)
         public void Log(Severity s, string text)
         {
             if (verbosity.Includes(s))
-                writer.WriteLine(GetSeverityPrefix(s) + text);
+            {
+                var threadId = this.logThreadId ? $"[{Environment.CurrentManagedThreadId:D3}] " : "";
+                writer.WriteLine(threadId + GetSeverityPrefix(s) + text);
+            }
         }
     }
 
@@ -103,10 +108,12 @@ public void Log(Severity s, string text)
     public sealed class ConsoleLogger : ILogger
     {
         private readonly Verbosity verbosity;
+        private readonly bool logThreadId;
 
-        public ConsoleLogger(Verbosity verbosity)
+        public ConsoleLogger(Verbosity verbosity, bool logThreadId)
         {
             this.verbosity = verbosity;
+            this.logThreadId = logThreadId;
         }
 
         public void Dispose() { }
@@ -136,7 +143,10 @@ private static string GetSeverityPrefix(Severity s)
         public void Log(Severity s, string text)
         {
             if (verbosity.Includes(s))
-                GetConsole(s).WriteLine(GetSeverityPrefix(s) + text);
+            {
+                var threadId = this.logThreadId ? $"[{Environment.CurrentManagedThreadId:D3}] " : "";
+                GetConsole(s).WriteLine(threadId + GetSeverityPrefix(s) + text);
+            }
         }
     }
 
diff --git a/csharp/extractor/Semmle.Util/ProcessStartInfoExtensions.cs b/csharp/extractor/Semmle.Util/ProcessStartInfoExtensions.cs

Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ public static void Main(string[] args)`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`var options = new ExtractorOptions(args);`
`41`		`- using var logger = new ConsoleLogger(options.Verbosity);`
	`41`	`+ using var logger = new ConsoleLogger(options.Verbosity, logThreadId: false);`
`42`	`42`
`43`	`43`	`var actions = options.AssembliesToExtract`
`44`	`44`	`.Select(asm => asm.Filename)`
Original file line number	Diff line number	Diff line change
`@@ -219,7 +219,7 @@ private void GenerateSourceFilesFromWebViews(List<FileInfo> allFiles)`
`219`	`219`	`}`
`220`	`220`	`}`
`221`	`221`
`222`		`- public DependencyManager(string srcDir) : this(srcDir, DependencyOptions.Default, new ConsoleLogger(Verbosity.Info)) { }`
	`222`	`+ public DependencyManager(string srcDir) : this(srcDir, DependencyOptions.Default, new ConsoleLogger(Verbosity.Info, logThreadId: true)) { }`
`223`	`223`
`224`	`224`	`private IEnumerable<FileInfo> GetAllFiles()`
`225`	`225`	`{`
`@@ -430,8 +430,8 @@ private void AnalyseProject(FileInfo project)`
`430`	`430`
`431`	`431`	`}`
`432`	`432`
`433`		`- private bool RestoreProject(string project, out string stdout, string? pathToNugetConfig = null) =>`
`434`		`- dotnet.RestoreProjectToDirectory(project, packageDirectory.DirInfo.FullName, out stdout, pathToNugetConfig);`
	`433`	`+ private bool RestoreProject(string project, string? pathToNugetConfig = null) =>`
	`434`	`+ dotnet.RestoreProjectToDirectory(project, packageDirectory.DirInfo.FullName, pathToNugetConfig);`
`435`	`435`
`436`	`436`	`private bool RestoreSolution(string solution, out IEnumerable<string> projects) =>`
`437`	`437`	`dotnet.RestoreSolutionToDirectory(solution, packageDirectory.DirInfo.FullName, out projects);`
`@@ -454,25 +454,14 @@ private IEnumerable<string> RestoreSolutions(IEnumerable<string> solutions) =>`
`454`	`454`	`/// <summary>`
`455`	`455`	/// Executes `dotnet restore` on all projects in projects.
`456`	`456`	`/// This is done in parallel for performance reasons.`
`457`		`- /// To ensure that output is not interleaved, the output of each`
`458`		`- /// restore is collected and printed.`
`459`	`457`	`/// </summary>`
`460`	`458`	`/// <param name="projects">A list of paths to project files.</param>`
`461`	`459`	`private void RestoreProjects(IEnumerable<string> projects)`
`462`	`460`	`{`
`463`		`- var stdoutLines = projects`
`464`		`- .AsParallel()`
`465`		`- .WithDegreeOfParallelism(options.Threads)`
`466`		`- .Select(project =>`
`467`		`- {`
`468`		`- RestoreProject(project, out var stdout);`
`469`		`- return stdout;`
`470`		`- })`
`471`		`- .ToList();`
`472`		`- foreach (var line in stdoutLines)`
	`461`	`+ Parallel.ForEach(projects, new ParallelOptions { MaxDegreeOfParallelism = options.Threads }, project =>`
`473`	`462`	`{`
`474`		`- Console.WriteLine(line);`
`475`		`- }`
	`463`	`+ RestoreProject(project);`
	`464`	`+ });`
`476`	`465`	`}`
`477`	`466`
`478`	`467`	`private void DownloadMissingPackages(List<FileInfo> allFiles)`
`@@ -499,30 +488,30 @@ private void DownloadMissingPackages(List<FileInfo> allFiles)`
`499`	`488`	`var alreadyDownloadedPackages = Directory.GetDirectories(packageDirectory.DirInfo.FullName)`
`500`	`489`	`.Select(d => Path.GetFileName(d).ToLowerInvariant());`
`501`	`490`	`var notYetDownloadedPackages = fileContent.AllPackages.Except(alreadyDownloadedPackages);`
`502`		`- foreach (var package in notYetDownloadedPackages)`
	`491`	`+`
	`492`	`+ Parallel.ForEach(notYetDownloadedPackages, new ParallelOptions { MaxDegreeOfParallelism = options.Threads }, package =>`
`503`	`493`	`{`
`504`	`494`	`progressMonitor.NugetInstall(package);`
`505`		`- using var tempDir = new TemporaryDirectory(GetTemporaryWorkingDirectory(package));`
	`495`	`+ using var tempDir = new TemporaryDirectory(ComputeTempDirectory(package));`
`506`	`496`	`var success = dotnet.New(tempDir.DirInfo.FullName);`
`507`	`497`	`if (!success)`
`508`	`498`	`{`
`509`		`- continue;`
	`499`	`+ return;`
`510`	`500`	`}`
	`501`	`+`
`511`	`502`	`success = dotnet.AddPackage(tempDir.DirInfo.FullName, package);`
`512`	`503`	`if (!success)`
`513`	`504`	`{`
`514`		`- continue;`
	`505`	`+ return;`
`515`	`506`	`}`
`516`	`507`
`517`		`- success = RestoreProject(tempDir.DirInfo.FullName, out var stdout, nugetConfig);`
`518`		`- Console.WriteLine(stdout);`
`519`		`-`
	`508`	`+ success = RestoreProject(tempDir.DirInfo.FullName, nugetConfig);`
`520`	`509`	`// TODO: the restore might fail, we could retry with a prerelease (- instead of *) version of the package.`
`521`	`510`	`if (!success)`
`522`	`511`	`{`
`523`	`512`	`progressMonitor.FailedToRestoreNugetPackage(package);`
`524`	`513`	`}`
`525`		`- }`
	`514`	`+ });`
`526`	`515`	`}`
`527`	`516`
`528`	`517`	`private void AnalyseSolutions(IEnumerable<string> solutions)`
Original file line number	Diff line number	Diff line change
`@@ -40,16 +40,15 @@ private void Info()`
`40`	`40`	`private static string GetRestoreArgs(string projectOrSolutionFile, string packageDirectory) =>`
`41`	`41`	`$"restore --no-dependencies \"{projectOrSolutionFile}\" --packages \"{packageDirectory}\" /p:DisableImplicitNuGetFallbackFolder=true";`
`42`	`42`
`43`		`- public bool RestoreProjectToDirectory(string projectFile, string packageDirectory, out string stdout, string? pathToNugetConfig = null)`
	`43`	`+ public bool RestoreProjectToDirectory(string projectFile, string packageDirectory, string? pathToNugetConfig = null)`
`44`	`44`	`{`
`45`	`45`	`var args = GetRestoreArgs(projectFile, packageDirectory);`
`46`	`46`	`if (pathToNugetConfig != null)`
`47`	`47`	`{`
`48`	`48`	`args += $" --configfile \"{pathToNugetConfig}\"";`
`49`	`49`	`}`
`50`		`- var success = dotnetCliInvoker.RunCommand(args, out var output);`
`51`		`- stdout = string.Join("\n", output);`
`52`		`- return success;`
	`50`	`+`
	`51`	`+ return dotnetCliInvoker.RunCommand(args);`
`53`	`52`	`}`
`54`	`53`
`55`	`54`	`public bool RestoreSolutionToDirectory(string solutionFile, string packageDirectory, out IEnumerable<string> projects)`
`@@ -90,7 +89,6 @@ private IList<string> GetListed(string args, string artifact)`
`90`	`89`	`{`
`91`	`90`	`if (dotnetCliInvoker.RunCommand(args, out var artifacts))`
`92`	`91`	`{`
`93`		`- progressMonitor.LogInfo($"Found {artifact}s: {string.Join("\n", artifacts)}");`
`94`	`92`	`return artifacts;`
`95`	`93`	`}`
`96`	`94`	`return new List<string>();`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@ namespace Semmle.Extraction.CSharp.DependencyFetching`
`4`	`4`	`{`
`5`	`5`	`internal interface IDotNet`
`6`	`6`	`{`
`7`		`- bool RestoreProjectToDirectory(string project, string directory, out string stdout, string? pathToNugetConfig = null);`
	`7`	`+ bool RestoreProjectToDirectory(string project, string directory, string? pathToNugetConfig = null);`
`8`	`8`	`bool RestoreSolutionToDirectory(string solutionFile, string packageDirectory, out IEnumerable<string> projects);`
`9`	`9`	`bool New(string folder);`
`10`	`10`	`bool AddPackage(string folder, string package);`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@`
`2`	`2`	`using Semmle.Util;`
`3`	`3`	`using Semmle.Util.Logging;`
`4`	`4`	`using Semmle.Extraction.CSharp.DependencyFetching;`
	`5`	`+using System;`
`5`	`6`
`6`	`7`	`namespace Semmle.Extraction.CSharp.Standalone`
`7`	`8`	`{`
`@@ -64,15 +65,15 @@ public override bool HandleArgument(string arg)`
`64`	`65`	`var fi = new FileInfo(dependencies.SolutionFile);`
`65`	`66`	`if (!fi.Exists)`
`66`	`67`	`{`
`67`		`- System.Console.WriteLine("Error: The solution {0} does not exist", fi.FullName);`
	`68`	`+ System.Console.WriteLine($"[{Environment.CurrentManagedThreadId:D3}] Error: The solution {fi.FullName} does not exist");`
`68`	`69`	`Errors = true;`
`69`	`70`	`}`
`70`	`71`	`return true;`
`71`	`72`	`}`
`72`	`73`
`73`	`74`	`public override void InvalidArgument(string argument)`
`74`	`75`	`{`
`75`		`- System.Console.WriteLine($"Error: Invalid argument {argument}");`
	`76`	`+ System.Console.WriteLine($"[{Environment.CurrentManagedThreadId:D3}] Error: Invalid argument {argument}");`
`76`	`77`	`Errors = true;`
`77`	`78`	`}`
`78`	`79`
Original file line number	Diff line number	Diff line change
`@@ -71,9 +71,9 @@ public static void SetInvariantCulture()`
`71`	`71`
`72`	`72`	`public static ILogger MakeLogger(Verbosity verbosity, bool includeConsole)`
`73`	`73`	`{`
`74`		`- var fileLogger = new FileLogger(verbosity, GetCSharpLogPath());`
	`74`	`+ var fileLogger = new FileLogger(verbosity, GetCSharpLogPath(), logThreadId: true);`
`75`	`75`	`return includeConsole`
`76`		`- ? new CombinedLogger(new ConsoleLogger(verbosity), fileLogger)`
	`76`	`+ ? new CombinedLogger(new ConsoleLogger(verbosity, logThreadId: true), fileLogger)`
`77`	`77`	`: (ILogger)fileLogger;`
`78`	`78`	`}`
`79`	`79`