Struct CommandTrace

pub struct CommandTrace<'a> { /* private fields */ }

Implementations

impl<'a> CommandTrace<'a>

pub fn builder() -> CommandTraceBuilder<'a, ((), (), (), (), (), (), ())>

Create a builder for building CommandTrace. On the builder, call .command(...), .args(...)(optional), .envs(...)(optional), .current_dir(...)(optional), .status(...)(optional), .stdout(...)(optional), .stderr(...)(optional) to set the values of the fields. Finally, call .build() to create the instance of CommandTrace.

impl<'a> CommandTrace<'a>

pub fn trace_args<L>(&'a mut self, filter: L) -> &'a mut CommandTrace<'_>

where L: Into<Level>,

pub fn trace_envs<L>(&'a mut self, filter: L) -> &'a mut CommandTrace<'_>

where L: Into<Level>,

pub fn trace_current_dir<L>(&'a mut self, filter: L) -> &'a mut CommandTrace<'_>

where L: Into<Level>,

pub fn trace_status<L>(&'a mut self, filter: L) -> &'a mut CommandTrace<'_>

where L: Into<Level>,

pub fn trace_stdout<L>(&'a mut self, filter: L) -> &'a mut CommandTrace<'_>

where L: Into<Level>,

pub fn trace_stderr<L>(&'a mut self, filter: L) -> &'a mut CommandTrace<'_>

where L: Into<Level>,

Trait Implementations

impl<'a> CommandExtCheck for CommandTrace<'a>

type Error = CommandExtError

The error type for the result of checking for an error status

fn check(&mut self) -> Result<Output, Self::Error>

Check the result of a command, returning an error containing the output and error stream content if the status is not success

impl<'a> CommandWrap for CommandTrace<'a>

fn on_spawn(&mut self)

Called when the child process is spawned using [spawn]

fn on_output(&mut self)

Called when output is created using [output]

fn on_status(&mut self)

Called when status is obtained using [status]

fn after_output(&mut self, output: &Result<Output>)

Called when output is created using [output]

fn after_status(&mut self, status: &Result<ExitStatus>)

Called when status is obtained using [status]

fn on_arg<S: AsRef<OsStr>>(&mut self, arg: S)

Called when an arg is added using [arg]

fn on_args<I, S>(&mut self, args: I)

where I: IntoIterator<Item = S>, S: AsRef<OsStr>,

Called when args are added using [args]

fn on_env<K, V>(&mut self, key: K, val: V)

where K: AsRef<OsStr>, V: AsRef<OsStr>,

Called when environment variables are configured using env

fn on_envs<'a, I, K, V>(&mut self, vars: I)

where I: IntoIterator<Item = &'a (K, V)>, K: AsRef<OsStr> + 'a, V: AsRef<OsStr> + 'a,

Called when environment variables are configured using [envs]

fn on_env_remove<K: AsRef<OsStr>>(&mut self, key: K)

Called when environment variables are removed using [env_remove]

fn on_env_clear(&mut self)

Called when environment variables are cleared using [env_clear]

fn on_current_dir<P: AsRef<Path>>(&mut self, dir: P)

Called when the current directory is set using [current_dir]

fn on_stdin(&mut self, cfg: &Stdio)

Called when stdin is set using [stdin]

fn on_stdout(&mut self, cfg: &Stdio)

Called when stdout is set using [stdout]

fn on_stderr(&mut self, cfg: &Stdio)

Called when stderr is set using [stderr]

fn after_spawn(&mut self, child: &Result<Child>)

Called when the child process is spawned using [spawn]

fn arg<S: AsRef<OsStr>>(&mut self, arg: S) -> &mut Self

Adds an argument to pass to the program.

fn args<I, S>(&mut self, args: I) -> &mut Self

where I: IntoIterator<Item = S>, S: AsRef<OsStr>,

Adds multiple arguments to pass to the program.

fn env<K, V>(&mut self, key: K, val: V) -> &mut Self

where K: AsRef<OsStr>, V: AsRef<OsStr>,

Inserts or updates an explicit environment variable mapping.

fn envs<I, K, V>(&mut self, vars: I) -> &mut Self

where I: IntoIterator<Item = (K, V)>, K: AsRef<OsStr>, V: AsRef<OsStr>,

Inserts or updates multiple explicit environment variable mappings.

fn env_remove<K: AsRef<OsStr>>(&mut self, key: K) -> &mut Self

Removes an explicitly set environment variable and prevents inheriting it from a parent process.

fn env_clear(&mut self) -> &mut Self

Clears all explicitly set environment variables and prevents inheriting any parent process environment variables.

fn current_dir<P: AsRef<Path>>(&mut self, dir: P) -> &mut Self

Sets the working directory for the child process.

fn stdin<T: Into<Stdio>>(&mut self, cfg: T) -> &mut Self

Configuration for the child process’s standard input (stdin) handle.

fn stdout<T: Into<Stdio>>(&mut self, cfg: T) -> &mut Self

Configuration for the child process’s standard output (stdout) handle.

fn stderr<T: Into<Stdio>>(&mut self, cfg: T) -> &mut Self

Configuration for the child process’s standard error (stderr) handle.

fn spawn(&mut self) -> Result<Child>

Executes the command as a child process, returning a handle to it.

fn output(&mut self) -> Result<Output>

Executes the command as a child process, waiting for it to finish and collecting all of its output.

fn status(&mut self) -> Result<ExitStatus>

Executes a command as a child process, waiting for it to finish and collecting its status.

fn get_program(&self) -> &OsStr

Returns the path to the program that was given to Command::new.

fn get_args(&self) -> CommandArgs<'_>

Returns an iterator of the arguments that will be passed to the program.

fn get_envs(&self) -> CommandEnvs<'_>

Returns an iterator of the environment variables explicitly set for the child process.

fn get_current_dir(&self) -> Option<&Path>

Returns the working directory for the child process.

impl<'a> Debug for CommandTrace<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> From<&'a mut Command> for CommandTrace<'a>

fn from(value: &'a mut Command) -> Self

Converts to this type from the input type.

impl<'a> HasCommand for CommandTrace<'a>

fn command(&self) -> &Command

fn command_mut(&mut self) -> &mut Command