let mut writer = std::io::BufWriter::with_capacity(1024*1024, file);
- CaTarEncoder::encode(source, &mut dir, None, &mut writer)?;
+ CaTarEncoder::encode(source, &mut dir, None, &mut writer, false)?;
writer.flush()?;
archive_name: &str,
backup_time: DateTime<Utc>,
chunk_size: Option<u64>,
+ verbose: bool,
) -> Result<(), Error> {
let mut param = json!({
let path = format!("api2/json/admin/datastore/{}/catar?{}", repo.store, query);
- let stream = CaTarBackupStream::open(dir_path.as_ref())?;
+ let stream = CaTarBackupStream::open(dir_path.as_ref(), verbose)?;
let body = Body::wrap_stream(stream);
let repo = BackupRepository::parse(repo_url)?;
+ let verbose = param["verbose"].as_bool().unwrap_or(false);
+
let chunk_size_opt = param["chunk-size"].as_u64().map(|v| v*1024);
if let Some(size) = chunk_size_opt {
for (filename, target) in upload_list {
flog!(log, "Upload '{}' to '{:?}' as {}", filename, repo, target);
- backup_directory(&mut client, &repo, &filename, &target, backup_time, chunk_size_opt)?;
+ backup_directory(&mut client, &repo, &filename, &target, backup_time, chunk_size_opt, verbose)?;
}
flog!(log, "Upload backup log");
backup_source_schema,
).min_length(1)
)
+ .optional(
+ "verbose",
+ BooleanSchema::new("Verbose output.").default(false))
.optional(
"chunk-size",
IntegerSchema::new("Chunk size in KB. Must be a power of 2.")
_size: usize,
file_copy_buffer: Vec<u8>,
devices: Option<HashSet<u64>>,
+ verbose: bool,
}
impl <'a, W: Write> CaTarEncoder<'a, W> {
path: PathBuf,
dir: &mut nix::dir::Dir,
device_list: Option<Vec<u64>>,
- writer: &'a mut W
+ writer: &'a mut W,
+ verbose: bool,
) -> Result<(), Error> {
const FILE_COPY_BUFFER_SIZE: usize = 1024*1024;
_size: 0,
file_copy_buffer,
devices: None,
+ verbose,
};
// todo: use scandirat??
me.devices = Some(devices);
}
+ if verbose { println!("{:?}", me.current_path); }
+
me.encode_dir(dir, &stat, magic)?;
Ok(())
for filename in &name_list {
self.current_path.push(std::ffi::OsStr::from_bytes(filename.as_bytes()));
+ if self.verbose { println!("{:?}", self.current_path); }
+
let stat = match nix::sys::stat::fstatat(rawfd, filename.as_ref(), nix::fcntl::AtFlags::AT_SYMLINK_NOFOLLOW) {
Ok(stat) => stat,
Err(nix::Error::Sys(Errno::ENOENT)) => {
impl CaTarBackupStream {
- pub fn new(mut dir: Dir, path: PathBuf) -> Result<Self, Error> {
+ pub fn new(mut dir: Dir, path: PathBuf, verbose: bool) -> Result<Self, Error> {
let mut buffer = Vec::with_capacity(4096);
unsafe { buffer.set_len(buffer.capacity()); }
let child = thread::spawn(move|| {
let mut writer = unsafe { std::fs::File::from_raw_fd(tx) };
- if let Err(err) = CaTarEncoder::encode(path, &mut dir, None, &mut writer) {
+ let device_list = vec![];
+ if let Err(err) = CaTarEncoder::encode(path, &mut dir, Some(device_list), &mut writer, verbose) {
eprintln!("catar encode failed - {}", err);
}
});
Ok(Self { pipe: Some(pipe), buffer, child: Some(child) })
}
- pub fn open(dirname: &Path) -> Result<Self, Error> {
+ pub fn open(dirname: &Path, verbose: bool) -> Result<Self, Error> {
let dir = nix::dir::Dir::open(dirname, OFlag::O_DIRECTORY, Mode::empty())?;
let path = std::path::PathBuf::from(dirname);
- Self::new(dir, path)
+ Self::new(dir, path, verbose)
}
}