experiment: ignore SIGCHLD

Cargo.toml

@@ -27,6 +27,6 @@ rand = "0.8.5"
 regex = "1.10.2"
 simplelog = "0.12.1"
 thiserror = "1.0.50"
-time = { version = "0.3.30", features = ["local-offset", "macros"]}
+time = { version = "0.3.30", features = ["local-offset"]}
 tokio = { version = "1.34.0", features = ["full"] }
 tokio-util = "0.7.10"

docker/alpine/Dockerfile

@@ -0,0 +1,25 @@
+FROM rust:alpine as builder
+
+ADD . /root/wingmate
+
+WORKDIR /root/wingmate
+
+RUN apk add musl-dev && cargo clean && \
+    cargo build --release
+
+FROM alpine
+
+COPY --from=builder /root/wingmate/target/release/wingmate-rs /usr/local/bin/wingmate
+COPY --from=builder /root/wingmate/target/release/wmtest-helper-dummy /usr/local/bin/wmtest-helper-dummy
+COPY --from=builder /root/wingmate/target/release/wmtest-helper-spawner /usr/local/bin/wmtest-helper-spawner
+COPY --from=builder /root/wingmate/target/release/wmtest-helper-log /usr/local/bin/wmtest-helper-log
+
+ADD docker/alpine/etc/ /etc/
+ADD docker/alpine/entry.sh /usr/local/bin/entry.sh
+
+RUN chmod -R ugo+x /etc/wingmate && chmod +x /usr/local/bin/entry.sh && apk add tzdata && \
+    ln -sv /usr/share/zoneinfo/Australia/Sydney /etc/localtime
+
+ENTRYPOINT [ "/usr/local/bin/entry.sh" ]
+
+CMD [ "/usr/local/bin/wingmate" ]

docker/alpine/entry.sh

