daemon: simplify daemon creation

[proxmox-backup.git] / src / bin / proxmox-backup-api.rs

diff --git a/src/bin/proxmox-backup-api.rs b/src/bin/proxmox-backup-api.rs
index 67da761594720391a63d3c331e81b429d0a4482c..20e33c4fcb6a18dafd1afec568b66f9c2bd3c701 100644 (file)
--- a/src/bin/proxmox-backup-api.rs
+++ b/src/bin/proxmox-backup-api.rs
@@ -4,7 +4,7 @@ extern crate proxmox_backup;
 use proxmox_backup::api_schema::router::*;
 use proxmox_backup::api_schema::config::*;
 use proxmox_backup::server::rest::*;
-use proxmox_backup::tools::daemon::Reloader;
+use proxmox_backup::tools::daemon;
 use proxmox_backup::auth_helpers::*;
 use proxmox_backup::config;
 
@@ -12,12 +12,9 @@ use failure::*;
 use lazy_static::lazy_static;
 
 use futures::future::Future;
-use tokio::prelude::*;
 
 use hyper;
 
-static mut QUIT_MAIN: bool = false;
-
 fn main() {
 
     if let Err(err) = run() {
@@ -27,9 +24,6 @@ fn main() {
 }
 
 fn run() -> Result<(), Error> {
-    // This manages data for reloads:
-    let mut reloader = Reloader::new();
-
     if let Err(err) = syslog::init(
         syslog::Facility::LOG_DAEMON,
         log::LevelFilter::Info,
@@ -59,75 +53,17 @@ fn run() -> Result<(), Error> {
     let rest_server = RestServer::new(config);
 
     // http server future:
-
-    let listener: tokio::net::TcpListener = reloader.restore(
-        "PROXMOX_BACKUP_LISTEN_FD",
-        || {
-            let addr = ([127,0,0,1], 82).into();
-            Ok(tokio::net::TcpListener::bind(&addr)?)
+    let server = daemon::create_daemon(
+        ([127,0,0,1], 82).into(),
+        |listener| {
+            Ok(hyper::Server::builder(listener.incoming())
+                .serve(rest_server)
+                .map_err(|e| eprintln!("server error: {}", e))
+            )
         },
     )?;
 
-    let mut http_server = hyper::Server::builder(listener.incoming())
-        .serve(rest_server)
-        .map_err(|e| eprintln!("server error: {}", e));
-
-    // signalfd future:
-
-    let signal_handler =
-        proxmox_backup::tools::daemon::default_signalfd_stream(
-            reloader,
-            || {
-                unsafe { QUIT_MAIN = true; }
-                Ok(())
-            },
-        )?
-        .map(|si| {
-            // debugging...
-            eprintln!("received signal: {}", si.ssi_signo);
-        })
-        .map_err(|e| {
-            eprintln!("error from signalfd: {}, shutting down...", e);
-            unsafe {
-                QUIT_MAIN = true;
-            }
-        });
-
-
-    // Combined future for signalfd & http server, we want to quit as soon as either of them ends.
-    // Neither of them is supposed to end unless some weird error happens, so just bail out if is
-    // the case...
-    let mut signal_handler = signal_handler.into_future();
-    let main = futures::future::poll_fn(move || {
-        // Helper for some diagnostic error messages:
-        fn poll_helper<S: Future>(stream: &mut S, name: &'static str) -> bool {
-            match stream.poll() {
-                Ok(Async::Ready(_)) => {
-                    eprintln!("{} ended, shutting down", name);
-                    true
-                }
-                Err(_) => {
-                    eprintln!("{} error, shutting down", name);
-                    true
-                },
-                _ => false,
-            }
-        }
-        if poll_helper(&mut http_server, "http server") ||
-           poll_helper(&mut signal_handler, "signalfd handler")
-        {
-            return Ok(Async::Ready(()));
-        }
-
-        if unsafe { QUIT_MAIN } {
-            eprintln!("shutdown requested");
-            Ok(Async::Ready(()))
-        } else {
-            Ok(Async::NotReady)
-        }
-    });
-
-    hyper::rt::run(main);
+    hyper::rt::run(server);
 
     Ok(())
 }