private static CommandResult ExecuteMiniCover(string minicoverDirectory, string command, string parameter) { StreamForwarder stdOut = new StreamForwarder(); StreamForwarder stdError = new StreamForwarder(); ProcessStartInfo processStartInfo = new ProcessStartInfo("dotnet", $"minicover {command} {parameter}") { WorkingDirectory = minicoverDirectory, UseShellExecute = false, RedirectStandardOutput = true, RedirectStandardError = true }; stdOut.Capture(); stdError.Capture(); var process = new Process { StartInfo = processStartInfo }; process.Start(); var threadOut = stdOut.BeginRead(process.StandardOutput); var threadErr = stdError.BeginRead(process.StandardError); process.WaitForExit(); threadOut.Wait(); threadErr.Wait(); process.HasExited.ShouldBe(true); return(new CommandResult(processStartInfo, process.ExitCode, stdOut.CapturedOutput, stdError.CapturedOutput)); }
private CommandResult RunProcess(string executable, string args, StreamForwarder stdOut, StreamForwarder stdErr) { var psi = new ProcessStartInfo { FileName = executable, Arguments = args, RedirectStandardError = true, RedirectStandardOutput = true }; var process = new Process { StartInfo = psi }; process.EnableRaisingEvents = true; process.Start(); var threadOut = stdOut.BeginRead(process.StandardOutput); var threadErr = stdErr.BeginRead(process.StandardError); process.WaitForExit(); threadOut.Join(); threadErr.Join(); var result = new CommandResult( process.StartInfo, process.ExitCode, stdOut.GetCapturedOutput(), stdErr.GetCapturedOutput()); return(result); }
public virtual CommandResult Execute(params string[] args) { var commandPath = _command; ResolveCommand(ref commandPath); var stdOut = new StreamForwarder(); var stdErr = new StreamForwarder(); stdOut.ForwardTo(Log); stdErr.ForwardTo(Log); return(RunProcess(commandPath, args, stdOut, stdErr)); }
public virtual CommandResult ExecuteWithCapturedOutput(string args = "") { Console.WriteLine($"Executing (Captured Output) - {_command} {args}"); var commandPath = Env.GetCommandPath(_command, ".exe", ".cmd", "") ?? Env.GetCommandPathFromAppBase(AppContext.BaseDirectory, _command, ".exe", ".cmd", ""); var stdOut = new StreamForwarder(); var stdErr = new StreamForwarder(); stdOut.Capture(); stdErr.Capture(); return(RunProcess(commandPath, args, stdOut, stdErr)); }
private CommandResult RunProcess(string executable, string[] args, StreamForwarder stdOut, StreamForwarder stdErr) { var psi = new ProcessStartInfo { FileName = executable, Arguments = ArgumentEscaper.EscapeAndConcatenateArgArrayForProcessStart(args), RedirectStandardError = true, RedirectStandardOutput = true }; Log("Executing: ".Bold().Blue() + $"{psi.FileName} {psi.Arguments}"); foreach (var item in Environment) { psi.Environment[item.Key] = item.Value; } if (!string.IsNullOrWhiteSpace(WorkingDirectory)) { psi.WorkingDirectory = WorkingDirectory; Log($"Working directory: {WorkingDirectory}"); } var process = new Process { StartInfo = psi, EnableRaisingEvents = true }; using (process) { process.Start(); var threadOut = stdOut.BeginRead(process.StandardOutput); var threadErr = stdErr.BeginRead(process.StandardError); process.WaitForExit(); Task.WaitAll(threadOut, threadErr); var result = new CommandResult( process.StartInfo, process.ExitCode, stdOut.CapturedOutput, stdErr.CapturedOutput); return(result); } }
public virtual CommandResult Execute(string args = "") { var commandPath = _command; ResolveCommand(ref commandPath, ref args); Console.WriteLine($"Executing - {commandPath} {args}"); var stdOut = new StreamForwarder(); var stdErr = new StreamForwarder(); stdOut.ForwardTo(writeLine: Reporter.Output.WriteLine); stdErr.ForwardTo(writeLine: Reporter.Output.WriteLine); return(RunProcess(commandPath, args, stdOut, stdErr)); }
public virtual CommandResult Execute(string args = "") { var commandPath = _command; ResolveCommand(ref commandPath, ref args); Log($"Executing - {commandPath} {args}"); var stdOut = new StreamForwarder(); var stdErr = new StreamForwarder(); stdOut.ForwardTo(Log); stdErr.ForwardTo(Log); return(RunProcess(commandPath, args, stdOut, stdErr)); }
public virtual CommandResult ExecuteWithCapturedOutput(params string[] args) { var command = _command; ResolveCommand(ref command); var commandPath = Env.GetCommandPath(command, ".exe", ".cmd", string.Empty) ?? Env.GetCommandPathFromRootPath(AppContext.BaseDirectory, command, ".exe", ".cmd", string.Empty); var stdOut = new StreamForwarder(); var stdErr = new StreamForwarder(); stdOut.Capture(); stdErr.Capture(); return(RunProcess(commandPath, args, stdOut, stdErr)); }
public virtual Task<CommandResult> ExecuteAsync(string args = "") { var commandPath = _command; ResolveCommand(ref commandPath, ref args); Console.WriteLine($"Executing - {commandPath} {args} - {WorkingDirectoryInfo()}"); var stdOut = new StreamForwarder(); var stdErr = new StreamForwarder(); AddWriteLine(Reporter.Output.WriteLine); stdOut.ForwardTo(writeLine: WriteLine); stdErr.ForwardTo(writeLine: WriteLine); return RunProcessAsync(commandPath, args, stdOut, stdErr); }
private CommandResult RunProcess(string executable, string args, StreamForwarder stdOut, StreamForwarder stdErr) { CurrentProcess = StartProcess(executable, args); var taskOut = stdOut.BeginRead(CurrentProcess.StandardOutput); var taskErr = stdErr.BeginRead(CurrentProcess.StandardError); CurrentProcess.WaitForExit(); Task.WaitAll(taskOut, taskErr); var result = new CommandResult( CurrentProcess.StartInfo, CurrentProcess.ExitCode, stdOut.CapturedOutput, stdErr.CapturedOutput); return(result); }
public virtual CommandResult ExecuteWithCapturedOutput(string args = "") { var command = _command; ResolveCommand(ref command, ref args); var commandPath = Env.GetCommandPath(command, ".exe", ".cmd", "") ?? Env.GetCommandPathFromRootPath(_baseDirectory, command, ".exe", ".cmd", ""); Console.WriteLine($"Executing (Captured Output) - {commandPath} {args}"); var stdOut = new StreamForwarder(); var stdErr = new StreamForwarder(); stdOut.Capture(); stdErr.Capture(); return(RunProcess(commandPath, args, stdOut, stdErr)); }
private CommandResult RunProcess(string executable, string args, StreamForwarder stdOut, StreamForwarder stdErr) { var psi = new ProcessStartInfo { FileName = executable, Arguments = args, RedirectStandardError = true, RedirectStandardOutput = true }; foreach (var item in Environment) { psi.Environment[item.Key] = item.Value; } if (!string.IsNullOrWhiteSpace(WorkingDirectory)) { psi.WorkingDirectory = WorkingDirectory; Log($"Working directory: {WorkingDirectory}"); } var process = new Process { StartInfo = psi, EnableRaisingEvents = true }; process.Start(); var threadOut = stdOut.BeginRead(process.StandardOutput); var threadErr = stdErr.BeginRead(process.StandardError); process.WaitForExit(); threadOut.Join(); threadErr.Join(); var result = new CommandResult( process.StartInfo, process.ExitCode, stdOut.CapturedOutput, stdErr.CapturedOutput); return(result); }
public virtual CommandResult Execute(string args = "") { var commandPath = _command; if (!Path.IsPathRooted(_command)) { _command = Env.GetCommandPath(_command) ?? Env.GetCommandPathFromAppBase(AppContext.BaseDirectory, _command); } Console.WriteLine($"Executing - {_command} {args}"); var stdOut = new StreamForwarder(); var stdErr = new StreamForwarder(); stdOut.ForwardTo(write: Reporter.Output.Write, writeLine: Reporter.Output.WriteLine); stdErr.ForwardTo(write: Reporter.Error.Write, writeLine: Reporter.Output.WriteLine); return(RunProcess(commandPath, args, stdOut, stdErr)); }
private static void Forward(int bufferSize, ForwardOptions options, string str, string expectedCaptured, string[] expectedWrites) { var forwarder = new StreamForwarder(bufferSize); var writes = new List <string>(); if ((options & ForwardOptions.WriteLine) != 0) { forwarder.ForwardTo( write: (options & ForwardOptions.Write) == 0 ? (Action <string>)null : writes.Add, writeLine: s => writes.Add(s + "\n")); } if ((options & ForwardOptions.Capture) != 0) { forwarder.Capture(); } forwarder.Read(new StringReader(str)); Assert.Equal(expectedWrites, writes); var captured = forwarder.GetCapturedOutput(); Assert.Equal(expectedCaptured, captured); }
private void TestCapturingAndForwardingHelper(ForwardOptions options, string str, string expectedCaptured, string[] expectedWrites) { var forwarder = new StreamForwarder(); var writes = new List <string>(); if ((options & ForwardOptions.WriteLine) != 0) { forwarder.ForwardTo(writeLine: s => writes.Add(s + Environment.NewLine)); } if ((options & ForwardOptions.Capture) != 0) { forwarder.Capture(); } forwarder.Read(new StringReader(str)); Assert.Equal(expectedWrites, writes); var captured = forwarder.CapturedOutput; Assert.Equal(expectedCaptured, captured); }
private Task <CommandResult> RunProcessAsync(string executable, string args, StreamForwarder stdOut, StreamForwarder stdErr) { CurrentProcess = StartProcess(executable, args); var taskOut = stdOut.BeginRead(CurrentProcess.StandardOutput); var taskErr = stdErr.BeginRead(CurrentProcess.StandardError); var tcs = new TaskCompletionSource <CommandResult>(); CurrentProcess.Exited += (sender, arg) => { Task.WaitAll(taskOut, taskErr); var result = new CommandResult( CurrentProcess.StartInfo, CurrentProcess.ExitCode, stdOut.CapturedOutput, stdErr.CapturedOutput); tcs.SetResult(result); }; return(tcs.Task); }
private CommandResult RunProcess(string executable, string args, StreamForwarder stdOut, StreamForwarder stdErr) { Task taskOut = null; Task taskErr = null; CurrentProcess = CreateProcess(executable, args); CurrentProcess.Start(); try { taskOut = stdOut.BeginRead(CurrentProcess.StandardOutput); } catch (System.InvalidOperationException e) { if (!e.Message.Equals("The collection has been marked as complete with regards to additions.")) { throw; } } try { taskErr = stdErr.BeginRead(CurrentProcess.StandardError); } catch (System.InvalidOperationException e) { if (!e.Message.Equals("The collection has been marked as complete with regards to additions.")) { throw; } } CurrentProcess.WaitForExit(); var tasksToAwait = new List <Task>(); if (taskOut != null) { tasksToAwait.Add(taskOut); } if (taskErr != null) { tasksToAwait.Add(taskErr); } if (tasksToAwait.Any()) { Task.WaitAll(tasksToAwait.ToArray()); } var result = new CommandResult( CurrentProcess.StartInfo, CurrentProcess.ExitCode, stdOut?.CapturedOutput ?? CurrentProcess.StandardOutput.ReadToEnd(), stdErr?.CapturedOutput ?? CurrentProcess.StandardError.ReadToEnd()); return(result); }
private Task<CommandResult> RunProcessAsync(string executable, string args, StreamForwarder stdOut, StreamForwarder stdErr) { Task taskOut = null; Task taskErr = null; CurrentProcess = CreateProcess(executable, args); CurrentProcess.Start(); try { taskOut = stdOut.BeginRead(CurrentProcess.StandardOutput); } catch (System.InvalidOperationException e) { if (!e.Message.Equals("The collection has been marked as complete with regards to additions.")) { throw; } } try { taskErr = stdErr.BeginRead(CurrentProcess.StandardError); } catch (System.InvalidOperationException e) { if (!e.Message.Equals("The collection has been marked as complete with regards to additions.")) { throw; } } var tcs = new TaskCompletionSource<CommandResult>(); CurrentProcess.Exited += (sender, arg) => { var tasksToAwait = new List<Task>(); if (taskOut != null) { tasksToAwait.Add(taskOut); } if (taskErr != null) { tasksToAwait.Add(taskErr); } if (tasksToAwait.Any()) { try { Task.WaitAll(tasksToAwait.ToArray()); } catch (System.ObjectDisposedException e) { taskErr = null; taskOut = null; } } var result = new CommandResult( CurrentProcess.StartInfo, CurrentProcess.ExitCode, stdOut?.CapturedOutput ?? CurrentProcess.StandardOutput.ReadToEnd(), stdErr?.CapturedOutput ?? CurrentProcess.StandardError.ReadToEnd()); tcs.SetResult(result); }; return tcs.Task; }