wip: better env handling and scheduling

Author: beeb

Cargo.toml

@@ -12,14 +12,14 @@ aws-config = "0.54"
 aws-sdk-s3 = "0.24"
 aws-smithy-http = "0.54"
 chrono = "0.4"
-clap = { version = "4", features = ["derive"] }
+clap = { version = "4", features = ["derive", "env"] }
 cron = "0.12"
 dotenvy = "0.15"
 flate2 = "1"
 tar = "0.4"
 tempfile = "3"
 tokio = { version = "1", features = ["full"] }
-tokio-cron-scheduler = "0.9"
+tokio-cron-scheduler = { version = "0.9", features = ["signal"] }
 
 [dev-dependencies]
 ctor = "0.1"

src/config.rs

@@ -1,4 +1,4 @@
-use std::{env, path::PathBuf};
+use std::path::PathBuf;
 
 use anyhow::{anyhow, Context, Result};
 use aws_config::meta::region::RegionProviderChain;
@@ -12,31 +12,49 @@ use crate::prelude::*;
 #[command(version, about, long_about = None)]
 struct Cli {
     /// Path to the folder to backup
-    ///
-    /// If not specified, defaults to "/dockerbck"
-    #[arg(value_hint = clap::ValueHint::DirPath)]
+    #[arg(value_hint = clap::ValueHint::DirPath, env = "DOCKERBCK_FOLDER")]
     folder: Option<PathBuf>,
 
     /// Specify a cron expression to run the backup periodically
     ///
     /// If not specified, the backup will only run once
-    #[arg(short, long, value_name = "CRON")]
+    #[arg(short, long, value_name = "CRON", env = "DOCKERBCK_SCHEDULE")]
     schedule: Option<String>,
 
     /// The AWS S3 region
-    #[arg(short = 'r', long = "region", value_name = "REGION")]
+    #[arg(
+        short = 'r',
+        long = "region",
+        value_name = "REGION",
+        env = "AWS_REGION"
+    )]
     aws_region: Option<String>,
 
     /// The AWS S3 bucket name
-    #[arg(short = 'b', long = "bucket", value_name = "BUCKET")]
+    #[arg(
+        short = 'b',
+        long = "bucket",
+        value_name = "BUCKET",
+        env = "AWS_BUCKET"
+    )]
     aws_bucket: Option<String>,
 
     /// The AWS S3 access key ID
-    #[arg(short = 'i', long = "id", value_name = "KEY_ID")]
+    #[arg(
+        short = 'i',
+        long = "id",
+        value_name = "KEY_ID",
+        env = "AWS_ACCESS_KEY_ID"
+    )]
     aws_key_id: Option<String>,
 
     /// The AWS S3 secret access key
-    #[arg(short = 't', long = "token", value_name = "KEY")]
+    #[arg(
+        short = 't',
+        long = "token",
+        value_name = "KEY",
+        env = "AWS_SECRET_ACCESS_KEY"
+    )]
     aws_key: Option<String>,
 }
 
@@ -58,27 +76,11 @@ pub struct Params {
 
 /// Parse the command-line arguments and environment variables into runtime params
 pub async fn parse_config() -> Result<Params> {
-    let mut params = Cli::parse();
-
-    params.folder = params
-        .folder
-        .or_else(|| env::var("DOCKERBCK_FOLDER").ok().map(PathBuf::from))
-        .or_else(|| Some(PathBuf::from("/dockerbox")));
-
-    params.schedule = params
-        .schedule
-        .or_else(|| env::var("DOCKERBCK_SCHEDULE").ok());
+    let params = Cli::parse();
 
-    params.aws_region = params.aws_region.or_else(|| env::var("AWS_REGION").ok());
-    params.aws_bucket = params.aws_bucket.or_else(|| env::var("AWS_BUCKET").ok());
-    params.aws_key_id = params
-        .aws_key_id
-        .or_else(|| env::var("AWS_ACCESS_KEY_ID").ok());
-    params.aws_key = params
-        .aws_key
-        .or_else(|| env::var("AWS_SECRET_ACCESS_KEY").ok());
-
-    let folder = params.folder.or_panic(); // Ok to unwrap due to default value
+    let Some(folder) = params.folder else {
+        return Err(anyhow!("No folder path was provided"));
+    };
     let folder = folder
         .canonicalize()
         .with_context(|| anyhow!("Could not resolve path {}", folder.to_string_lossy()))?;

src/main.rs

@@ -3,7 +3,7 @@
 #![warn(clippy::unwrap_used)]
 #![warn(clippy::expect_used)]
 
-use std::sync::Arc;
+use std::{sync::Arc, time::Duration};
 
 use anyhow::{anyhow, Context, Result};
 use dotenvy::dotenv;
@@ -26,7 +26,7 @@ async fn main() -> Result<()> {
 
     match params.schedule.clone() {
         Some(schedule) => {
-            let sched = JobScheduler::new().await?;
+            let mut sched = JobScheduler::new().await?;
             let job = Job::new_async(schedule, move |_, _| {
                 let shared_params = Arc::clone(&params);
                 Box::pin(async move {
@@ -37,6 +37,16 @@ async fn main() -> Result<()> {
                 })
             })?;
             sched.add(job).await?;
+            sched.shutdown_on_ctrl_c();
+            sched.set_shutdown_handler(Box::new(|| {
+                Box::pin(async move {
+                    println!("Shut down done");
+                })
+            }));
+            sched.start().await?;
+            loop {
+                tokio::time::sleep(Duration::from_millis(500)).await;
+            }
         }
         None => {
             backup(&params)