Add signal handlers for SIGTERM and SIGUSR1

Closes #71

SIGTERM now properly shuts down the system instead of aborting. SIGUSR1
will reload the config, but right now this only updates the encoding of
data. More work is needed to actually reload the 0-db's used to encoded
data.

Signed-off-by: Lee Smet <[email protected]>

Author: LeeSmet

zstor/src/actors/config.rs

@@ -4,7 +4,7 @@ use crate::{
     ZstorError,
 };
 use actix::prelude::*;
-use log::error;
+use log::{debug, error};
 use std::{convert::TryInto, ops::Deref, path::PathBuf, sync::Arc};
 use tokio::fs;
 
@@ -73,6 +73,7 @@ impl Handler<ReloadConfig> for ConfigActor {
 
     fn handle(&mut self, _: ReloadConfig, _: &mut Self::Context) -> Self::Result {
         let path = self.config_path.clone();
+        debug!("Config actor reloading running config from {:?}", path);
         AtomicResponse::new(Box::pin(
             async move {
                 fs::read(path)
@@ -83,6 +84,7 @@ impl Handler<ReloadConfig> for ConfigActor {
             .map(|res, this, _| {
                 let config = toml::from_slice(&res?)?;
                 this.config = Arc::new(config);
+                debug!("Config actor finished reloading running config");
                 Ok(())
             }),
         ))

zstor/src/actors/zstor.rs

@@ -21,6 +21,8 @@ use std::{
 };
 use tokio::{fs, io, task::JoinHandle};
 
+use super::config::ReloadConfig;
+
 #[derive(Serialize, Deserialize, Debug)]
 /// All possible commands zstor operates on.
 pub enum ZstorCommand {
@@ -365,6 +367,15 @@ impl Handler<Check> for ZstorActor {
     }
 }
 
+impl Handler<ReloadConfig> for ZstorActor {
+    type Result = ResponseFuture<Result<(), ZstorError>>;
+
+    fn handle(&mut self, _: ReloadConfig, _: &mut Self::Context) -> Self::Result {
+        let cfg = self.cfg.clone();
+        Box::pin(async move { cfg.send(ReloadConfig).await? })
+    }
+}
+
 async fn load_data(metadata: &MetaData) -> ZstorResult<Vec<Option<Vec<u8>>>> {
     // attempt to retrieve all shards
     let mut shard_loads: Vec<JoinHandle<(usize, Result<(_, _), ZstorError>)>> =

zstor/src/main.rs

@@ -1,4 +1,5 @@
 use actix::Addr;
+use actix_rt::signal::unix::SignalKind;
 use futures::future::join_all;
 use log::LevelFilter;
 use log::{debug, error, info, trace};
@@ -16,6 +17,7 @@ use std::process;
 use structopt::StructOpt;
 use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
 use tokio::net::{UnixListener, UnixStream};
+use zstor_v2::actors::config::ReloadConfig;
 use zstor_v2::actors::zstor::{
     Check, Rebuild, Retrieve, Store, ZstorActor, ZstorCommand, ZstorResponse,
 };
@@ -314,6 +316,14 @@ async fn real_main() -> ZstorResult<()> {
 
             let zstor = zstor_v2::setup_system(opts.config, cfg).await?;
 
+            // setup signal handlers
+            let mut sigints = actix_rt::signal::unix::signal(SignalKind::interrupt())
+                .expect("Failed to install SIGINT handler");
+            let mut sigterms = actix_rt::signal::unix::signal(SignalKind::terminate())
+                .expect("Failed to install SIGTERM handler");
+            let mut siguserone = actix_rt::signal::unix::signal(SignalKind::user_defined1())
+                .expect("Failed to install SIGUSR1 handler");
+
             loop {
                 tokio::select! {
                     accepted = server.accept() => {
@@ -332,14 +342,22 @@ async fn real_main() -> ZstorResult<()> {
                             }
                         });
                     }
-                    _ = actix_rt::signal::ctrl_c() => break,
+                    _ = sigints.recv() => {
+                        info!("Shutting down zstor daemon after receiving SIGINT");
+                        break
+                    },
+                    _ = sigterms.recv() => {
+                        info!("Shutting down zstor daemon after receiving SIGTERM");
+                        break
+                    },
+                    _ = siguserone.recv() => {
+                        info!("Reloading config after receiving SIGUSR1");
+                        if let Err(e) = zstor.send(ReloadConfig).await {
+                            error!("could not reload config: {}", e)
+                        }
+                    },
                 }
             }
-            actix_rt::signal::ctrl_c()
-                .await
-                .map_err(|e| ZstorError::new_io("Failed to wait for CTRL-C".to_string(), e))?;
-
-            info!("Shutting down zstor daemon after receiving CTRL-C");
         }
     };