6 releases
0.1.5 | Aug 22, 2019 |
---|---|
0.1.4 | Jul 9, 2019 |
#1435 in Asynchronous
22 downloads per month
33KB
614 lines
Bawawa: project management
Usage
First, add this to your Cargo.toml
:
[dependencies]
bawawa = "0.1"
Next, add this to your crate:
extern crate bawawa;
License
This project is licensed under either of
- Apache License, Version 2.0, (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)
- MIT license (LICENSE-MIT or http://opensource.org/licenses/MIT)
at your option.
Contribution
Unless you explicitly state otherwise, any contribution intentionally submitted
for inclusion in bawawa
by you, as defined in the Apache-2.0 license, shall be
dual licensed as above, without any additional terms or conditions.
lib.rs
:
process management
this module provides some wrapping around the standard library's
std::process::Command
and std::process::Child
and associated
types.
Here we provide an opinionated API where we capture standard inputs and outputs by default. The errors are also wrapped to provide better understanding of what did fail (especially the PID or the command line).
There are a couple of items to keep in mind when utilising this API:
- as soon as
Process
is dropped the associated process will be terminated; Process
captures Stdout and Stderr, if you don't read the standard output it won't be visible on your terminal;Process
control Stdin too- the API utilizes the
Future
framework. If you don't push it in a runtime or callwait
the functions will do nothing.
the Program
Program
is an object that guarantees (within reason) the existence of a
program within the execution environment. When constructing, the Program
is checked so that once created it is known if it exists and if it has
appropriate execution rights.
#
let rustc = Program::new("rustc".to_owned())?;
the Command
this is the command line, the Program
, the parameters and the associated
environment variables necessary to spawn a new Process
.
#
let mut get_rustc_version = Command::new(rustc);
get_rustc_version.arguments(&["--version"]);
println!("{}", get_rustc_version);
spawn a Process
Once the Command
is ready with the appropriate parameter it is possible
to spawn a Process
. The trait Control
allows to follow the life
cycle of the spawned Process
.
#
let process = Process::spawn(get_rustc_version)?;
println!("spawned command: '{}' (PID: {})", process.command(), process.id());
We provide functions to capture the standard output and standard error output
utilising the StandardOutput::capture_stdout
or StandardError::capture_stderr
and to send items to the standard inputs with StandardInput::send_stdin
.
#
let mut capture_stdout = process
.capture_stdout(
// specify the codec, the way to decode data
// from the captured output. Here we read line
// by line.
tokio_codec::LinesCodec::new()
)
.wait(); // from the _futures_ crate's Stream trait
println!("compiler: {}", capture_stdout.next().unwrap()?);
// compiler: rustc 1.35.0 (3c235d560 2019-05-20)
Dependencies
~6.5MB
~122K SLoC