//! Helpers for daemons/services.
use std::ffi::CString;
+use std::future::Future;
use std::os::raw::{c_char, c_int};
use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
use std::os::unix::ffi::OsStrExt;
use std::panic::UnwindSafe;
+use std::pin::Pin;
+use std::task::{Context, Poll};
use failure::*;
-use tokio::prelude::*;
+
+use proxmox::tools::io::{ReadExt, WriteExt};
use crate::server;
use crate::tools::{fd_change_cloexec, self};
/// the function provided in the `or_create` parameter to instantiate the new "first" instance.
///
/// Values created via this method will be remembered for later re-execution.
- pub fn restore<T, F>(&mut self, name: &'static str, or_create: F) -> Result<T, Error>
+ pub async fn restore<T, F, U>(&mut self, name: &'static str, or_create: F) -> Result<T, Error>
where
T: Reloadable,
- F: FnOnce() -> Result<T, Error>,
+ F: FnOnce() -> U,
+ U: Future<Output = Result<T, Error>>,
{
let res = match std::env::var(name) {
Ok(varstr) => T::restore(&varstr)?,
- Err(std::env::VarError::NotPresent) => or_create()?,
+ Err(std::env::VarError::NotPresent) => or_create().await?,
Err(_) => bail!("variable {} has invalid value", name),
};
new_args.push(CString::new(arg.as_bytes())?);
}
+ // Synchronisation pipe:
+ let (pin, pout) = super::pipe()?;
+
// Start ourselves in the background:
use nix::unistd::{fork, ForkResult};
match fork() {
Ok(ForkResult::Child) => {
- // At this point we call pre-exec helpers. We must be certain that if they fail for
- // whatever reason we can still call `_exit()`, so use catch_unwind.
- match std::panic::catch_unwind(move || self.do_exec(exe, new_args)) {
- Ok(_) => eprintln!("do_exec returned unexpectedly!"),
- Err(_) => eprintln!("panic in re-exec"),
+ // Double fork so systemd can supervise us without nagging...
+ match fork() {
+ Ok(ForkResult::Child) => {
+ std::mem::drop(pin);
+ // At this point we call pre-exec helpers. We must be certain that if they fail for
+ // whatever reason we can still call `_exit()`, so use catch_unwind.
+ match std::panic::catch_unwind(move || {
+ let mut pout = unsafe {
+ std::fs::File::from_raw_fd(pout.into_raw_fd())
+ };
+ let pid = nix::unistd::Pid::this();
+ if let Err(e) = unsafe { pout.write_host_value(pid.as_raw()) } {
+ log::error!("failed to send new server PID to parent: {}", e);
+ unsafe {
+ libc::_exit(-1);
+ }
+ }
+ std::mem::drop(pout);
+ self.do_exec(exe, new_args)
+ })
+ {
+ Ok(_) => eprintln!("do_exec returned unexpectedly!"),
+ Err(_) => eprintln!("panic in re-exec"),
+ }
+ }
+ Ok(ForkResult::Parent { child }) => {
+ std::mem::drop((pin, pout));
+ log::debug!("forked off a new server (second pid: {})", child);
+ }
+ Err(e) => log::error!("fork() failed, restart delayed: {}", e),
}
// No matter how we managed to get here, this is the time where we bail out quickly:
unsafe {
}
}
Ok(ForkResult::Parent { child }) => {
- eprintln!("forked off a new server (pid: {})", child);
+ log::debug!("forked off a new server (first pid: {}), waiting for 2nd pid", child);
+ std::mem::drop(pout);
+ let mut pin = unsafe {
+ std::fs::File::from_raw_fd(pin.into_raw_fd())
+ };
+ let child = nix::unistd::Pid::from_raw(match unsafe { pin.read_le_value() } {
+ Ok(v) => v,
+ Err(e) => {
+ log::error!("failed to receive pid of double-forked child process: {}", e);
+ // systemd will complain but won't kill the service...
+ return Ok(());
+ }
+ });
+
if let Err(e) = systemd_notify(SystemdNotify::MainPid(child)) {
log::error!("failed to notify systemd about the new main pid: {}", e);
}
Ok(())
}
Err(e) => {
- eprintln!("fork() failed, restart delayed: {}", e);
+ log::error!("fork() failed, restart delayed: {}", e);
Ok(())
}
}
fd_change_cloexec(fd, true)?;
Ok(Self::from_std(
unsafe { std::net::TcpListener::from_raw_fd(fd) },
- &tokio::reactor::Handle::default(),
+ &tokio_net::driver::Handle::default(),
)?)
}
}
+pub struct NotifyReady;
+
+impl Future for NotifyReady {
+ type Output = Result<(), Error>;
+
+ fn poll(self: Pin<&mut Self>, _cx: &mut Context) -> Poll<Result<(), Error>> {
+ systemd_notify(SystemdNotify::Ready)?;
+ Poll::Ready(Ok(()))
+ }
+}
+
/// This creates a future representing a daemon which reloads itself when receiving a SIGHUP.
/// If this is started regularly, a listening socket is created. In this case, the file descriptor
/// number will be remembered in `PROXMOX_BACKUP_LISTEN_FD`.
/// If the variable already exists, its contents will instead be used to restore the listening
/// socket. The finished listening socket is then passed to the `create_service` function which
/// can be used to setup the TLS and the HTTP daemon.
-pub fn create_daemon<F, S>(
+pub async fn create_daemon<F, S>(
address: std::net::SocketAddr,
create_service: F,
-) -> Result<impl Future<Item = (), Error = ()>, Error>
+) -> Result<(), Error>
where
- F: FnOnce(tokio::net::TcpListener) -> Result<S, Error>,
- S: Future<Item = (), Error = ()>,
+ F: FnOnce(tokio::net::TcpListener, NotifyReady) -> Result<S, Error>,
+ S: Future<Output = ()>,
{
let mut reloader = Reloader::new();
let listener: tokio::net::TcpListener = reloader.restore(
"PROXMOX_BACKUP_LISTEN_FD",
- move || Ok(tokio::net::TcpListener::bind(&address)?),
- )?;
+ move || async move { Ok(tokio::net::TcpListener::bind(&address).await?) },
+ ).await?;
- let service = create_service(listener)?;
+ create_service(listener, NotifyReady)?.await;
let mut reloader = Some(reloader);
- Ok(service
- .map(move |_| {
- crate::tools::request_shutdown(); // make sure we are in shutdown mode
- if server::is_reload_request() {
- log::info!("daemon reload...");
- if let Err(e) = systemd_notify(SystemdNotify::Reloading) {
- log::error!("failed to notify systemd about the state change: {}", e);
- }
- if let Err(e) = reloader.take().unwrap().fork_restart() {
- log::error!("error during reload: {}", e);
- let _ = systemd_notify(SystemdNotify::Status(format!("error during reload")));
- }
- } else {
- log::info!("daemon shutting down...");
- }
- })
- .map_err(|_| ())
- )
+ crate::tools::request_shutdown(); // make sure we are in shutdown mode
+ if server::is_reload_request() {
+ log::info!("daemon reload...");
+ if let Err(e) = systemd_notify(SystemdNotify::Reloading) {
+ log::error!("failed to notify systemd about the state change: {}", e);
+ }
+ if let Err(e) = reloader.take().unwrap().fork_restart() {
+ log::error!("error during reload: {}", e);
+ let _ = systemd_notify(SystemdNotify::Status(format!("error during reload")));
+ }
+ } else {
+ log::info!("daemon shutting down...");
+ }
+ Ok(())
}
#[link(name = "systemd")]
projects / proxmox-backup.git / blobdiff