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 fn backup_directory(body: Body, store: &str, archive_name: &str) -> Result<(), Error> {
  22
  23     let client = HttpClient::new("localhost");
  24
  25     let epoch = std::time::SystemTime::now().duration_since(
  26         std::time::SystemTime::UNIX_EPOCH)?.as_secs();
  27
  28     let query = url::form_urlencoded::Serializer::new(String::new())
  29         .append_pair("archive_name", archive_name)
  30         .append_pair("type", "host")
  31         .append_pair("id", &tools::nodename())
  32         .append_pair("time", &epoch.to_string())
  33         .finish();
  34
  35     let path = format!("api3/json/admin/datastore/{}/upload_catar?{}", store, query);
  36
  37     client.upload("application/x-proxmox-backup-catar", body, &path)?;
  38
  39     Ok(())
  40 }
  41
  42 /****
  43 fn backup_image(datastore: &DataStore, file: &std::fs::File, size: usize, target: &str, chunk_size: usize) -> Result<(), Error> {
  44
  45     let mut target = PathBuf::from(target);
  46
  47     if let Some(ext) = target.extension() {
  48         if ext != "iidx" {
  49             bail!("got wrong file extension - expected '.iidx'");
  50         }
  51     } else {
  52         target.set_extension("iidx");
  53     }
  54
  55     let mut index = datastore.create_image_writer(&target, size, chunk_size)?;
  56
  57     tools::file_chunker(file, chunk_size, |pos, chunk| {
  58         index.add_chunk(pos, chunk)?;
  59         Ok(true)
  60     })?;
  61
  62     index.close()?; // commit changes
  63
  64     Ok(())
  65 }
  66 */
  67
  68 fn create_backup(param: Value, _info: &ApiMethod) -> Result<Value, Error> {
  69
  70     let filename = tools::required_string_param(&param, "filename")?;
  71     let store = tools::required_string_param(&param, "store")?;
  72     let target = tools::required_string_param(&param, "target")?;
  73
  74     let mut chunk_size = 4*1024*1024;
  75
  76     if let Some(size) = param["chunk-size"].as_u64() {
  77         static SIZES: [u64; 7] = [64, 128, 256, 512, 1024, 2048, 4096];
  78
  79         if SIZES.contains(&size) {
  80             chunk_size = (size as usize) * 1024;
  81         } else {
  82             bail!("Got unsupported chunk size '{}'", size);
  83         }
  84     }
  85
  86     let stat = match nix::sys::stat::stat(filename) {
  87         Ok(s) => s,
  88         Err(err) => bail!("unable to access '{}' - {}", filename, err),
  89     };
  90
  91     if (stat.st_mode & libc::S_IFDIR) != 0 {
  92         println!("Backup directory '{}' to '{}'", filename, store);
  93
  94         let stream = CaTarBackupStream::open(filename)?;
  95
  96         let body = Body::wrap_stream(stream);
  97
  98         backup_directory(body, store, target)?;
  99
 100     } else if (stat.st_mode & (libc::S_IFREG|libc::S_IFBLK)) != 0 {
 101         println!("Backup image '{}' to '{}'", filename, store);
 102
 103         if stat.st_size <= 0 { bail!("got strange file size '{}'", stat.st_size); }
 104         let size = stat.st_size as usize;
 105
 106         panic!("implement me");
 107
 108         //backup_image(&datastore, &file, size, &target, chunk_size)?;
 109
 110        // let idx = datastore.open_image_reader(target)?;
 111        // idx.print_info();
 112
 113     } else {
 114         bail!("unsupported file type (expected a directory, file or block device)");
 115     }
 116
 117     //datastore.garbage_collection()?;
 118
 119     Ok(Value::Null)
 120 }
 121
 122 fn main() {
 123
 124     let cmd_def = CliCommand::new(
 125         ApiMethod::new(
 126             create_backup,
 127             ObjectSchema::new("Create backup.")
 128                 .required("filename", StringSchema::new("Source name (file or directory name)"))
 129                 .required("store", StringSchema::new("Datastore name."))
 130                 .required("target", StringSchema::new("Target name."))
 131                 .optional(
 132                     "chunk-size",
 133                     IntegerSchema::new("Chunk size in KB. Must be a power of 2.")
 134                         .minimum(64)
 135                         .maximum(4096)
 136                         .default(4096)
 137                 )
 138         ))
 139         .arg_param(vec!["filename", "target"])
 140         .completion_cb("filename", tools::complete_file_name)
 141         .completion_cb("store", proxmox_backup::config::datastore::complete_datastore_name);
 142
 143
 144     if let Err(err) = run_cli_command(&cmd_def.into()) {
 145         eprintln!("Error: {}", err);
 146         if err.downcast::<UsageError>().is_ok() {
 147             print_cli_usage();
 148         }
 149         std::process::exit(-1);
 150     }
 151
 152 }