holm/nushell
1
1
Fork 0
forked from extern/nushell
Code Issues Pull Requests Packages Projects Releases Wiki Activity

cp progress bar implementation (#8012)

Browse Source 
# NOTE
Clean duplicate of #7825
Sorry about all the mess guys... I got confuse with GitHub and and ended
up mankind that mess.
This the same code I just cleaned the commits.

# Description
Progress bar implementation for the `cp` command. Now if the flag `-p`
or `--progress` is set, then the user will be able to see the progress
of the file or files being copy


![progressbar_cp01](https://user-images.githubusercontent.com/38369407/213899494-0f6a4aa9-ee82-48c3-a1f1-1816f3fc1d9c.jpg)

![progressbar_cp02](https://user-images.githubusercontent.com/38369407/213899497-2f9e6e8c-fdd9-400b-bd8d-c59899ae0368.jpg)

# User-Facing Changes
A new flag (`--progress` `-p`) was added to the `cp` command 
Examples:
```nu
cp -p test_file.txt test_folder_1\
cp -r -p test_folder\* test_folder_1\
cp -r -p -i test_folder\* test_folder_1\
```

## Notes 
- The progress bar uses `std::io::{Read, Write}` instead of
`std::fs::copy` to get the progress. that means that when the progress
bar is used the copy process might be a bit slower.
- Progress bar for symbolic links TBD: Since symbolic links are usually
very light I think is not worth it to duplicate the function
`copy_symlink` just to add a progress bar that will be so fast to the
point is not needed, but.. for consistency purposes we might need to
added it, In that case I would have to pass the variable `progress` by
parameter (to not duplicate code unnecessary). If I do that i would have
to pass the `progress` var to every function to respect `copy_impl: impl
Fn(PathBuf, PathBuf, Span)`. Please let me know if this is not clear :p

---------

Co-authored-by: Reilly Wood <reilly.wood@icloud.com>
This commit is contained in:
Xoffio
2023-02-22 14:57:38 -05:00
committed by GitHub
parent f4a129a792
commit fc23c6721a
3 changed files with 385 additions and 71 deletions
Download Patch File Download Diff File Expand all files Collapse all files

191
crates/nu-command/src/filesystem/cp.rs
View File

@ -1,4 +1,5 @@
use std::fs::read_link;
use std::io::{BufReader, BufWriter, ErrorKind, Read, Write};
use std::path::PathBuf;
use nu_engine::env::current_dir;
@ -14,6 +15,7 @@ use nu_protocol::{
use super::util::try_interaction;
use crate::filesystem::util::FileStructure;
use crate::progress_bar;
const GLOB_PARAMS: nu_glob::MatchOptions = nu_glob::MatchOptions {
case_sensitive: true,
@ -61,6 +63,7 @@ impl Command for Cp {
"no symbolic links are followed, only works if -r is active",
Some('n'),
)
.switch("progress", "enable progress bar", Some('p'))
.category(Category::FileSystem)
}
@ -82,6 +85,7 @@ impl Command for Cp {
let recursive = call.has_flag("recursive");
let verbose = call.has_flag("verbose");
let interactive = call.has_flag("interactive");
let progress = call.has_flag("progress");
let current_dir_path = current_dir(engine_state, stack)?;
let source = current_dir_path.join(src.item.as_str());
@ -98,6 +102,7 @@ impl Command for Cp {
let ctrlc = engine_state.ctrlc.clone();
let span = call.head;
// Get an iterator with all the source files.
let sources: Vec<_> = match nu_glob::glob_with(&source.to_string_lossy(), GLOB_PARAMS) {
Ok(files) => files.collect(),
Err(e) => {
@ -179,8 +184,23 @@ impl Command for Cp {
Vec::new(),
));
} else if interactive && dst.exists() {
interactive_copy(interactive, src, dst, span, copy_file)
if progress {
interactive_copy(
interactive,
src,
dst,
span,
copy_file_with_progressbar,
)
} else {
interactive_copy(interactive, src, dst, span, copy_file)
}
} else if progress {
// uses std::io::copy to get the progress
// slower std::fs::copy but useful if user needs to see the progress
copy_file_with_progressbar(src, dst, span)
} else {
// uses std::fs::copy
copy_file(src, dst, span)
};
result.push(res);
@ -268,7 +288,19 @@ impl Command for Cp {
result.push(res);
} else if s.is_file() {
let res = if interactive && d.exists() {
interactive_copy(interactive, s, d, span, copy_file)
if progress {
interactive_copy(
interactive,
s,
d,
span,
copy_file_with_progressbar,
)
} else {
interactive_copy(interactive, s, d, span, copy_file)
}
} else if progress {
copy_file_with_progressbar(s, d, span)
} else {
copy_file(s, d, span)
};
@ -349,50 +381,95 @@ fn interactive_copy(
}
}
// This uses `std::fs::copy` to copy a file. There is another function called `copy_file_with_progressbar`
// which uses `read` and `write` instead. This is to get the progress of the copy. Try to keep the logic in
// this function in sync with `copy_file_with_progressbar`
fn copy_file(src: PathBuf, dst: PathBuf, span: Span) -> Value {
match std::fs::copy(&src, &dst) {
Ok(_) => {
let msg = format!("copied {:} to {:}", src.display(), dst.display());
Value::String { val: msg, span }
}
Err(e) => {
let message_src = format!(
"copying file '{src_display}' failed: {e}",
src_display = src.display()
);
let message_dst = format!(
"copying to destination '{dst_display}' failed: {e}",
dst_display = dst.display()
);
use std::io::ErrorKind;
let shell_error = match e.kind() {
ErrorKind::NotFound => {
if std::path::Path::new(&dst).exists() {
ShellError::FileNotFoundCustom(message_src, span)
} else {
ShellError::FileNotFoundCustom(message_dst, span)
}
}
ErrorKind::PermissionDenied => match std::fs::metadata(&dst) {
Ok(meta) => {
if meta.permissions().readonly() {
ShellError::PermissionDeniedError(message_dst, span)
} else {
ShellError::PermissionDeniedError(message_src, span)
Err(e) => convert_io_error(e, src, dst, span),
}
}
// This uses `read` and `write` to copy a file. There is another function called `copy_file`
// which uses `std::fs::copy` instead which is faster but does not provide progress updates for the copy. try to keep the
// logic in this function in sync with `copy_file`
fn copy_file_with_progressbar(src: PathBuf, dst: PathBuf, span: Span) -> Value {
let mut bytes_processed: u64 = 0;
let mut process_failed: Option<std::io::Error> = None;
let file_in = match std::fs::File::open(&src) {
Ok(file) => file,
Err(error) => return convert_io_error(error, src, dst, span),
};
let file_size = match file_in.metadata() {
Ok(metadata) => Some(metadata.len()),
_ => None,
};
let mut bar = progress_bar::NuProgressBar::new(file_size);
let file_out = match std::fs::File::create(&dst) {
Ok(file) => file,
Err(error) => return convert_io_error(error, src, dst, span),
};
let mut buffer = [0u8; 8192];
let mut buf_reader = BufReader::new(file_in);
let mut buf_writer = BufWriter::new(file_out);
loop {
// Read src file
match buf_reader.read(&mut buffer) {
// src file read successfully
Ok(bytes_read) => {
// Write dst file
match buf_writer.write(&buffer[..bytes_read]) {
// dst file written successfully
Ok(bytes_written) => {
// Update the total amount of bytes that has been saved and then print the progress bar
bytes_processed += bytes_written as u64;
bar.update_bar(bytes_processed);
// the last block of bytes is going to be lower than the buffer size
// let's break the loop once we write the last block
if bytes_read < buffer.len() {
break;
}
}
Err(_) => ShellError::PermissionDeniedError(message_dst, span),
},
ErrorKind::Interrupted => ShellError::IOInterrupted(message_src, span),
ErrorKind::OutOfMemory => ShellError::OutOfMemoryError(message_src, span),
// TODO: handle ExecutableFileBusy etc. when io_error_more is stabilized
// https://github.com/rust-lang/rust/issues/86442
_ => ShellError::IOErrorSpanned(message_src, span),
};
Value::Error { error: shell_error }
}
Err(e) => {
// There was a problem writing the dst file
process_failed = Some(e);
break;
}
}
}
Err(e) => {
// There was a problem reading the src file
process_failed = Some(e);
break;
}
};
}
// If copying the file failed
if let Some(error) = process_failed {
bar.abandoned_msg("# !! Error !!".to_owned());
return convert_io_error(error, src, dst, span);
}
// Get the name of the file to print it out at the end
let file_name = &src
.file_name()
.unwrap_or_else(|| std::ffi::OsStr::new(""))
.to_string_lossy();
let msg = format!("copied {:} to {:}", src.display(), dst.display());
bar.finished_msg(format!(" {} copied!", &file_name));
Value::String { val: msg, span }
}
fn copy_symlink(src: PathBuf, dst: PathBuf, span: Span) -> Value {
@ -438,3 +515,43 @@ fn copy_symlink(src: PathBuf, dst: PathBuf, span: Span) -> Value {
},
}
}
// Function to convert io::Errors to more specific ShellErrors
fn convert_io_error(error: std::io::Error, src: PathBuf, dst: PathBuf, span: Span) -> Value {
let message_src = format!(
"copying file '{src_display}' failed: {error}",
src_display = src.display()
);
let message_dst = format!(
"copying to destination '{dst_display}' failed: {error}",
dst_display = dst.display()
);
let shell_error = match error.kind() {
ErrorKind::NotFound => {
if std::path::Path::new(&dst).exists() {
ShellError::FileNotFoundCustom(message_src, span)
} else {
ShellError::FileNotFoundCustom(message_dst, span)
}
}
ErrorKind::PermissionDenied => match std::fs::metadata(&dst) {
Ok(meta) => {
if meta.permissions().readonly() {
ShellError::PermissionDeniedError(message_dst, span)
} else {
ShellError::PermissionDeniedError(message_src, span)
}
}
Err(_) => ShellError::PermissionDeniedError(message_dst, span),
},
ErrorKind::Interrupted => ShellError::IOInterrupted(message_src, span),
ErrorKind::OutOfMemory => ShellError::OutOfMemoryError(message_src, span),
// TODO: handle ExecutableFileBusy etc. when io_error_more is stabilized
// https://github.com/rust-lang/rust/issues/86442
_ => ShellError::IOErrorSpanned(message_src, span),
};
Value::Error { error: shell_error }
}

11
crates/nu-command/src/progress_bar.rs
View File

@ -16,12 +16,12 @@ impl NuProgressBar {
let template = match total_bytes {
Some(_) => {
// We will use a progress bar if we know the total bytes of the stream
ProgressStyle::with_template("{spinner:.green} [{elapsed_precise}] [{wide_bar:.cyan/blue}] {bytes}/{total_bytes} {binary_bytes_per_sec} ({eta}) {msg}")
ProgressStyle::with_template("{spinner:.green} [{elapsed_precise}] [{bar:30.cyan/blue}] [{bytes}/{total_bytes}] {binary_bytes_per_sec} ({eta}) {wide_msg}")
}
_ => {
// But if we don't know the total then we just show the stats progress
ProgressStyle::with_template(
"{spinner:.green} [{elapsed_precise}] {bytes} {binary_bytes_per_sec} {msg}",
"{spinner:.green} [{elapsed_precise}] {bytes} {binary_bytes_per_sec} {wide_msg}",
)
}
};
@ -49,10 +49,9 @@ impl NuProgressBar {
self.pb.set_position(bytes_processed);
}
// Commenting this for now but adding it in the future
//pub fn finished_msg(&self, msg: String) {
// self.pb.finish_with_message(msg);
//}
pub fn finished_msg(&self, msg: String) {
self.pb.finish_with_message(msg);
}
pub fn abandoned_msg(&self, msg: String) {
self.pb.abandon_with_message(msg);