Struct std::process::Stdio
pub struct Stdio(_);
Describes what to do with a standard I/O stream for a child process when passed to the stdin
, stdout
, and stderr
methods of Command
.
Implementations
impl Stdio
pub fn piped() -> Stdio
A new pipe should be arranged to connect the parent and child processes.
Examples
With stdout:
use std::process::{Command, Stdio}; let output = Command::new("echo") .arg("Hello, world!") .stdout(Stdio::piped()) .output() .expect("Failed to execute command"); assert_eq!(String::from_utf8_lossy(&output.stdout), "Hello, world!\n"); // Nothing echoed to console
With stdin:
use std::io::Write; use std::process::{Command, Stdio}; let mut child = Command::new("rev") .stdin(Stdio::piped()) .stdout(Stdio::piped()) .spawn() .expect("Failed to spawn child process"); let mut stdin = child.stdin.take().expect("Failed to open stdin"); std::thread::spawn(move || { stdin.write_all("Hello, world!".as_bytes()).expect("Failed to write to stdin"); }); let output = child.wait_with_output().expect("Failed to read stdout"); assert_eq!(String::from_utf8_lossy(&output.stdout), "!dlrow ,olleH");
Writing more than a pipe buffer’s worth of input to stdin without also reading stdout and stderr at the same time may cause a deadlock. This is an issue when running any program that doesn’t guarantee that it reads its entire stdin before writing more than a pipe buffer’s worth of output. The size of a pipe buffer varies on different targets.
pub fn inherit() -> Stdio
The child inherits from the corresponding parent descriptor.
Examples
With stdout:
use std::process::{Command, Stdio}; let output = Command::new("echo") .arg("Hello, world!") .stdout(Stdio::inherit()) .output() .expect("Failed to execute command"); assert_eq!(String::from_utf8_lossy(&output.stdout), ""); // "Hello, world!" echoed to console
With stdin:
use std::process::{Command, Stdio}; use std::io::{self, Write}; let output = Command::new("rev") .stdin(Stdio::inherit()) .stdout(Stdio::piped()) .output() .expect("Failed to execute command"); print!("You piped in the reverse of: "); io::stdout().write_all(&output.stdout).unwrap();
pub fn null() -> Stdio
This stream will be ignored. This is the equivalent of attaching the stream to /dev/null
.
Examples
With stdout:
use std::process::{Command, Stdio}; let output = Command::new("echo") .arg("Hello, world!") .stdout(Stdio::null()) .output() .expect("Failed to execute command"); assert_eq!(String::from_utf8_lossy(&output.stdout), ""); // Nothing echoed to console
With stdin:
use std::process::{Command, Stdio}; let output = Command::new("rev") .stdin(Stdio::null()) .stdout(Stdio::piped()) .output() .expect("Failed to execute command"); assert_eq!(String::from_utf8_lossy(&output.stdout), ""); // Ignores any piped-in input
Trait Implementations
impl Debug for Stdio
fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
impl From<ChildStderr> for Stdio
fn from(child: ChildStderr) -> Stdio
Converts a ChildStderr
into a Stdio
Examples
use std::process::{Command, Stdio}; let reverse = Command::new("rev") .arg("non_existing_file.txt") .stderr(Stdio::piped()) .spawn() .expect("failed reverse command"); let cat = Command::new("cat") .arg("-") .stdin(reverse.stderr.unwrap()) // Converted into a Stdio here .output() .expect("failed echo command"); assert_eq!( String::from_utf8_lossy(&cat.stdout), "rev: cannot open non_existing_file.txt: No such file or directory\n" );
impl From<ChildStdin> for Stdio
fn from(child: ChildStdin) -> Stdio
Converts a ChildStdin
into a Stdio
Examples
ChildStdin
will be converted to Stdio
using Stdio::from
under the hood.
use std::process::{Command, Stdio}; let reverse = Command::new("rev") .stdin(Stdio::piped()) .spawn() .expect("failed reverse command"); let _echo = Command::new("echo") .arg("Hello, world!") .stdout(reverse.stdin.unwrap()) // Converted into a Stdio here .output() .expect("failed echo command"); // "!dlrow ,olleH" echoed to console
impl From<ChildStdout> for Stdio
fn from(child: ChildStdout) -> Stdio
Converts a ChildStdout
into a Stdio
Examples
ChildStdout
will be converted to Stdio
using Stdio::from
under the hood.
use std::process::{Command, Stdio}; let hello = Command::new("echo") .arg("Hello, world!") .stdout(Stdio::piped()) .spawn() .expect("failed echo command"); let reverse = Command::new("rev") .stdin(hello.stdout.unwrap()) // Converted into a Stdio here .output() .expect("failed reverse command"); assert_eq!(reverse.stdout, b"!dlrow ,olleH\n");
impl From<File> for Stdio
fn from(file: File) -> Stdio
Converts a File
into a Stdio
Examples
File
will be converted to Stdio
using Stdio::from
under the hood.
use std::fs::File; use std::process::Command; // With the `foo.txt` file containing `Hello, world!" let file = File::open("foo.txt").unwrap(); let reverse = Command::new("rev") .stdin(file) // Implicit File conversion into a Stdio .output() .expect("failed reverse command"); assert_eq!(reverse.stdout, b"!dlrow ,olleH");
fn from(fd: OwnedFd) -> Stdio
Performs the conversion.
fn from(handle: OwnedHandle) -> Stdio
Performs the conversion.
unsafe fn from_raw_fd(fd: RawFd) -> Stdio
Constructs a new instance of Self
from the given raw file descriptor. Read more
Auto Trait Implementations
impl RefUnwindSafe for Stdio
impl Send for Stdio
impl Sync for Stdio
impl Unpin for Stdio
impl UnwindSafe for Stdio
Blanket Implementations
impl<T> From<T> for T
pub fn from(t: T) -> T
Performs the conversion.
pub fn into(self) -> U
Performs the conversion.
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
Performs the conversion.
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
Performs the conversion.
© 2010 The Rust Project Developers
Licensed under the Apache License, Version 2.0 or the MIT license, at your option.
https://doc.rust-lang.org/std/process/struct.Stdio.html