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 use proxmox_backup::auth_helpers::*;
  12
  13 use lazy_static::lazy_static;
  14
  15 use futures::future::Future;
  16
  17 use hyper;
  18
  19 fn main() {
  20
  21     if let Err(err) = syslog::init(
  22         syslog::Facility::LOG_DAEMON,
  23         log::LevelFilter::Info,
  24         Some("proxmox-backup-api")) {
  25         eprintln!("unable to inititialize syslog: {}", err);
  26         std::process::exit(-1);
  27     }
  28
  29     if let Err(err) = generate_auth_key() {
  30         eprintln!("unable to generate auth key: {}", err);
  31         std::process::exit(-1);
  32     }
  33     let _ = private_auth_key(); // load with lazy_static
  34
  35     if let Err(err) = generate_csrf_key() {
  36         eprintln!("unable to generate csrf key: {}", err);
  37         std::process::exit(-1);
  38     }
  39     let _ = csrf_secret(); // load with lazy_static
  40
  41     let command : Arc<Schema> = StringSchema::new("Command.")
  42         .format(Arc::new(ApiStringFormat::Enum(vec![
  43             "start".into(),
  44             "status".into(),
  45             "stop".into()
  46         ])))
  47         .into();
  48
  49     let schema = ObjectSchema::new("Parameters.")
  50         .required("command", command);
  51
  52     let args: Vec<String> = std::env::args().skip(1).collect();
  53
  54     let options = match getopts::parse_arguments(&args, &vec!["command"], &schema) {
  55         Ok((options, rest)) => {
  56             if !rest.is_empty() {
  57                 eprintln!("Error: got additional arguments: {:?}", rest);
  58                 std::process::exit(-1);
  59             }
  60             options
  61         }
  62         Err(err) => {
  63             eprintln!("Error: unable to parse arguments:\n{}", err);
  64             std::process::exit(-1);
  65         }
  66     };
  67
  68     let command = options["command"].as_str().unwrap();
  69
  70     match command {
  71         "start" => {
  72             println!("Starting server.");
  73         },
  74         "stop" => {
  75             println!("Stopping server.");
  76             std::process::exit(0);
  77         },
  78         "status" => {
  79             println!("Server status.");
  80              std::process::exit(0);
  81        },
  82         _ => {
  83             eprintln!("got unexpected command {}", command);
  84             std::process::exit(-1);
  85         },
  86     }
  87
  88     let addr = ([127,0,0,1], 82).into();
  89
  90     lazy_static!{
  91        static ref ROUTER: Router = proxmox_backup::api2::router();
  92     }
  93
  94     let config = ApiConfig::new(
  95         "/usr/share/javascript/proxmox-backup", &ROUTER, RpcEnvironmentType::PRIVILEDGED);
  96
  97     let rest_server = RestServer::new(config);
  98
  99     let server = hyper::Server::bind(&addr)
 100         .serve(rest_server)
 101         .map_err(|e| eprintln!("server error: {}", e));
 102
 103
 104     // Run this server for... forever!
 105     hyper::rt::run(server);
 106 }