Signals & Process Control

use tokio::signal;
 
#[tokio::main]
async fn main() -> anyhow::Result<()> {
    tokio::select! {
        _ = signal::ctrl_c() => {
            eprintln!("shutting down gracefully");
        }
        res = run_server() => res?,
    }
    Ok(())
}

use std::process::{Child, Command, Stdio};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;
use tokio::signal;
use tokio::time::{sleep, Duration};
 
struct Supervisor {
    shutdown: Arc<AtomicBool>,
    child: Option<Child>,
}
 
impl Supervisor {
    fn spawn_worker(&mut self) -> anyhow::Result<()> {
        let child = Command::new("worker-bin")
            .stdout(Stdio::piped())
            .spawn()?;
        self.child = Some(child);
        Ok(())
    }
 
    fn stop_worker(&mut self) {
        if let Some(mut child) = self.child.take() {
            let _ = child.kill();
            let _ = child.wait();
        }
    }
}
 
#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let shutdown = Arc::new(AtomicBool::new(false));
    let mut sup = Supervisor { shutdown: shutdown.clone(), child: None };
    sup.spawn_worker()?;
 
    tokio::select! {
        _ = signal::ctrl_c() => {
            shutdown.store(true, Ordering::SeqCst);
            sup.stop_worker();
        }
        _ = async {
            while !shutdown.load(Ordering::SeqCst) {
                sleep(Duration::from_secs(1)).await;
            }
        } => {}
    }
    Ok(())
}

use std::os::unix::process::CommandExt;
 
unsafe {
    cmd.pre_exec(|| {
        libc::setpgid(0, 0);
        Ok(())
    });
}