src/bin/proxmox-backup-proxy.rs

   1 use proxmox_backup::try_block;
   2 use proxmox_backup::configdir;
   3 use proxmox_backup::tools;
   4 use proxmox_backup::server;
   5 use proxmox_backup::tools::daemon;
   6 use proxmox_backup::api_schema::router::*;
   7 use proxmox_backup::api_schema::config::*;
   8 use proxmox_backup::server::rest::*;
   9 use proxmox_backup::auth_helpers::*;
  10
  11 use failure::*;
  12 use lazy_static::lazy_static;
  13
  14 use futures::*;
  15 use futures::stream::Stream;
  16
  17 use hyper;
  18
  19 fn main() {
  20
  21     if let Err(err) = run() {
  22         eprintln!("Error: {}", err);
  23         std::process::exit(-1);
  24     }
  25 }
  26
  27 fn run() -> Result<(), Error> {
  28     if let Err(err) = syslog::init(
  29         syslog::Facility::LOG_DAEMON,
  30         log::LevelFilter::Info,
  31         Some("proxmox-backup-proxy")) {
  32         bail!("unable to inititialize syslog - {}", err);
  33     }
  34
  35     let _ = public_auth_key(); // load with lazy_static
  36     let _ = csrf_secret(); // load with lazy_static
  37
  38     lazy_static!{
  39        static ref ROUTER: Router = proxmox_backup::api2::router();
  40     }
  41
  42     let mut config = ApiConfig::new(
  43         env!("PROXMOX_JSDIR"), &ROUTER, RpcEnvironmentType::PUBLIC);
  44
  45     // add default dirs which includes jquery and bootstrap
  46     // my $base = '/usr/share/libpve-http-server-perl';
  47     // add_dirs($self->{dirs}, '/css/' => "$base/css/");
  48     // add_dirs($self->{dirs}, '/js/' => "$base/js/");
  49     // add_dirs($self->{dirs}, '/fonts/' => "$base/fonts/");
  50     config.add_alias("novnc", "/usr/share/novnc-pve");
  51     config.add_alias("extjs", "/usr/share/javascript/extjs");
  52     config.add_alias("fontawesome", "/usr/share/fonts-font-awesome");
  53     config.add_alias("xtermjs", "/usr/share/pve-xtermjs");
  54     config.add_alias("widgettoolkit", "/usr/share/javascript/proxmox-widget-toolkit");
  55
  56     let rest_server = RestServer::new(config);
  57
  58     let cert_path = configdir!("/proxy.pfx");
  59     let raw_cert = tools::file_get_contents(cert_path)?;
  60
  61     let identity = match native_tls::Identity::from_pkcs12(&raw_cert, "") {
  62         Ok(data) => data,
  63         Err(err) => bail!("unabled to decode pkcs12 identity {} - {}", cert_path, err),
  64     };
  65
  66     let server = daemon::create_daemon(
  67         ([0,0,0,0,0,0,0,0], 8007).into(),
  68         |listener| {
  69             let acceptor = native_tls::TlsAcceptor::new(identity)?;
  70             let acceptor = std::sync::Arc::new(tokio_tls::TlsAcceptor::from(acceptor));
  71             let connections = listener
  72                 .incoming()
  73                 .map_err(Error::from)
  74                 .and_then(move |sock| acceptor.accept(sock).map_err(|e| e.into()))
  75                 .then(|r| match r {
  76                     // accept()s can fail here with an Err() when eg. the client rejects
  77                     // the cert and closes the connection, so we follow up with mapping
  78                     // it to an option and then filtering None with filter_map
  79                     Ok(c) => Ok::<_, Error>(Some(c)),
  80                     Err(e) => {
  81                         if let Some(_io) = e.downcast_ref::<std::io::Error>() {
  82                             // "real" IO errors should not simply be ignored
  83                             bail!("shutting down...");
  84                         } else {
  85                             // handshake errors just get filtered by filter_map() below:
  86                             Ok(None)
  87                         }
  88                     }
  89                 })
  90                 .filter_map(|r| {
  91                     // Filter out the Nones
  92                     r
  93                 });
  94             Ok(hyper::Server::builder(connections)
  95                 .serve(rest_server)
  96                 .map_err(|e| eprintln!("server error: {}", e))
  97             )
  98         },
  99     )?;
 100
 101     tokio::run(lazy(||  {
 102
 103         let init_result: Result<(), Error> = try_block!({
 104             server::create_task_control_socket()?;
 105             server::server_state_init()?;
 106             Ok(())
 107         });
 108
 109         if let Err(err) = init_result {
 110             eprintln!("unable to start daemon - {}", err);
 111         } else {
 112             tokio::spawn(server);
 113         }
 114
 115         Ok(())
 116     }));
 117
 118     Ok(())
 119 }