Struct apt_cmd::DpkgQuery

pub struct DpkgQuery(_);

Implementations

impl DpkgQuery

pub fn new() -> Self

pub async fn show_installed<I, S>(
    self,
    packages: I
) -> Result<(Child, Pin<Box<dyn Stream<Item = String>>>)> where
    I: IntoIterator<Item = S>,
    S: AsRef<OsStr>, 

pub async fn status(self) -> Result<()>

pub async fn spawn_with_stdout(self) -> Result<(Child, ChildStdout)>

Methods from Deref<Target = Command>

pub fn arg<S>(&mut self, arg: S) -> &mut Command where
    S: AsRef<OsStr>, 

Adds a single argument to pass to the program.

Examples

use async_process::Command;

let mut cmd = Command::new("echo");
cmd.arg("hello");
cmd.arg("world");

pub fn args<I, S>(&mut self, args: I) -> &mut Command where
    I: IntoIterator<Item = S>,
    S: AsRef<OsStr>, 

Adds multiple arguments to pass to the program.

Examples

use async_process::Command;

let mut cmd = Command::new("echo");
cmd.args(&["hello", "world"]);

pub fn env<K, V>(&mut self, key: K, val: V) -> &mut Command where
    K: AsRef<OsStr>,
    V: AsRef<OsStr>, 

Configures an environment variable for the new process.

Note that environment variable names are case-insensitive (but case-preserving) on Windows, and case-sensitive on all other platforms.

Examples

use async_process::Command;

let mut cmd = Command::new("ls");
cmd.env("PATH", "/bin");

pub fn envs<I, K, V>(&mut self, vars: I) -> &mut Command where
    I: IntoIterator<Item = (K, V)>,
    K: AsRef<OsStr>,
    V: AsRef<OsStr>, 

Configures multiple environment variables for the new process.

Note that environment variable names are case-insensitive (but case-preserving) on Windows, and case-sensitive on all other platforms.

Examples

use async_process::Command;

let mut cmd = Command::new("ls");
cmd.envs(vec![("PATH", "/bin"), ("TERM", "xterm-256color")]);

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

Removes an environment variable mapping.

Examples

use async_process::Command;

let mut cmd = Command::new("ls");
cmd.env_remove("PATH");

pub fn env_clear(&mut self) -> &mut Command

Removes all environment variable mappings.

Examples

use async_process::Command;

let mut cmd = Command::new("ls");
cmd.env_clear();

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

Configures the working directory for the new process.

Examples

use async_process::Command;

let mut cmd = Command::new("ls");
cmd.current_dir("/");

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

Configures the standard input (stdin) for the new process.

Examples

use async_process::{Command, Stdio};

let mut cmd = Command::new("cat");
cmd.stdin(Stdio::null());

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

Configures the standard output (stdout) for the new process.

Examples

use async_process::{Command, Stdio};

let mut cmd = Command::new("ls");
cmd.stdout(Stdio::piped());

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

Configures the standard error (stderr) for the new process.

Examples

use async_process::{Command, Stdio};

let mut cmd = Command::new("ls");
cmd.stderr(Stdio::piped());

pub fn reap_on_drop(&mut self, reap_on_drop: bool) -> &mut Command

Configures whether to reap the zombie process when Child is dropped.

When the process finishes, it becomes a “zombie” and some resources associated with it remain until Child::try_status(), Child::status(), or Child::output() collects its exit code.

If its exit code is never collected, the resources may leak forever. This crate has a background thread named “async-process” that collects such “zombie” processes and then “reaps” them, thus preventing the resource leaks.

The default value of this option is true.

Examples

use async_process::{Command, Stdio};

let mut cmd = Command::new("cat");
cmd.reap_on_drop(false);

pub fn kill_on_drop(&mut self, kill_on_drop: bool) -> &mut Command

Configures whether to kill the process when Child is dropped.

The default value of this option is false.

Examples

use async_process::{Command, Stdio};

let mut cmd = Command::new("cat");
cmd.kill_on_drop(true);

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

Executes the command and returns the Child handle to it.

If not configured, stdin, stdout and stderr will be set to Stdio::inherit().

After spawning the process, stdin, stdout, and stderr become unconfigured again.

Examples

use async_process::Command;

let child = Command::new("ls").spawn()?;

pub fn status(&mut self) -> impl Future<Output = Result<ExitStatus, Error>>

Executes the command, waits for it to exit, and returns the exit status.

If not configured, stdin, stdout and stderr will be set to Stdio::inherit().

After spawning the process, stdin, stdout, and stderr become unconfigured again.

Examples

use async_process::Command;

let status = Command::new("cp")
    .arg("a.txt")
    .arg("b.txt")
    .status()
    .await?;

pub fn output(&mut self) -> impl Future<Output = Result<Output, Error>>

Executes the command and collects its output.

If not configured, stdin will be set to Stdio::null(), and stdout and stderr will be set to Stdio::piped().

After spawning the process, stdin, stdout, and stderr become unconfigured again.

Examples

use async_process::Command;

let output = Command::new("cat")
    .arg("a.txt")
    .output()
    .await?;

Trait Implementations

impl<__AsMutT: ?Sized> AsMut<__AsMutT> for DpkgQuery where
    Command: AsMut<__AsMutT>, 

fn as_mut(&mut self) -> &mut __AsMutT

Performs the conversion.

impl Deref for DpkgQuery

type Target = Command

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for DpkgQuery

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.