src/bin/proxmox-backup-client.rs

   1 extern crate proxmox_backup;
   2
   3 use failure::*;
   4 use std::os::unix::io::AsRawFd;
   5
   6 use proxmox_backup::tools;
   7 use proxmox_backup::cli::command::*;
   8 use proxmox_backup::api::schema::*;
   9 use proxmox_backup::api::router::*;
  10 use proxmox_backup::client::http_client::*;
  11 use proxmox_backup::client::catar_backup_stream::*;
  12 //use proxmox_backup::backup::chunk_store::*;
  13 //use proxmox_backup::backup::image_index::*;
  14 //use proxmox_backup::config::datastore;
  15 //use proxmox_backup::catar::encoder::*;
  16 use proxmox_backup::backup::datastore::*;
  17
  18 use serde_json::{Value};
  19 use hyper::Body;
  20
  21
  22 fn backup_directory(body: Body, store: &str, archive_name: &str) -> Result<(), Error> {
  23
  24     let client = HttpClient::new("localhost");
  25
  26     let path = format!("api3/json/admin/datastore/{}/upload_catar?archive_name={}", store, archive_name);
  27
  28     client.upload("application/x-proxmox-backup-catar", body, &path)?;
  29
  30     Ok(())
  31 }
  32
  33 /****
  34 fn backup_image(datastore: &DataStore, file: &std::fs::File, size: usize, target: &str, chunk_size: usize) -> Result<(), Error> {
  35
  36     let mut target = PathBuf::from(target);
  37
  38     if let Some(ext) = target.extension() {
  39         if ext != "iidx" {
  40             bail!("got wrong file extension - expected '.iidx'");
  41         }
  42     } else {
  43         target.set_extension("iidx");
  44     }
  45
  46     let mut index = datastore.create_image_writer(&target, size, chunk_size)?;
  47
  48     tools::file_chunker(file, chunk_size, |pos, chunk| {
  49         index.add_chunk(pos, chunk)?;
  50         Ok(true)
  51     })?;
  52
  53     index.close()?; // commit changes
  54
  55     Ok(())
  56 }
  57 */
  58
  59 fn create_backup(param: Value, _info: &ApiMethod) -> Result<Value, Error> {
  60
  61     let filename = tools::required_string_param(&param, "filename")?;
  62     let store = tools::required_string_param(&param, "store")?;
  63     let target = tools::required_string_param(&param, "target")?;
  64
  65     let mut chunk_size = 4*1024*1024;
  66
  67     if let Some(size) = param["chunk-size"].as_u64() {
  68         static SIZES: [u64; 7] = [64, 128, 256, 512, 1024, 2048, 4096];
  69
  70         if SIZES.contains(&size) {
  71             chunk_size = (size as usize) * 1024;
  72         } else {
  73             bail!("Got unsupported chunk size '{}'", size);
  74         }
  75     }
  76
  77     let stat = match nix::sys::stat::stat(filename) {
  78         Ok(s) => s,
  79         Err(err) => bail!("unable to access '{}' - {}", filename, err),
  80     };
  81
  82     if (stat.st_mode & libc::S_IFDIR) != 0 {
  83         println!("Backup directory '{}' to '{}'", filename, store);
  84
  85         let stream = CaTarBackupStream::open(filename)?;
  86
  87         let body = Body::wrap_stream(stream);
  88
  89         backup_directory(body, store, target)?;
  90
  91     } else if (stat.st_mode & (libc::S_IFREG|libc::S_IFBLK)) != 0 {
  92         println!("Backup image '{}' to '{}'", filename, store);
  93
  94         if stat.st_size <= 0 { bail!("got strange file size '{}'", stat.st_size); }
  95         let size = stat.st_size as usize;
  96
  97         panic!("implement me");
  98
  99         //backup_image(&datastore, &file, size, &target, chunk_size)?;
 100
 101        // let idx = datastore.open_image_reader(target)?;
 102        // idx.print_info();
 103
 104     } else {
 105         bail!("unsupported file type (expected a directory, file or block device)");
 106     }
 107
 108     //datastore.garbage_collection()?;
 109
 110     Ok(Value::Null)
 111 }
 112
 113
 114 pub fn complete_file_name(arg: &str) -> Vec<String> {
 115
 116     let mut result = vec![];
 117
 118     use nix::fcntl::OFlag;
 119     use nix::sys::stat::Mode;
 120     use nix::fcntl::AtFlags;
 121
 122     let mut dirname = std::path::PathBuf::from(arg);
 123
 124     if let Ok(stat) = nix::sys::stat::fstatat(libc::AT_FDCWD, &dirname, AtFlags::empty()) {
 125
 126     } else {
 127         if let Some(parent) = dirname.parent() {
 128             dirname = parent.to_owned();
 129         }
 130     }
 131
 132     let mut dir = match nix::dir::Dir::openat(libc::AT_FDCWD, &dirname, OFlag::O_DIRECTORY, Mode::empty()) {
 133         Ok(d) => d,
 134         Err(err) => {
 135             return result;
 136         }
 137     };
 138
 139     for item in dir.iter() {
 140         if let Ok(entry) = item {
 141             if let Ok(name) = entry.file_name().to_str() {
 142                 if name == "." || name == ".." { continue; }
 143                 let mut newpath = dirname.clone();
 144                 newpath.push(name);
 145
 146                 if let Ok(stat) = nix::sys::stat::fstatat(libc::AT_FDCWD, &newpath, AtFlags::empty()) {
 147                     if (stat.st_mode & libc::S_IFMT) == libc::S_IFDIR {
 148                         newpath.push("");
 149                         if let Some(newpath) = newpath.to_str() {
 150                             result.push(newpath.to_owned());
 151                         }
 152                         continue;
 153                      }
 154                 }
 155                 if let Some(newpath) = newpath.to_str() {
 156                     result.push(newpath.to_owned());
 157                 }
 158
 159              }
 160         }
 161     }
 162
 163     result
 164 }
 165
 166 fn main() {
 167
 168     let cmd_def = CliCommand::new(
 169         ApiMethod::new(
 170             create_backup,
 171             ObjectSchema::new("Create backup.")
 172                 .required("filename", StringSchema::new("Source name (file or directory name)"))
 173                 .required("store", StringSchema::new("Datastore name."))
 174                 .required("target", StringSchema::new("Target name."))
 175                 .optional(
 176                     "chunk-size",
 177                     IntegerSchema::new("Chunk size in KB. Must be a power of 2.")
 178                         .minimum(64)
 179                         .maximum(4096)
 180                         .default(4096)
 181                 )
 182         ))
 183         .arg_param(vec!["filename", "target"])
 184         .completion_cb("filename", complete_file_name)
 185         .completion_cb("store", proxmox_backup::config::datastore::complete_datastore_name);
 186
 187
 188     if let Err(err) = run_cli_command(&cmd_def.into()) {
 189         eprintln!("Error: {}", err);
 190         if err.downcast::<UsageError>().is_ok() {
 191             print_cli_usage();
 192         }
 193         std::process::exit(-1);
 194     }
 195
 196 }