Revert "Use store instead of fetch_add for atomics"

This reverts commit d4bd0ef1ca.

src/io/stats.rs

@@ -19,15 +19,15 @@ pub struct Stats {
 
 impl Stats {
     pub fn add_connection(&self) {
-        self.connections.store(1, Ordering::Relaxed);
+        self.connections.fetch_add(1, Ordering::Relaxed);
     }
 
     pub fn add_rx_bytes(&self, n: usize) {
-        self.rx.store(n, Ordering::Relaxed);
+        self.rx.fetch_add(n, Ordering::Relaxed);
     }
 
     pub fn add_tx_bytes(&self, n: usize) {
-        self.tx.store(n, Ordering::Relaxed);
+        self.tx.fetch_add(n, Ordering::Relaxed);
     }
 
     pub fn connections(&self) -> usize {

src/ldap.rs

@@ -3,7 +3,7 @@ use russh::keys::PublicKey;
 use tokio::select;
 use tokio::task::JoinHandle;
 use tokio_util::sync::CancellationToken;
-use tracing::{debug, warn};
+use tracing::{debug, error};
 
 #[derive(Debug, Clone)]
 pub struct Ldap {
@@ -51,9 +51,10 @@ impl Ldap {
             select! {
                 res = conn.drive() => {
                     if let Err(err) = res {
-                        warn!("LDAP connection error: {}", err);
+                        error!("LDAP connection error: {}", err);
                     } else {
-                        debug!("LDAP drive has stopped, this should not happen?");
+                        error!("LDAP connection lost");
+                        token.cancel();
                     }
                 }
                 _ = token.cancelled() => {

src/main.rs

@@ -15,18 +15,43 @@ use siranga::web::{ForwardAuth, Service};
 use tokio::net::TcpListener;
 use tokio::select;
 use tokio_util::sync::CancellationToken;
-use tracing::{error, info, warn};
+use tracing::{debug, error, info, warn};
 use tracing_subscriber::EnvFilter;
 use tracing_subscriber::layer::SubscriberExt;
 use tracing_subscriber::util::SubscriberInitExt;
 
+#[cfg(unix)]
+async fn sigterm() {
+    use tokio::signal::unix::SignalKind;
+
+    let mut sigterm =
+        tokio::signal::unix::signal(SignalKind::terminate()).expect("should be able to initialize");
+    sigterm.recv().await;
+}
+
+#[cfg(not(unix))]
+async fn sigterm() {
+    std::future::pending::<()>().await;
+}
+
 async fn shutdown_task(token: CancellationToken) {
-    tokio::signal::ctrl_c()
-        .await
-        .expect("Failed to listen for ctrl-c event");
+    select! {
+        _ = tokio::signal::ctrl_c() => {
+            debug!("Received SIGINT");
+        }
+        _ = sigterm() => {
+            debug!("Received SIGTERM");
+        }
+        _ = token.cancelled() => {
+            debug!("Application called for graceful shutdown");
+        }
+    }
     info!("Starting graceful shutdown");
     token.cancel();
-    tokio::time::sleep(Duration::from_secs(5)).await;
+    select! {
+        _ = tokio::time::sleep(Duration::from_secs(5)) => {}
+        _ = tokio::signal::ctrl_c() => {}
+    }
 }
 
 #[tokio::main]