Struct tauri::api::process::Command

pub struct Command { /* private fields */ }

Available on crate feature process-command-api only.

The type to spawn commands.

Implementations

impl Command

pub fn new<S: Into<String>>(program: S) -> Self

Creates a new Command for launching the given program.

pub fn new_sidecar<S: Into<String>>(program: S) -> Result<Self>

Creates a new Command for launching the given sidecar program.

A sidecar program is a embedded external binary in order to make your application work or to prevent users having to install additional dependencies (e.g. Node.js, Python, etc).

pub fn args<I, S>(self, args: I) -> Selfwhere I: IntoIterator<Item = S>, S: AsRef<str>,

Appends arguments to the command.

pub fn env_clear(self) -> Self

Clears the entire environment map for the child process.

pub fn envs(self, env: HashMap<String, String>) -> Self

Adds or updates multiple environment variable mappings.

pub fn current_dir(self, current_dir: PathBuf) -> Self

Sets the working directory for the child process.

pub fn encoding(self, encoding: &'static Encoding) -> Self

Sets the character encoding for stdout/stderr.

pub fn spawn(self) -> Result<(Receiver<CommandEvent>, CommandChild)>

Spawns the command.

Examples

use tauri::api::process::{Command, CommandEvent};
tauri::async_runtime::spawn(async move {
  let (mut rx, mut child) = Command::new("cargo")
    .args(["tauri", "dev"])
    .spawn()
    .expect("Failed to spawn cargo");

  let mut i = 0;
  while let Some(event) = rx.recv().await {
    if let CommandEvent::Stdout(line) = event {
      println!("got: {}", line);
      i += 1;
      if i == 4 {
        child.write("message from Rust\n".as_bytes()).unwrap();
        i = 0;
      }
    }
  }
});

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

Executes a command as a child process, waiting for it to finish and collecting its exit status. Stdin, stdout and stderr are ignored.

Examples

use tauri::api::process::Command;
let status = Command::new("which").args(["ls"]).status().unwrap();
println!("`which` finished with status: {:?}", status.code());

pub fn output(self) -> Result<Output>

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

Examples

use tauri::api::process::Command;
let output = Command::new("echo").args(["TAURI"]).output().unwrap();
assert!(output.status.success());
assert_eq!(output.stdout, "TAURI");

Trait Implementations

impl Debug for Command

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

Formats the value using the given formatter.

impl From<Command> for StdCommand

fn from(cmd: Command) -> StdCommand

Converts to this type from the input type.