public static int RunDotNet(string cmd)
{
var watcher = Process.Start(DotNetExe.FullPathOrDefault(), cmd);
watcher?.WaitForExit();
return(watcher?.ExitCode ?? 1);
}
public static async Task RunDotnetCommand(string args, CancellationToken cancellationToken)
{
await Task.Run(() =>
{
var process = Process.Start(DotNetExe.FullPathOrDefault(), args);
process?.WaitForExit((int)TimeSpan.FromSeconds(30).TotalMilliseconds);
}, cancellationToken);
}
private static async Task RestorePackagesForSolutionAsync(string solutionFile)
{
var restoreExitCode = await ProcessRunner.ConnectConsoleGetExitCodeAsync(DotNetExe.FullPathOrDefault(), "restore", solutionFile);
if (restoreExitCode != 0)
{
throw new ValidationException("dotnet restore had a non-zero exit code.");
}
}
public DotnetCommandResult Run(string workingDirectory, string arguments)
{
Contract.Requires(arguments != null);
var psi = new ProcessStartInfo(DotNetExe.FullPathOrDefault(), arguments)
{
CreateNoWindow = true,
RedirectStandardOutput = true,
RedirectStandardError = true,
UseShellExecute = false,
WorkingDirectory = workingDirectory
};
using (var p = Process.Start(psi))
{
var output = new StringBuilder();
var errors = new StringBuilder();
var outputTask = ConsumeStreamReaderAsync(p.StandardOutput, output);
var errorTask = ConsumeStreamReaderAsync(p.StandardError, errors);
var processExited = p.WaitForExit(TimeoutMilliseconds);
if (processExited)
{
Task.WaitAll(outputTask, errorTask);
return(new DotnetCommandResult
{
ExitCode = p.ExitCode,
StdOut = output.ToString(),
StdErr = errors.ToString()
});
}
else
{
p.Kill();
return(new DotnetCommandResult
{
ExitCode = -1,
StdOut = arguments.StartsWith("restore ", System.StringComparison.InvariantCulture) ?
$"Timeout running dotnet restore, try running \"dotnet restore\" before \"dotnet CycloneDX\""
: $"Timeout running dotnet {arguments}",
});
}
}
}
public RunStatus Run(string workingDirectory, string[] arguments)
{
var psi = new ProcessStartInfo(DotNetExe.FullPathOrDefault(), string.Join(" ", arguments))
{
WorkingDirectory = workingDirectory,
UseShellExecute = false,
CreateNoWindow = true,
RedirectStandardOutput = true,
RedirectStandardError = true
};
var p = new Process();
try
{
p.StartInfo = psi;
p.Start();
var output = new StringBuilder();
var errors = new StringBuilder();
var outputTask = ConsumeStreamReaderAsync(p.StandardOutput, output);
var errorTask = ConsumeStreamReaderAsync(p.StandardError, errors);
var processExited = p.WaitForExit(20000);
if (processExited == false)
{
p.Kill();
return(new RunStatus(output.ToString(), errors.ToString(), exitCode: -1));
}
Task.WaitAll(outputTask, errorTask);
return(new RunStatus(output.ToString(), errors.ToString(), p.ExitCode));
}
finally
{
p.Dispose();
}
}
public async Task BuildAsync(IFileInfo project, string configuration, string framework)
{
_console.WriteLine("Building project...");
var processInfo = new ProcessStartInfo(DotNetExe.FullPathOrDefault())
{
Arguments = $"build {project.Name} --configuration {configuration} --framework {framework}",
WorkingDirectory = Path.GetDirectoryName(project.PhysicalPath),
CreateNoWindow = true,
WindowStyle = ProcessWindowStyle.Hidden,
UseShellExecute = false,
RedirectStandardError = true,
RedirectStandardOutput = true
};
using (var process = new Process {
StartInfo = processInfo
})
{
await process.StartAsync(
async output =>
{
while (!output.EndOfStream)
{
await _console.Out.WriteLineAsync(
await output.ReadLineAsync().ConfigureAwait(false)).ConfigureAwait(false);
}
},
async error =>
{
while (!error.EndOfStream)
{
await _console.Error.WriteLineAsync(
await error.ReadLineAsync().ConfigureAwait(false)).ConfigureAwait(false);
}
}).ConfigureAwait(false);
}
_console.WriteLine("Build completed.")
.WriteLine(string.Empty);
}
static string RunDotnet(params string[] args)
{
var dotnetCliPath = DotNetExe.FullPathOrDefault();
var processArgs = ArgumentEscaper.EscapeAndConcatenate(args);
var runCommand = $"dotnet {processArgs}";
Console.WriteLine($"Running: {runCommand}");
var(output, error, exitCode) = RunProcess(dotnetCliPath, args);
if (!string.IsNullOrWhiteSpace(error))
{
throw new Exception($"Error running: {runCommand}{Environment.NewLine}{error}");
}
if (exitCode != 0)
{
throw new Exception($"Bad exit code '{exitCode}' when running: {runCommand}{Environment.NewLine}{output}");
}
return(output);
}
public Dotnet(IFileSystem fileSystem, IConsole console, IPlatformService platformService) : base(console, platformService, DotNetExe.FullPathOrDefault())
{
_fileSystem = fileSystem;
}
public static DotNetServe Start(
string directory = null,
int?port = default,
bool enableTls = false,
string certPassword = null,
string[] mimeMap = null,
string[] headers = null,
ITestOutputHelper output = null)
{
var psi = new ProcessStartInfo
{
FileName = DotNetExe.FullPathOrDefault(),
RedirectStandardOutput = true,
RedirectStandardError = true,
ArgumentList =
{
s_dotnetServe,
"--verbose",
},
WorkingDirectory = directory ?? AppContext.BaseDirectory,
};
if (directory != null)
{
psi.ArgumentList.Add("-d");
psi.ArgumentList.Add(directory);
}
if (!port.HasValue)
{
port = Interlocked.Increment(ref s_nextPort);
}
psi.ArgumentList.Add("-p");
psi.ArgumentList.Add(port.ToString());
if (enableTls)
{
psi.ArgumentList.Add("--tls");
}
if (certPassword != null)
{
psi.ArgumentList.Add("--pfx-pwd");
psi.ArgumentList.Add(certPassword);
}
if (mimeMap != null)
{
foreach (var mapping in mimeMap)
{
psi.ArgumentList.Add("-m");
psi.ArgumentList.Add(mapping);
}
}
if (headers != null)
{
foreach (var header in headers)
{
psi.ArgumentList.Add("-h");
psi.ArgumentList.Add(header);
}
}
var process = new Process
{
EnableRaisingEvents = true,
StartInfo = psi,
};
var serve = new DotNetServe(process, port.Value, enableTls, output);
serve.Start();
return(serve);
}
static DotNetRunner()
{
DotnetCommand = DotNetExe.FullPathOrDefault();
}
