src/bin/proxmox-backup-api.rs

   1 use std::future::Future;
   2 use std::pin::Pin;
   3
   4 use anyhow::{bail, Error};
   5 use futures::*;
   6 use http::request::Parts;
   7 use http::HeaderMap;
   8 use http::Response;
   9 use hyper::{Body, Method, StatusCode};
  10
  11 use proxmox_lang::try_block;
  12 use proxmox_router::{RpcEnvironmentType, UserInformation};
  13 use proxmox_sys::fs::CreateOptions;
  14
  15 use proxmox_rest_server::{
  16     daemon, ApiConfig, AuthError, RestEnvironment, RestServer, ServerAdapter,
  17 };
  18
  19 use proxmox_backup::auth_helpers::*;
  20 use proxmox_backup::config;
  21 use proxmox_backup::server::auth::check_pbs_auth;
  22
  23 fn main() {
  24     pbs_tools::setup_libc_malloc_opts();
  25
  26     proxmox_backup::tools::setup_safe_path_env();
  27
  28     if let Err(err) = proxmox_async::runtime::main(run()) {
  29         eprintln!("Error: {}", err);
  30         std::process::exit(-1);
  31     }
  32 }
  33
  34 struct ProxmoxBackupApiAdapter;
  35
  36 impl ServerAdapter for ProxmoxBackupApiAdapter {
  37     fn get_index(
  38         &self,
  39         _env: RestEnvironment,
  40         _parts: Parts,
  41     ) -> Pin<Box<dyn Future<Output = Response<Body>> + Send>> {
  42         Box::pin(async move {
  43             let index = "<center><h1>Proxmox Backup API Server</h1></center>";
  44
  45             Response::builder()
  46                 .status(StatusCode::OK)
  47                 .header(hyper::header::CONTENT_TYPE, "text/html")
  48                 .body(index.into())
  49                 .unwrap()
  50         })
  51     }
  52
  53     fn check_auth<'a>(
  54         &'a self,
  55         headers: &'a HeaderMap,
  56         method: &'a Method,
  57     ) -> Pin<
  58         Box<
  59             dyn Future<Output = Result<(String, Box<dyn UserInformation + Sync + Send>), AuthError>>
  60                 + Send
  61                 + 'a,
  62         >,
  63     > {
  64         Box::pin(async move { check_pbs_auth(headers, method).await })
  65     }
  66 }
  67
  68 async fn run() -> Result<(), Error> {
  69     if let Err(err) = syslog::init(
  70         syslog::Facility::LOG_DAEMON,
  71         log::LevelFilter::Info,
  72         Some("proxmox-backup-api"),
  73     ) {
  74         bail!("unable to inititialize syslog - {}", err);
  75     }
  76
  77     config::create_configdir()?;
  78
  79     config::update_self_signed_cert(false)?;
  80
  81     proxmox_backup::server::create_run_dir()?;
  82     proxmox_backup::server::create_state_dir()?;
  83     proxmox_backup::server::create_active_operations_dir()?;
  84     proxmox_backup::server::jobstate::create_jobstate_dir()?;
  85     proxmox_backup::tape::create_tape_status_dir()?;
  86     proxmox_backup::tape::create_drive_state_dir()?;
  87     proxmox_backup::tape::create_changer_state_dir()?;
  88     proxmox_backup::tape::create_drive_lock_dir()?;
  89
  90     if let Err(err) = generate_auth_key() {
  91         bail!("unable to generate auth key - {}", err);
  92     }
  93     let _ = private_auth_key(); // load with lazy_static
  94
  95     if let Err(err) = generate_csrf_key() {
  96         bail!("unable to generate csrf key - {}", err);
  97     }
  98     let _ = csrf_secret(); // load with lazy_static
  99
 100     let mut config = ApiConfig::new(
 101         pbs_buildcfg::JS_DIR,
 102         &proxmox_backup::api2::ROUTER,
 103         RpcEnvironmentType::PRIVILEGED,
 104         ProxmoxBackupApiAdapter,
 105     )?;
 106
 107     let backup_user = pbs_config::backup_user()?;
 108     let mut commando_sock = proxmox_rest_server::CommandSocket::new(
 109         proxmox_rest_server::our_ctrl_sock(),
 110         backup_user.gid,
 111     );
 112
 113     let dir_opts = CreateOptions::new()
 114         .owner(backup_user.uid)
 115         .group(backup_user.gid);
 116     let file_opts = CreateOptions::new()
 117         .owner(backup_user.uid)
 118         .group(backup_user.gid);
 119
 120     config.enable_access_log(
 121         pbs_buildcfg::API_ACCESS_LOG_FN,
 122         Some(dir_opts.clone()),
 123         Some(file_opts.clone()),
 124         &mut commando_sock,
 125     )?;
 126
 127     config.enable_auth_log(
 128         pbs_buildcfg::API_AUTH_LOG_FN,
 129         Some(dir_opts.clone()),
 130         Some(file_opts.clone()),
 131         &mut commando_sock,
 132     )?;
 133
 134     let rest_server = RestServer::new(config);
 135     proxmox_rest_server::init_worker_tasks(
 136         pbs_buildcfg::PROXMOX_BACKUP_LOG_DIR_M!().into(),
 137         file_opts.clone(),
 138     )?;
 139
 140     // http server future:
 141     let server = daemon::create_daemon(
 142         ([127, 0, 0, 1], 82).into(),
 143         move |listener| {
 144             let incoming = hyper::server::conn::AddrIncoming::from_listener(listener)?;
 145
 146             Ok(async {
 147                 daemon::systemd_notify(daemon::SystemdNotify::Ready)?;
 148
 149                 hyper::Server::builder(incoming)
 150                     .serve(rest_server)
 151                     .with_graceful_shutdown(proxmox_rest_server::shutdown_future())
 152                     .map_err(Error::from)
 153                     .await
 154             })
 155         },
 156         Some(pbs_buildcfg::PROXMOX_BACKUP_API_PID_FN),
 157     );
 158
 159     proxmox_rest_server::write_pid(pbs_buildcfg::PROXMOX_BACKUP_API_PID_FN)?;
 160
 161     let init_result: Result<(), Error> = try_block!({
 162         proxmox_rest_server::register_task_control_commands(&mut commando_sock)?;
 163         commando_sock.spawn()?;
 164         proxmox_rest_server::catch_shutdown_signal()?;
 165         proxmox_rest_server::catch_reload_signal()?;
 166         Ok(())
 167     });
 168
 169     if let Err(err) = init_result {
 170         bail!("unable to start daemon - {}", err);
 171     }
 172
 173     // stop gap for https://github.com/tokio-rs/tokio/issues/4730 where the thread holding the
 174     // IO-driver may block progress completely if it starts polling its own tasks (blocks).
 175     // So, trigger a notify to parked threads, as we're immediately ready the woken up thread will
 176     // acquire the IO driver, if blocked, before going to sleep, which allows progress again
 177     // TODO: remove once tokio solves this at their level (see proposals in linked comments)
 178     let rt_handle = tokio::runtime::Handle::current();
 179     std::thread::spawn(move || loop {
 180         rt_handle.spawn(std::future::ready(()));
 181         std::thread::sleep(std::time::Duration::from_secs(3));
 182     });
 183
 184     server.await?;
 185     log::info!("server shutting down, waiting for active workers to complete");
 186     proxmox_rest_server::last_worker_future().await?;
 187
 188     log::info!("done - exit server");
 189
 190     Ok(())
 191 }