public static string Command(string executable, string arguments, string workingDirectory) { var stdOutBuffer = new StringBuilder(); var stdErrBuffer = new StringBuilder(); var command = CliWrap.Cli.Wrap(executable).WithArguments( args => args .Add(arguments.Split()) ) .WithWorkingDirectory(workingDirectory) .WithStandardOutputPipe(PipeTarget.ToStringBuilder(stdOutBuffer)) .WithStandardErrorPipe(PipeTarget.ToStringBuilder(stdErrBuffer)); try { using var task = command.ExecuteAsync().Task; task.Wait(); } catch (AggregateException) { throw new IOException(stdErrBuffer.ToString()); } return(stdOutBuffer.ToString()); }
internal static async Task <string> ExecuteInternal(Action <ArgumentsBuilder> configure, CancellationToken cancellationToken) { var toolPath = ToolPath; ThrowIfNull(toolPath, nameof(Emulator)); var builder = new ArgumentsBuilder(); configure(builder); var args = builder.Build(); Logger.WriteLine($"{toolPath} {args}", LogLevel.Normal); var stdErrBuffer = new StringBuilder(); var stdOutBuffer = new StringBuilder(); var stdOut = PipeTarget.Merge(PipeTarget.ToStringBuilder(stdOutBuffer), PipeTarget.ToDelegate(l => Logger.WriteLine(l, LogLevel.Verbose))); await Cli.Wrap(toolPath) .WithArguments(args) .WithStandardErrorPipe(PipeTarget.ToStringBuilder(stdErrBuffer)) .WithStandardOutputPipe(stdOut) .ExecuteAsync(cancellationToken); var stdErr = stdErrBuffer.ToString().Trim(); if (!string.IsNullOrEmpty(stdErr)) { throw new Exception(stdErr); } return(stdOutBuffer.ToString().Trim()); }
public async Task <string> DownloadMediaFile(string id, string outputDirectory, string _, CancellationToken ct) { var tcs = new TaskCompletionSource <object>(); var stdout = new StringBuilder(); var stderr = new StringBuilder(); var command = $"youtube-dl -o \"%(title)s-%(id)s.%(ext)s\" -f worst --write-info-json \"{id}\""; var cmd = Cli.Wrap("youtube-dl") .WithArguments($"-o \"%(title)s-%(id)s.%(ext)s\" -f worst --write-info-json \"{id}\"") .WithWorkingDirectory(outputDirectory) .WithStandardOutputPipe(PipeTarget.ToStringBuilder(stdout)) .WithStandardErrorPipe(PipeTarget.ToStringBuilder(stderr)); try { await cmd.ExecuteAsync(ct); } catch (Exception) { throw new Exception(stderr.ToString()); } var fileInfo = GetFileInfo(stdout.ToString(), outputDirectory); return(fileInfo.FileName); }
public static async Task <bool> InstallPackage(string packageName, CancellationToken cancellationToken) { Console.WriteLine($"npm install -g {packageName}"); var stdErrBuffer = new StringBuilder(); var stdOut = PipeTarget.ToDelegate(l => Console.WriteLine(l)); await Cli.Wrap("npm") .WithArguments($"install -g {packageName}") .WithStandardOutputPipe(stdOut) .WithStandardErrorPipe(PipeTarget.ToStringBuilder(stdErrBuffer)) .ExecuteAsync(cancellationToken); if (cancellationToken.IsCancellationRequested) { return(false); } var errorOutput = stdErrBuffer.ToString().Trim(); if (string.IsNullOrEmpty(errorOutput)) { return(true); } throw new Exception(errorOutput); }
internal static async Task ExecuteInternal(Action <ArgumentsBuilder> configure, CancellationToken cancellationToken) { ThrowIfNull(ToolPath, nameof(SdkManager)); var stdErrBuffer = new StringBuilder(); await Cli.Wrap(ToolPath) .WithArguments(configure) .WithValidation(CommandResultValidation.None) .WithStandardErrorPipe(PipeTarget.ToStringBuilder(stdErrBuffer)) .WithStandardOutputPipe(PipeTarget.ToDelegate(l => Logger.WriteLine(l, LogLevel.Detailed))) .WithStandardInputPipe(PipeSource.FromString("y")) .ExecuteAsync(cancellationToken); var stdErr = stdErrBuffer.ToString().Trim(); if (!string.IsNullOrEmpty(stdErr)) { if (stdErr.Split('\n').Select(x => x.Trim()).All(x => x.StartsWith("Warning:"))) { Logger.WriteWarning(stdErr); } else { throw new Exception(stdErr); } } }
private static async Task Execute(string args, LogLevel logLevel, CancellationToken cancellationToken) { Logger.WriteLine($"{DotNetExe.FullPath} {args}", LogLevel.Normal); var stdErrBuffer = new StringBuilder(); var stdOut = PipeTarget.ToDelegate(l => Logger.WriteLine(l, logLevel)); var stdErr = PipeTarget.ToStringBuilder(stdErrBuffer); var result = await Cli.Wrap(DotNetExe.FullPath) .WithArguments(args) .WithStandardErrorPipe(stdOut) .WithStandardErrorPipe(stdErr) .WithValidation(CommandResultValidation.None) .ExecuteAsync(cancellationToken) .ConfigureAwait(false); var error = stdErrBuffer.ToString().Trim(); if (!string.IsNullOrEmpty(error)) { throw new Exception(error); } if (result.ExitCode > 0) { throw new Exception($"The dotnet tool unexpectidly exited without any error output with code: {result.ExitCode}"); } }
public static EsiSystem ConvertTextSchema(EsiContext ctxt, FileInfo file) { var exeDir = new FileInfo(Assembly.GetExecutingAssembly().Location).Directory.FullName; using (var memstream = new MemoryStream()) { var errorStringBuilder = new StringBuilder(); var capnpCmd = Cli.Wrap("capnp") .WithEnvironmentVariables(new Dictionary <string, string>() { ["LD_LIBRARY_PATH"] = exeDir }) .WithArguments($"compile -I{Path.Join(Esi.Utils.RootDir.FullName, "capnp.convert")} -o- {file.FullName}") .WithStandardOutputPipe(PipeTarget.ToStream(memstream)) .WithStandardErrorPipe(PipeTarget.ToStringBuilder(errorStringBuilder)) .WithValidation(CommandResultValidation.ZeroExitCode); try { Task.Run(async() => await capnpCmd.ExecuteAsync()).Wait(); } catch (AggregateException ex) { if (ex.InnerException is CommandExecutionException cee) { ctxt.Log.Error($"CapNProto Error:\n{errorStringBuilder.ToString()}"); } ExceptionDispatchInfo.Capture(ex.InnerException).Throw(); } Debug.Assert(memstream.Length > 0); memstream.Seek(0, SeekOrigin.Begin); return(ConvertFromCGRMessage(ctxt, memstream)); } }
public async Task Serialize(TestDescription testDescription) { var extension = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? ".exe" : ""; var execPath = Path.Combine(testDescription.Directory, testDescription.Name + extension); var standardOutput = new StringBuilder(); var errorOutput = new StringBuilder(); try { await Cli.Wrap(execPath) .WithArguments("Serialize") .WithStandardOutputPipe(PipeTarget.ToStringBuilder(standardOutput)) .WithStandardErrorPipe(PipeTarget.ToStringBuilder(errorOutput)) .ExecuteAsync(); } catch (Exception e) { throw new Exception("Failed to run serialization for version " + testDescription.Name, e); } finally { Console.WriteLine(errorOutput.ToString()); Console.WriteLine(standardOutput.ToString()); } }
internal static async Task ExecuteInternal(Action <ArgumentsBuilder> configure, CancellationToken cancellationToken) { if (cancellationToken.IsCancellationRequested) { return; } var builder = new ArgumentsBuilder(); configure(builder); var args = builder.Build(); Logger.WriteLine($"{ToolPath} {args}", LogLevel.Normal); var stdOutBuffer = new StringBuilder(); var stdOut = PipeTarget.Merge(PipeTarget.ToStringBuilder(stdOutBuffer), PipeTarget.ToDelegate(l => Logger.WriteLine(l, LogLevel.Verbose))); var stdError = PipeTarget.ToDelegate(l => { if (string.IsNullOrEmpty(l)) { return; } // Suppress errors Logger.WriteWarning(l); }); var result = await Cli.Wrap(ToolPath) .WithArguments(args) .WithValidation(CommandResultValidation.None) .WithStandardErrorPipe(stdError) .WithStandardOutputPipe(stdOut) .ExecuteAsync(cancellationToken); }
private static async Task <bool> IsValidVideoFile(FileSystemInfo file, FrameFinderOptions frameFinderOptions) { var standardOutput = new StringBuilder(); var standardErrorOutput = new StringBuilder(); var result = await Cli.Wrap(frameFinderOptions.FFprobeBinaryPath) .WithArguments($"-print_format json -show_format -show_streams \"{file.FullName}\"") .WithStandardOutputPipe(PipeTarget.ToStringBuilder(standardOutput)) .WithStandardErrorPipe(PipeTarget.ToStringBuilder(standardErrorOutput)) .WithValidation(CommandResultValidation.None) .ExecuteAsync(); if (result.ExitCode == 0) { var json = standardOutput.ToString(); var parsed = JsonSerializer.Deserialize <FFprobeOutput>(json); if (parsed?.Format.Duration == null) { return(false); } var parsedDuration = double.Parse(parsed.Format.Duration, CultureInfo.InvariantCulture); var duration = TimeSpan.FromSeconds(parsedDuration); return(duration > frameFinderOptions.MinimumIntroTime); } return(false); }
private static async Task <string> ExecuteInternal(Action <ArgumentsBuilder> configure, CancellationToken cancellationToken, PipeSource stdInput = null) { var toolPath = ToolPath; ThrowIfNull(toolPath, nameof(AvdManager)); var builder = new ArgumentsBuilder(); configure(builder); var args = builder.Build(); Logger.WriteLine($"{toolPath} {args}", LogLevel.Normal); var errorBuffer = new List <string>(); var stdOutBuffer = new StringBuilder(); var stdOut = PipeTarget.Merge(PipeTarget.ToStringBuilder(stdOutBuffer), PipeTarget.ToDelegate(l => Logger.WriteLine(l, LogLevel.Verbose))); var stdErr = PipeTarget.ToDelegate(l => { if (string.IsNullOrEmpty(l)) { return; } else if (l.Contains("Warning: ")) { Logger.WriteWarning(l); } else { errorBuffer.Add(l); } }); var cmd = Cli.Wrap(toolPath) .WithArguments(args) .WithValidation(CommandResultValidation.None) .WithStandardErrorPipe(stdErr) .WithStandardOutputPipe(stdOut); if (stdInput != null) { cmd = cmd.WithStandardInputPipe(stdInput); } await cmd.ExecuteAsync(cancellationToken); if (errorBuffer.Any()) { throw new Exception(string.Join(Environment.NewLine, errorBuffer)); } return(stdOutBuffer.ToString().Trim()); }
public static async Task Build(string projectPath, string baseWorkingDirectory, IDictionary <string, string> props, CancellationToken cancellationToken, string target = null) { if (string.IsNullOrEmpty(ToolPath)) { throw new Exception("No installation of Visual Studio could be found. Could not locate msbuild."); } if (!props.ContainsKey("Configuration")) { props.Add("Configuration", "Release"); } if (!props.ContainsKey("Verbosity")) { props.Add("Verbosity", "Minimal"); } var stdErrBuffer = new StringBuilder(); var result = await Cli.Wrap(ToolPath) .WithArguments(b => { b.Add(projectPath); b.Add("/r"); if (!string.IsNullOrEmpty(target)) { b.Add($"/t:{target}"); } foreach ((var key, var value) in props) { b.Add($"/p:{key}={value}"); } var logoutput = Path.Combine(baseWorkingDirectory, "logs", $"{Path.GetFileNameWithoutExtension(projectPath)}.binlog"); b.Add($"/bl:{logoutput}"); }) .WithStandardOutputPipe(PipeTarget.ToDelegate(l => Logger.WriteLine(l, LogLevel.Normal))) .WithStandardErrorPipe(PipeTarget.ToStringBuilder(stdErrBuffer)) .WithValidation(CommandResultValidation.None) .ExecuteAsync(cancellationToken) .ConfigureAwait(false); var error = stdErrBuffer.ToString().Trim(); if (!string.IsNullOrEmpty(error)) { throw new Exception(error); } }
/// <summary> /// Executes the command asynchronously. /// The result of this execution contains the standard output and standard error streams buffered in-memory as strings. /// This method can be awaited. /// </summary> public static CommandTask <BufferedCommandResult> ExecuteBufferedAsync( this Command command, Encoding standardOutputEncoding, Encoding standardErrorEncoding, CancellationToken cancellationToken = default) { var stdOutBuffer = new StringBuilder(); var stdErrBuffer = new StringBuilder(); var stdOutPipe = PipeTarget.Merge( command.StandardOutputPipe, PipeTarget.ToStringBuilder(stdOutBuffer, standardOutputEncoding) ); var stdErrPipe = PipeTarget.Merge( command.StandardErrorPipe, PipeTarget.ToStringBuilder(stdErrBuffer, standardErrorEncoding) ); var commandPiped = command .WithStandardOutputPipe(stdOutPipe) .WithStandardErrorPipe(stdErrPipe) .WithValidation(CommandResultValidation.None); // disable validation because we have our own return(commandPiped .ExecuteAsync(cancellationToken) .Select(r => { // Transform the result var result = new BufferedCommandResult( r.ExitCode, r.StartTime, r.ExitTime, stdOutBuffer.ToString(), stdErrBuffer.ToString() ); // We perform validation separately here because we want to include stderr in the exception as well if (result.ExitCode != 0 && command.Validation.IsZeroExitCodeValidationEnabled()) { throw CommandExecutionException.ExitCodeValidation( command.TargetFilePath, command.Arguments, result.ExitCode, result.StandardError.Trim() ); } return result; })); }
private async Task <CommandResult> RunAsyncInner( IEnumerable <string> args, string workingDir, IDictionary <string, string?> additionalEnv, Action <string>?onStandardOutput = null, Action <string>?onStandardError = null, EventLogFile?eventLogFile = null, CancellationToken cancellationToken = default) { var stdOutBuffer = new StringBuilder(); var stdOutPipe = PipeTarget.ToStringBuilder(stdOutBuffer); if (onStandardOutput != null) { stdOutPipe = PipeTarget.Merge(stdOutPipe, PipeTarget.ToDelegate(onStandardOutput)); } var stdErrBuffer = new StringBuilder(); var stdErrPipe = PipeTarget.ToStringBuilder(stdErrBuffer); if (onStandardError != null) { stdErrPipe = PipeTarget.Merge(stdErrPipe, PipeTarget.ToDelegate(onStandardError)); } var pulumiCmd = Cli.Wrap("pulumi") .WithArguments(PulumiArgs(args, eventLogFile), escape: true) .WithWorkingDirectory(workingDir) .WithEnvironmentVariables(PulumiEnvironment(additionalEnv, debugCommands: eventLogFile != null)) .WithStandardOutputPipe(stdOutPipe) .WithStandardErrorPipe(stdErrPipe) .WithValidation(CommandResultValidation.None); // we check non-0 exit code ourselves var pulumiCmdResult = await pulumiCmd.ExecuteAsync(cancellationToken); var result = new CommandResult( pulumiCmdResult.ExitCode, standardOutput: stdOutBuffer.ToString(), standardError: stdErrBuffer.ToString()); if (pulumiCmdResult.ExitCode != 0) { throw CommandException.CreateFromResult(result); } else { return(result); } }
public static async Task <ConversionResult> Docx2HubAsync(string inputDocxPath) { if (!File.Exists(inputDocxPath)) { throw new FileNotFoundException($"{nameof(inputDocxPath)} does not exists"); } ConversionResult res = null; var targetDir = Path.GetDirectoryName(inputDocxPath); var stdOutBuffer = new StringBuilder(); var stdErrBuffer = new StringBuilder(); var script = "/opt/docx2hub/docx2hub.sh"; var cmd = CliWrap.Cli.Wrap("/bin/bash") .WithArguments($"-c \"{script} -o {targetDir} '{inputDocxPath}'\"") .WithStandardOutputPipe(PipeTarget.ToStringBuilder(stdOutBuffer)) .WithStandardErrorPipe(PipeTarget.ToStringBuilder(stdErrBuffer)) .WithValidation(CommandResultValidation.None); var expectedLogPath = Path.Combine(Path.GetDirectoryName(inputDocxPath), Path.GetFileNameWithoutExtension(inputDocxPath) + ".log"); var expectedResultFilePath = Path.Combine(Path.GetDirectoryName(inputDocxPath), Path.GetFileNameWithoutExtension(inputDocxPath) + ".xml"); try { var cmdRes = await cmd.ExecuteAsync(); res = new ConversionResult() { StdErr = stdErrBuffer.ToString(), StdOut = stdOutBuffer.ToString(), ExitCode = cmdRes.ExitCode, StartTime = cmdRes.StartTime, ExitTime = cmdRes.ExitTime, RunTime = cmdRes.RunTime, Log = ReadLog(expectedLogPath), ResultFilePath = File.Exists(expectedResultFilePath) ? expectedResultFilePath : null }; } catch (Exception ex) { res = new ConversionResult() { StdErr = stdErrBuffer.ToString(), StdOut = stdOutBuffer.ToString(), Message = ex.Message, Log = ReadLog(expectedLogPath), ResultFilePath = File.Exists(expectedResultFilePath) ? expectedResultFilePath : null }; } return(res); }
private static async Task ExecuteInternal(Action <ArgumentsBuilder> configure, CancellationToken cancellationToken) { ThrowIfNull(ToolPath, nameof(SdkManager)); var stdErrBuffer = new StringBuilder(); await Cli.Wrap(ToolPath) .WithArguments(configure) .WithStandardErrorPipe(PipeTarget.ToStringBuilder(stdErrBuffer)) .WithStandardOutputPipe(PipeTarget.ToDelegate(l => Logger.WriteLine(l, LogLevel.Detailed))) .WithStandardInputPipe(PipeSource.FromString("y")) .ExecuteAsync(cancellationToken); var stdErr = stdErrBuffer.ToString().Trim(); if (!string.IsNullOrEmpty(stdErr)) { throw new Exception(stdErr); } }
internal static async Task <string> ExecuteInternal(Action <ArgumentsBuilder> configure, CancellationToken cancellationToken) { if (cancellationToken.IsCancellationRequested) { return(null); } var toolPath = ToolPath; var builder = new ArgumentsBuilder(); configure(builder); var args = builder.Build(); Logger.WriteLine($"{toolPath} {args}", LogLevel.Normal); var stdErrBuffer = new StringBuilder(); var stdOutBuffer = new StringBuilder(); var stdOut = PipeTarget.Merge(PipeTarget.ToStringBuilder(stdOutBuffer), PipeTarget.ToDelegate(l => Logger.WriteLine(l, LogLevel.Verbose))); var result = await Cli.Wrap(toolPath) .WithArguments(args) .WithValidation(CommandResultValidation.None) .WithStandardErrorPipe(PipeTarget.ToStringBuilder(stdErrBuffer)) .WithStandardOutputPipe(stdOut) .ExecuteAsync(cancellationToken); var stdErr = stdErrBuffer.ToString().Trim(); if (!string.IsNullOrEmpty(stdErr)) { if (stdErr.Split('\n').Select(x => x.Trim()).All(x => x.StartsWith("Warning:", StringComparison.InvariantCultureIgnoreCase))) { Logger.WriteWarning(stdErr); } else { throw new Exception(stdErr); } } return(stdOutBuffer.ToString().Trim()); }
public async Task <string> Compress(string file, string directory, CancellationToken ct) { var resultFile = GetResultFile(file); var stderr = new StringBuilder(); var cmd = Cli.Wrap("ffmpeg") .WithArguments($"-y -i \"{file}\" -ac 1 -c:a libopus -af \"highpass=f=200,lowpass=f=4000\" -ar 16000 -b:a 8K -vbr constrained \"{resultFile}\"") .WithWorkingDirectory(directory) .WithStandardErrorPipe(PipeTarget.ToStringBuilder(stderr)); try { await cmd.ExecuteAsync(ct); } catch (Exception ex) { throw new Exception(stderr.ToString(), ex); } return(Path.GetFileName(resultFile)); }
public override async Task <ExecutionResult> RunAsync(IStepExecutionContext context) { // It's important that the CHROM names match (NC_000962.3) else it will report 0 var ouput = Session.CreateFolder(); Output = ouput.GetFile("output"); var errorBuilder = new StringBuilder(); var command = Cli .Wrap("bedtools") .WithArguments(args => args .Add("coverage") .Add("-a") .Add(FileA.AbsolutePath) .Add("-b") .Add(FileB.AbsolutePath)) .WithStandardOutputPipe(PipeTarget.ToFile(Output.AbsolutePath)) .WithStandardErrorPipe(PipeTarget.ToStringBuilder(errorBuilder)); await command.ExecuteAsync(); return(ExecutionResult.Next()); }
public IEnumerable <GitCommit> ForRepository(IAnalysisLocation analysisLocation, string gitPath) { var stdErrBuffer = new StringBuilder(); var stdOutBuffer = new StringBuilder(); var command = CliWrap.Cli.Wrap(gitPath).WithArguments( args => args .Add("log") // Commit hash, author date, strict ISO 8601 format // Lists commits as '583d813db3e28b9b44a29db352e2f0e1b4c6e420 2021-05-19T15:24:24-04:00' // Source: https://git-scm.com/docs/pretty-formats .Add("--pretty=format:%H %aI") ) .WithValidation(CommandResultValidation.None) .WithWorkingDirectory(analysisLocation.Path) .WithStandardOutputPipe(PipeTarget.ToStringBuilder(stdOutBuffer)) .WithStandardErrorPipe(PipeTarget.ToStringBuilder(stdErrBuffer)); using var task = command.ExecuteAsync().Task; task.Wait(); if (task.Result.ExitCode != 0) { throw new GitException($"{CliOutput.Exception_Git_EncounteredError}\n{stdErrBuffer}"); } var commitsWithDates = stdOutBuffer.ToString().Split("\n"); var commits = new List <GitCommit>(); foreach (var commitAndDate in commitsWithDates) { var separated = commitAndDate.Split(" "); commits.Add(new GitCommit( separated[0], DateTimeOffset.ParseExact(separated[1], "yyyy'-'MM'-'dd'T'HH':'mm':'ssK", null) )); } return(commits); }