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/{}/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 list_backups(param: Value, _info: &ApiMethod) -> Result<Value, Error> {
  69
  70     let store = tools::required_string_param(&param, "store")?;
  71
  72     let client = HttpClient::new("localhost");
  73
  74     let path = format!("api3/json/admin/datastore/{}/backups", store);
  75
  76     let result = client.get(&path)?;
  77
  78     Ok(result)
  79 }
  80
  81 fn create_backup(param: Value, _info: &ApiMethod) -> Result<Value, Error> {
  82
  83     let filename = tools::required_string_param(&param, "filename")?;
  84     let store = tools::required_string_param(&param, "store")?;
  85     let target = tools::required_string_param(&param, "target")?;
  86
  87     let mut _chunk_size = 4*1024*1024;
  88
  89     if let Some(size) = param["chunk-size"].as_u64() {
  90         static SIZES: [u64; 7] = [64, 128, 256, 512, 1024, 2048, 4096];
  91
  92         if SIZES.contains(&size) {
  93             _chunk_size = (size as usize) * 1024;
  94         } else {
  95             bail!("Got unsupported chunk size '{}'", size);
  96         }
  97     }
  98
  99     let stat = match nix::sys::stat::stat(filename) {
 100         Ok(s) => s,
 101         Err(err) => bail!("unable to access '{}' - {}", filename, err),
 102     };
 103
 104     if (stat.st_mode & libc::S_IFDIR) != 0 {
 105         println!("Backup directory '{}' to '{}'", filename, store);
 106
 107         let stream = CaTarBackupStream::open(filename)?;
 108
 109         let body = Body::wrap_stream(stream);
 110
 111         backup_directory(body, store, target)?;
 112
 113     } else if (stat.st_mode & (libc::S_IFREG|libc::S_IFBLK)) != 0 {
 114         println!("Backup image '{}' to '{}'", filename, store);
 115
 116         if stat.st_size <= 0 { bail!("got strange file size '{}'", stat.st_size); }
 117         let _size = stat.st_size as usize;
 118
 119         panic!("implement me");
 120
 121         //backup_image(&datastore, &file, size, &target, chunk_size)?;
 122
 123        // let idx = datastore.open_image_reader(target)?;
 124        // idx.print_info();
 125
 126     } else {
 127         bail!("unsupported file type (expected a directory, file or block device)");
 128     }
 129
 130     //datastore.garbage_collection()?;
 131
 132     Ok(Value::Null)
 133 }
 134
 135 fn main() {
 136
 137     let create_cmd_def = CliCommand::new(
 138         ApiMethod::new(
 139             create_backup,
 140             ObjectSchema::new("Create backup.")
 141                 .required("filename", StringSchema::new("Source name (file or directory name)"))
 142                 .required("store", StringSchema::new("Datastore name."))
 143                 .required("target", StringSchema::new("Target name."))
 144                 .optional(
 145                     "chunk-size",
 146                     IntegerSchema::new("Chunk size in KB. Must be a power of 2.")
 147                         .minimum(64)
 148                         .maximum(4096)
 149                         .default(4096)
 150                 )
 151         ))
 152         .arg_param(vec!["filename", "target"])
 153         .completion_cb("filename", tools::complete_file_name)
 154         .completion_cb("store", proxmox_backup::config::datastore::complete_datastore_name);
 155
 156     let list_cmd_def = CliCommand::new(
 157         ApiMethod::new(
 158             list_backups,
 159             ObjectSchema::new("List backups.")
 160                 .required("store", StringSchema::new("Datastore name."))
 161         ))
 162         .arg_param(vec!["store"])
 163         .completion_cb("store", proxmox_backup::config::datastore::complete_datastore_name);
 164
 165
 166     let cmd_def = CliCommandMap::new()
 167         .insert("create".to_owned(), create_cmd_def.into())
 168         .insert("list".to_owned(), list_cmd_def.into());
 169
 170     if let Err(err) = run_cli_command(&cmd_def.into()) {
 171         eprintln!("Error: {}", err);
 172         if err.downcast::<UsageError>().is_ok() {
 173             print_cli_usage();
 174         }
 175         std::process::exit(-1);
 176     }
 177
 178 }