src/bin/proxmox-backup-api.rs

   1 extern crate proxmox_backup;
   2
   3 //use proxmox_backup::tools;
   4 use proxmox_backup::api_schema::router::*;
   5 use proxmox_backup::api_schema::config::*;
   6 use proxmox_backup::server::rest::*;
   7 use proxmox_backup::tools::daemon::ReexecStore;
   8 use proxmox_backup::auth_helpers::*;
   9 use proxmox_backup::config;
  10
  11 use failure::*;
  12 use lazy_static::lazy_static;
  13
  14 use futures::future::Future;
  15 use tokio::prelude::*;
  16
  17 use hyper;
  18
  19 static mut QUIT_MAIN: bool = false;
  20
  21 fn main() {
  22
  23     if let Err(err) = run() {
  24         eprintln!("Error: {}", err);
  25         std::process::exit(-1);
  26     }
  27 }
  28
  29 fn run() -> Result<(), Error> {
  30     // This manages data for reloads:
  31     let mut reexecer = ReexecStore::new();
  32
  33     if let Err(err) = syslog::init(
  34         syslog::Facility::LOG_DAEMON,
  35         log::LevelFilter::Info,
  36         Some("proxmox-backup-api")) {
  37         bail!("unable to inititialize syslog - {}", err);
  38     }
  39
  40     config::create_configdir()?;
  41
  42     if let Err(err) = generate_auth_key() {
  43         bail!("unable to generate auth key - {}", err);
  44     }
  45     let _ = private_auth_key(); // load with lazy_static
  46
  47     if let Err(err) = generate_csrf_key() {
  48         bail!("unable to generate csrf key - {}", err);
  49     }
  50     let _ = csrf_secret(); // load with lazy_static
  51
  52     lazy_static!{
  53        static ref ROUTER: Router = proxmox_backup::api2::router();
  54     }
  55
  56     let config = ApiConfig::new(
  57         env!("PROXMOX_JSDIR"), &ROUTER, RpcEnvironmentType::PRIVILEGED);
  58
  59     let rest_server = RestServer::new(config);
  60
  61     // http server future:
  62
  63     let listener: tokio::net::TcpListener = reexecer.restore(
  64         "PROXMOX_BACKUP_LISTEN_FD",
  65         || {
  66             let addr = ([127,0,0,1], 82).into();
  67             Ok(tokio::net::TcpListener::bind(&addr)?)
  68         },
  69     )?;
  70
  71     let mut http_server = hyper::Server::builder(listener.incoming())
  72         .serve(rest_server)
  73         .map_err(|e| eprintln!("server error: {}", e));
  74
  75     // signalfd future:
  76
  77     let signal_handler =
  78         proxmox_backup::tools::daemon::default_signalfd_stream(
  79             reexecer,
  80             || {
  81                 unsafe { QUIT_MAIN = true; }
  82                 Ok(())
  83             },
  84         )?
  85         .map(|si| {
  86             // debugging...
  87             eprintln!("received signal: {}", si.ssi_signo);
  88         })
  89         .map_err(|e| {
  90             eprintln!("error from signalfd: {}, shutting down...", e);
  91             unsafe {
  92                 QUIT_MAIN = true;
  93             }
  94         });
  95
  96
  97     // Combined future for signalfd & http server, we want to quit as soon as either of them ends.
  98     // Neither of them is supposed to end unless some weird error happens, so just bail out if is
  99     // the case...
 100     let mut signal_handler = signal_handler.into_future();
 101     let main = futures::future::poll_fn(move || {
 102         // Helper for some diagnostic error messages:
 103         fn poll_helper<S: Future>(stream: &mut S, name: &'static str) -> bool {
 104             match stream.poll() {
 105                 Ok(Async::Ready(_)) => {
 106                     eprintln!("{} ended, shutting down", name);
 107                     true
 108                 }
 109                 Err(_) => {
 110                     eprintln!("{} error, shutting down", name);
 111                     true
 112                 },
 113                 _ => false,
 114             }
 115         }
 116         if poll_helper(&mut http_server, "http server") ||
 117            poll_helper(&mut signal_handler, "signalfd handler")
 118         {
 119             return Ok(Async::Ready(()));
 120         }
 121
 122         if unsafe { QUIT_MAIN } {
 123             eprintln!("shutdown requested");
 124             Ok(Async::Ready(()))
 125         } else {
 126             Ok(Async::NotReady)
 127         }
 128     });
 129
 130     hyper::rt::run(main);
 131
 132     Ok(())
 133 }