cursive/examples/vpv.rs
2018-11-30 16:55:47 -08:00

135 lines
4.7 KiB
Rust

extern crate cursive;
extern crate pretty_bytes;
use std::io;
use cursive::traits::{Boxable, With};
use cursive::utils;
use cursive::views::{Canvas, Dialog, LinearLayout, ProgressBar};
use cursive::Cursive;
use pretty_bytes::converter::convert;
use std::thread;
use std::time;
// This example is a visual version of the `pv` tool.
fn main() {
let mut siv = Cursive::default();
// We'll use this channel to signal the end of the transfer
let cb_sink = siv.cb_sink().clone();
// Use a counter to track progress
let counter = utils::Counter::new(0);
let counter_copy = counter.clone();
let start = time::Instant::now();
// If an argument is given, it is the file we'll read from.
// Else, read from stdin.
let (source, len) = match std::env::args().nth(1) {
Some(source) => {
let meta = std::fs::metadata(&source).unwrap();
// If possible, read the file size to have a progress bar.
let len = meta.len();
(Some(source), if len > 0 { Some(len) } else { None })
}
None => (None, None),
};
// Start the copy in a separate thread
thread::spawn(move || {
// Copy to stdout - lock it for better performance.
let stdout = io::stdout();
let mut stdout = stdout.lock();
match source {
None => {
// Copy from stdin - lock it for better performance.
let stdin = io::stdin();
let stdin = stdin.lock();
let mut reader =
utils::ProgressReader::new(counter_copy, stdin);
// And copy!
io::copy(&mut reader, &mut stdout).unwrap();
}
Some(source) => {
// Copy from stdin - lock it for better performance.
let input = std::fs::File::open(source).unwrap();
let mut reader =
utils::ProgressReader::new(counter_copy, input);
// And copy!
io::copy(&mut reader, &mut stdout).unwrap();
}
}
// When we're done, shut down the application
cb_sink.send(Box::new(|s: &mut Cursive| s.quit())).unwrap();
});
// Add a single view: progress status
siv.add_layer(
Dialog::new().title("Copying...").content(
LinearLayout::vertical()
.child(
Canvas::new(counter.clone())
.with_draw(move |c, printer| {
let ticks = c.get() as f64;
let now = time::Instant::now();
let duration = now - start;
let seconds = duration.as_secs() as f64
+ duration.subsec_nanos() as f64 * 1e-9;
let speed = ticks / seconds;
// Print ETA if we have a file size
// Otherwise prints elapsed time.
if let Some(len) = len {
let remaining = (len as f64 - ticks) / speed;
printer.print(
(0, 0),
&format!(
"ETA: {:.1} seconds",
remaining
),
);
} else {
printer.print(
(0, 0),
&format!(
"Elapsed: {:.1} seconds",
seconds
),
);
}
printer.print(
(0, 1),
&format!("Copied: {}", convert(ticks)),
);
printer.print(
(0, 2),
&format!("Speed: {}/s", convert(speed)),
);
})
.fixed_size((25, 3)),
)
.with(|l| {
// If we have a file length, add a progress bar
if let Some(len) = len {
l.add_child(
ProgressBar::new()
.max(len as usize)
.with_value(counter.clone()),
);
}
}),
),
);
siv.set_fps(10);
siv.run();
}