src/bin/proxmox-backup-api.rs

   1 extern crate proxmox_backup;
   2
   3 use std::sync::Arc;
   4
   5 use proxmox_backup::tools;
   6 use proxmox_backup::api::schema::*;
   7 use proxmox_backup::api::router::*;
   8 use proxmox_backup::api::config::*;
   9 use proxmox_backup::server::rest::*;
  10 use proxmox_backup::getopts;
  11
  12 use failure::*;
  13 use lazy_static::lazy_static;
  14 use openssl::rsa::{Rsa};
  15 use std::path::PathBuf;
  16
  17 use futures::future::Future;
  18
  19 use hyper;
  20
  21 pub fn gen_auth_key() -> Result<(), Error> {
  22
  23     let priv_path = PathBuf::from("/etc/proxmox-backup/authkey.key");
  24
  25     let mut public_path = priv_path.clone();
  26     public_path.set_extension("pub");
  27
  28     if priv_path.exists() && public_path.exists() { return Ok(()); }
  29
  30     let rsa = Rsa::generate(4096).unwrap();
  31
  32     let priv_pem = rsa.private_key_to_pem()?;
  33
  34     use nix::sys::stat::Mode;
  35
  36     tools::file_set_contents(
  37         &priv_path, &priv_pem, Some(Mode::from_bits_truncate(0o0600)))?;
  38
  39
  40     let public_pem = rsa.public_key_to_pem()?;
  41
  42     tools::file_set_contents(&public_path, &public_pem, None)?;
  43
  44     Ok(())
  45 }
  46
  47 fn main() {
  48
  49     if let Err(err) = syslog::init(
  50         syslog::Facility::LOG_DAEMON,
  51         log::LevelFilter::Info,
  52         Some("proxmox-backup-api")) {
  53         eprintln!("unable to inititialize syslog: {}", err);
  54         std::process::exit(-1);
  55     }
  56
  57     if let Err(err) = gen_auth_key() {
  58         eprintln!("unable to generate auth key: {}", err);
  59         std::process::exit(-1);
  60     }
  61
  62     let command : Arc<Schema> = StringSchema::new("Command.")
  63         .format(Arc::new(ApiStringFormat::Enum(vec![
  64             "start".into(),
  65             "status".into(),
  66             "stop".into()
  67         ])))
  68         .into();
  69
  70     let schema = ObjectSchema::new("Parameters.")
  71         .required("command", command);
  72
  73     let args: Vec<String> = std::env::args().skip(1).collect();
  74
  75     let options = match getopts::parse_arguments(&args, &vec!["command"], &schema) {
  76         Ok((options, rest)) => {
  77             if !rest.is_empty() {
  78                 eprintln!("Error: got additional arguments: {:?}", rest);
  79                 std::process::exit(-1);
  80             }
  81             options
  82         }
  83         Err(err) => {
  84             eprintln!("Error: unable to parse arguments:\n{}", err);
  85             std::process::exit(-1);
  86         }
  87     };
  88
  89     let command = options["command"].as_str().unwrap();
  90
  91     match command {
  92         "start" => {
  93             println!("Starting server.");
  94         },
  95         "stop" => {
  96             println!("Stopping server.");
  97             std::process::exit(0);
  98         },
  99         "status" => {
 100             println!("Server status.");
 101              std::process::exit(0);
 102        },
 103         _ => {
 104             eprintln!("got unexpected command {}", command);
 105             std::process::exit(-1);
 106         },
 107     }
 108
 109     let addr = ([127,0,0,1], 82).into();
 110
 111     lazy_static!{
 112        static ref ROUTER: Router = proxmox_backup::api2::router();
 113     }
 114
 115     let config = ApiConfig::new(
 116         "/usr/share/javascript/proxmox-backup", &ROUTER, RpcEnvironmentType::PRIVILEDGED);
 117
 118     let rest_server = RestServer::new(config);
 119
 120     let server = hyper::Server::bind(&addr)
 121         .serve(rest_server)
 122         .map_err(|e| eprintln!("server error: {}", e));
 123
 124
 125     // Run this server for... forever!
 126     hyper::rt::run(server);
 127 }