linkd: Resort to tokio signal handling

Signed-off-by: Alexander Simmerl <[email protected]>

linkd-lib/Cargo.toml

@@ -19,8 +19,6 @@ futures             = "0.3"
 lazy_static         = "1.4"
 log                 = "0.4"
 nix                 = "0.22"
-signal-hook         = { version = "0.3", default-features = false }
-signal-hook-tokio   = { version = "0.3", features = [ "futures-v0_3" ] }
 structopt           = { version = "0.3", default-features = false }
 thiserror           = "1.0"
 tempfile            = "3.2"

linkd-lib/src/node.rs

@@ -6,8 +6,6 @@
 use std::panic;
 
 use futures::future::{select_all, FutureExt as _};
-use signal_hook::consts::TERM_SIGNALS;
-use signal_hook_tokio::Signals;
 use structopt::StructOpt as _;
 use tokio::{net::UnixStream, spawn, sync::mpsc};
 use tracing::info;
@@ -34,9 +32,7 @@ pub async fn run() -> anyhow::Result<()> {
     let cfg: Cfg<discovery::Static, BoxedSigner> = cfg(&args).await?;
 
     let (shutdown_tx, shutdown_rx) = mpsc::channel(1);
-    let signals = Signals::new(TERM_SIGNALS)?;
-    let signals_handle = signals.handle();
-    let signals_task = tokio::spawn(signals::routine(signals, shutdown_tx));
+    let signals_task = tokio::spawn(signals::routine(shutdown_tx));
 
     let mut coalesced = vec![];
     let peer = Peer::new(cfg.peer)?;
@@ -71,7 +67,6 @@ pub async fn run() -> anyhow::Result<()> {
         }
     }
 
-    signals_handle.close();
     signals_task.await??;
 
     Ok(())

linkd-lib/src/signals.rs

@@ -3,26 +3,45 @@
 // This file is part of radicle-link, distributed under the GPLv3 with Radicle
 // Linking Exception. For full terms see the included LICENSE file.
 
-use futures::stream::StreamExt as _;
-use signal_hook_tokio::Signals;
-use tokio::sync::mpsc;
+use tokio::{select, sync::mpsc};
 use tracing::{info, instrument};
 
+#[cfg(unix)]
+#[instrument(name = "signals subroutine", skip(shutdown_tx))]
+pub async fn routine(shutdown_tx: mpsc::Sender<()>) -> anyhow::Result<()> {
+    use tokio::signal::unix::*;
+
+    let mut int = signal(SignalKind::interrupt())?;
+    let mut quit = signal(SignalKind::quit())?;
+    let mut term = signal(SignalKind::terminate())?;
+
+    let signal = select! {
+        _ = int.recv() => SignalKind::quit(),
+        _ = quit.recv() => SignalKind::quit(),
+        _ = term.recv() => SignalKind::terminate(),
+    };
+
+    info!(?signal, "received termination signal");
+    let _ = shutdown_tx.try_send(());
+
+    Ok(())
+}
+
+#[cfg(target_os = "windows")]
 #[instrument(name = "signals subroutine", skip(signals, shutdown_tx))]
 pub async fn routine(signals: Signals, shutdown_tx: mpsc::Sender<()>) -> anyhow::Result<()> {
-    use signal_hook::consts::signal::*;
-
-    let mut signals = signals.fuse();
-
-    while let Some(signal) = signals.next().await {
-        match signal {
-            SIGINT | SIGQUIT | SIGTERM => {
-                info!(?signal, "received termination signal");
-                let _ = shutdown_tx.try_send(());
-            },
-            _ => unreachable!(),
-        }
-    }
+    use tokio::signal::windows::*;
+
+    let mut br = ctrl_break()?;
+    let mut c = cltr_c()?;
+
+    let signal = select! {
+        _ = br.recv() => SignalKind::quit(),
+        _ = c.recv() => SignalKind::quit(),
+    };
+
+    info!(?signal, "received termination signal");
+    let _ = shutdown_tx.try_send(());
 
     Ok(())
 }