@@ -0,0 +1,7 @@
+#!/bin/sh
+
+if [ $# -gt 0 ];then
+    exec "$@"
+else
+    exec /usr/local/bin/wingmate
+fi

docker/alpine/etc/wingmate/crontab

@@ -0,0 +1,3 @@
+17 * * * * /etc/wingmate/crontab.d/cron1.sh
+*/5 * * * * /etc/wingmate/crontab.d/cron2.sh
+21,41 3,6,14,17,20,22 * * * /etc/wingmate/crontab.d/cron3.sh

docker/alpine/etc/wingmate/crontab.d/cron1.sh

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+exec wmtest-helper-log /var/log/cron1.log "this cron runs every hour on minute 17"

docker/alpine/etc/wingmate/crontab.d/cron2.sh

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+exec wmtest-helper-log /var/log/cron2.log "this cron runs every hour on minute 5,10,15,20,25,30,35,40,45,50,55"

docker/alpine/etc/wingmate/crontab.d/cron3.sh

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+exec wmtest-helper-log /var/log/cron3.log "this cron runs based on this specification: 21,41 3,6,14,17,20,22 * * *"

docker/alpine/etc/wingmate/services/one

@@ -0,0 +1,4 @@
+#!/bin/sh
+
+export LOG_PATH=/var/log/one.log
+exec /usr/local/bin/wmtest-helper-spawner 10

docker/alpine/etc/wingmate/services/three.sh

@@ -0,0 +1,4 @@
+#!/bin/sh
+
+export LOG_PATH=/var/log/three.log
+exec /usr/local/bin/wmtest-helper-spawner 13

docker/alpine/etc/wingmate/services/two.sh

@@ -0,0 +1,4 @@
+#!/bin/sh
+
+export LOG_PATH=/var/log/two.log
+exec /usr/local/bin/wmtest-helper-spawner 4

docker/bookworm/Dockerfile

@@ -0,0 +1,9 @@
+FROM ubuntu:22.04
+
+ADD target/debug/init /usr/local/bin/init
+ADD docker/etc/ /etc/
+
+RUN chmod ugo+x /etc/wingmate/services/one && chmod ugo+x /etc/wingmate/services/two.sh && \
+    chmod ugo-x /etc/wingmate/services/three.sh
+
+CMD [ "/usr/local/bin/init" ]

docker/bookworm/etc/wingmate/crontab

@@ -0,0 +1,3 @@
+17 * * * * sleep 1
+*/12 * * * * sleep 1
+12,17,27 * * * * sleep 1

docker/bookworm/etc/wingmate/services/one

@@ -0,0 +1 @@
+you cannot run this file

docker/bookworm/etc/wingmate/services/three.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+exec sleep 1

docker/bookworm/etc/wingmate/services/two.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+exec sleep 1

src/bin/test-helper/spawner.rs

@@ -8,9 +8,15 @@ use std::fs::OpenOptions;
 use std::process::Command;
 use std::env;
 use rand::Rng;
+use nix::sys::signal;
 
 fn main() -> Result<(), Box<dyn Error>> {
     let args: Vec<String> = env::args().collect();
+
+    unsafe {
+        signal::signal(signal::Signal::SIGCHLD, signal::SigHandler::SigIgn)
+    }.unwrap();
+
     let mut rng = rand::thread_rng();
 
     let log_path = env::var("LOG_PATH")?;
@@ -19,21 +25,22 @@ fn main() -> Result<(), Box<dyn Error>> {
 
     if args.len() > 1 {
         let x: u64 = args[1].parse()?;
-        for _i in 0..x {
-            let sleep_time = rng.gen_range(10..20);
-            info!("starting wmtest-helper-dummy {}", &sleep_time);
-            let child = Command::new("/usr/local/bin/wmtest-helper-dummy").arg(format!("{}", sleep_time)).spawn();
-            if let Err(e) = child {
-                error!("error spawning child: {e}");
+        loop {
+            for _i in 0..x {
+                let sleep_time = rng.gen_range(10..20);
+                info!("starting wmtest-helper-dummy {}", &sleep_time);
+                let child = Command::new("/usr/local/bin/wmtest-helper-dummy").arg(format!("{}", sleep_time)).spawn();
+                if let Err(e) = child {
+                    error!("error spawning child: {e}");
+                }
             }
-        }
 
-        let pause_time = rng.gen_range(5..10);
-        info!("going to sleep for {}", &pause_time);
-        std::thread::sleep(std::time::Duration::from_secs(pause_time));
+            let pause_time = rng.gen_range(10..20);
+            info!("going to sleep for {}", &pause_time);
+            std::thread::sleep(std::time::Duration::from_secs(pause_time));
+            info!("waking up")
+        }
     } else {
         return Err(anyhow::anyhow!("invalid arguments").into());
     }
-
-    Ok(())
 }

src/init.rs

@@ -27,6 +27,6 @@ pub async fn start() -> Result<(), error::WingmateInitError> {
     }
 
     let config = config::Config::find(vec_search)?;
-    // dbg!(&config);
+    dbg!(&config);
     daemon::start(config).await
 }

src/init/daemon/starter.rs

@@ -1,24 +1,21 @@
-use time::error::IndeterminateOffset;
 use tokio::task::JoinSet;
 use tokio::process::{Command, Child};
 use tokio_util::sync::CancellationToken;
 use tokio::select;
 use tokio::io::Result as tokio_result;
 use tokio::time::{sleep, interval};
-use std::env;
 use std::time::Duration;
 use std::process::ExitStatus;
 use nix::sys::signal::{kill, Signal};
 use nix::errno::Errno;
 use nix::unistd::Pid;
 use anyhow::{Context, anyhow};
-use time::{OffsetDateTime, Duration as TimeDur, Weekday, UtcOffset};
+use time::{OffsetDateTime, Duration as TimeDur, Weekday};
 use crate::init::config;
 use crate::init::error::{WingmateInitError, CronConfigError};
 
 
 const CRON_TRIGGER_WAIT_SECS: u64 = 20;
-const ENV_UTC_OFFSET: &'static str = "WINGMATE_TIME_OFFSET";
 
 pub fn start_services(ts: &mut JoinSet<Result<(), WingmateInitError>>, cfg: &config::Config, cancel: CancellationToken)
     -> Result<(), WingmateInitError> {
@@ -114,11 +111,9 @@ fn result_match(result: tokio_result<ExitStatus>) -> Result<(), anyhow::Error> {
 pub fn start_cron(ts: &mut JoinSet<Result<(), WingmateInitError>>, cfg: &config::Config, cancel: CancellationToken)
     -> Result<(), WingmateInitError> {
 
-    dbg!("cron: starting");
     for c_ in cfg.get_cron_iter() {
         let cron = c_.clone();
         let in_loop_cancel = cancel.clone();
-        dbg!("cron: item", c_);
 
         ts.spawn(async move {
             if cron.day_of_month != config::CronTimeFieldSpec::Any
@@ -126,35 +121,18 @@ pub fn start_cron(ts: &mut JoinSet<Result<(), WingmateInitError>>, cfg: &config:
                     return Err(WingmateInitError::CronConfig { source: CronConfigError::ClashingConfig });
             }
 
-            dbg!("cron: async task spawned");
-
-            let cron = cron.clone();
+            // let cron = cron.clone();
             let mut cron_interval = interval(Duration::from_secs(CRON_TRIGGER_WAIT_SECS));
             let mut cron_procs: JoinSet<Result<(), WingmateInitError>> = JoinSet::new();
             let mut last_running: Option<OffsetDateTime> = None;
             'continuous: loop {
                 let cron = cron.clone();
                 let cron_proc_cancel = in_loop_cancel.clone();
-                dbg!("cron: single: in loop", &cron.command);
                 
                 let mut flag = true;
 
-                let tr: Result<OffsetDateTime, IndeterminateOffset>;
-                if let Ok(offset) = env::var(ENV_UTC_OFFSET) {
-                    if let Ok(i_off) =  offset.parse::<i8>() {
-                        let utc_time = OffsetDateTime::now_utc().to_offset(UtcOffset::from_hms(i_off, 0, 0).unwrap());
-                        tr = Ok(utc_time);
-                    } else {
-                        tr = OffsetDateTime::now_local();
-                    }
-                } else {
-                    tr = OffsetDateTime::now_local();
-                }
-                // let tr = OffsetDateTime::now_local();
-                if let Ok(local_time) = tr {
-                    dbg!("cron: current local time", &local_time);
+                if let Ok(local_time) = OffsetDateTime::now_local() {
                     if let Some(last) = last_running {
-                        dbg!("cron: last runing instance", &last);
                         if local_time - last < TimeDur::minutes(1) {
                             flag = false;
                         } else {
@@ -163,25 +141,14 @@ pub fn start_cron(ts: &mut JoinSet<Result<(), WingmateInitError>>, cfg: &config:
                                 cron.day_of_month.is_match(local_time.day()) &&
                                 cron.day_of_week.is_match(weekday_map(local_time.weekday()));
                         }
-                    } else {
-                        flag = flag && cron.minute.is_match(local_time.minute()) &&
-                            cron.hour.is_match(local_time.hour()) &&
-                            cron.day_of_month.is_match(local_time.day()) &&
-                            cron.day_of_week.is_match(weekday_map(local_time.weekday()));
                     }
 
                     if flag {
-                        dbg!("cron: timing: hit: {}", &cron.command);
                         last_running = Some(local_time);
                         cron_procs.spawn(async move {
                             run_cron_command(cron.command.clone(), cron_proc_cancel).await
                         });
                     }    
-                } else {
-                    dbg!("cron: unexpected error");
-                    if let Err(e) = tr {
-                        dbg!(e);
-                    }
                 }
 
                 if cron_procs.is_empty() {
@@ -242,7 +209,6 @@ async fn run_cron_command(command: String, cancel: CancellationToken) -> Result<
         }
     }
 
-    dbg!("cron: in running command");
     if args.is_empty() {
         return Err(WingmateInitError::Other { source: anyhow!("parsed as empty: {}", command) });
     }