(Rust) Silence stderr and stdout, optionally rerouting it.

Stdout Gagging

println!("STDOUT GAGGING", );
println!("you will see this");
let shh = shh::stdout().unwrap();
println!("but not this");
drop(shh);
println!("and this");

Stderr Gagging

println!("STDERR GAGGING", );
eprintln!("you will see this");
let shh = shh::stderr().unwrap();
eprintln!("but not this");
drop(shh);
eprintln!("and this");

Redirecting Example

println!("REDIRECTING", );
use std::io::{Read, Write};

std::thread::spawn(move || {
    let mut shh = shh::stdout().unwrap();
    let mut stderr = std::io::stderr();
    loop {
        let mut buf = Vec::new();
        shh.read_to_end(&mut buf).unwrap();
        stderr.write_all(&buf).unwrap();
    }
});

println!("This should be printed on stderr");
eprintln!("This will be printed on stderr as well");

// This will exit and close the spawned thread.
// In most cases you will want to setup a channel and send a break signal to the loop,
// and then join the thread back into it once you are finished.

Scoping

The struct Shh implements the Drop trait. Upon going out of scope, the redirection is reset and resources are cleaned up. A Shh will only last for the scope, and where no local variable is used, the silencing will not work.

Example - Silencing Dropped Early

println!("you will see this");
shh::stdout().unwrap();        // Shh struct is created, and dropped, here
println!("and expect not to see this, but you will");

To fix this, just assign a local variable

println!("you will see this");
let shh = shh::stdout().unwrap();        // Shh struct is created here
println!("and expect not to see this");
drop(shh);    // and dropped here
println!("now it works!");