use local time everywhere

bytebeamio · Apr 15, 2023 · d327e0b · d327e0b
1 parent aec3cf0
commit d327e0b
Show file tree

Hide file tree

Showing 5 changed files with 119 additions and 14 deletions.
diff --git a/build.gradle.kts b/build.gradle.kts
@@ -4,7 +4,7 @@ import kotlin.io.path.copyTo
 
 buildscript {
     extra.apply {
-        set("sdk_version", "v0.6.2")
+        set("sdk_version", "v0.6.3")
         set("kotlin_version", "1.7.0")
     }
     repositories {

diff --git a/utilities/Cargo.lock b/utilities/Cargo.lock
diff --git a/utilities/Cargo.toml b/utilities/Cargo.toml
@@ -7,7 +7,7 @@ edition = "2021"
 
 [dependencies]
 clap = { version = "4.0.32", features = ["derive"] }
-time = "0.3.17"
+time = { version = "0.3.20", features = ["local-offset"] }
 regex = "1.7.0"
 lazy_static = "1.4.0"
 

diff --git a/utilities/src/bin/uplink_watchdog.rs b/utilities/src/bin/uplink_watchdog.rs
@@ -1,14 +1,22 @@
 use std::io::Write;
+use std::ops::Add;
 use std::process::Command;
 use std::thread::sleep;
 use std::time::Duration;
 use regex::Regex;
 use time::{OffsetDateTime, PrimitiveDateTime, UtcOffset};
+use utilities::next_wednesday_3am;
 
 lazy_static::lazy_static! {
     static ref UPLINK_MODE_REGEX: Regex = Regex::new("^.+Switching to (.+) mode!!$").unwrap();
 }
 
+fn current_time() -> OffsetDateTime {
+    OffsetDateTime::now_utc()
+        .to_offset(UtcOffset::current_local_offset()
+            .unwrap_or(UtcOffset::from_hms(5, 30, 0).unwrap()))
+}
+
 fn uplink_running() -> bool {
     Command::new("pgrep")
         .arg("-x")
@@ -44,12 +52,10 @@ fn _internet_working() -> bool {
 }
 
 fn main() {
-    let tomorrow_3am = OffsetDateTime::now_utc()
-        .date()
-        .next_day().unwrap()
-        .with_hms(22, 15, 0)
-        .unwrap()
-        .assume_offset(UtcOffset::UTC);
+    // safe as long as we don't modify environment variables
+    unsafe { time::util::local_offset::set_soundness(time::util::local_offset::Soundness::Unsound); }
+    let now = current_time();
+    let oh_boy_3am = next_wednesday_3am(now);
 
     let current_exe_path = std::env::current_exe().unwrap();
     let uplink_module_dir = current_exe_path
@@ -63,16 +69,16 @@ fn main() {
             .output();
     };
 
-    println!("waiting till: {tomorrow_3am}");
+    println!("{now}: waiting till: {oh_boy_3am}");
     let mut _tics = 0;
     loop {
         let _ = std::io::stdout().flush();
         let _ = std::io::stderr().flush();
         sleep(Duration::from_secs(1));
         _tics += 1;
-        let now = OffsetDateTime::now_utc();
+        let now = current_time();
 
-        if now > tomorrow_3am {
+        if now > oh_boy_3am {
             println!("{now}: restarting uplink");
             restart()
         } else if !uplink_running() {

diff --git a/utilities/src/lib.rs b/utilities/src/lib.rs
@@ -1,5 +1,11 @@
+#![feature(const_option)]
+#![feature(const_result_drop)]
+
 use std::fmt::{Debug, Display, Formatter};
 use std::io::Write;
+use std::ops::Add;
+use std::time::Duration;
+use time::{OffsetDateTime, UtcOffset};
 
 #[derive(Debug)]
 pub struct LazyFile {
@@ -62,4 +68,86 @@ impl<T: Debug> Trace<T> for T {
         println!("{:?}", self);
         self
     }
-}
+}
+
+pub fn next_wednesday_3am(anchor: OffsetDateTime) -> OffsetDateTime {
+    let current_weekday = anchor.weekday().number_days_from_sunday();
+    let wednesday_weekday = time::Weekday::Wednesday.number_days_from_sunday();
+    let three_am = time::Time::from_hms(3, 30, 0).unwrap();
+    let before_wednesday_case = current_weekday < wednesday_weekday || (current_weekday == wednesday_weekday && anchor.time() < three_am);
+    // let after_wednesday_case = current_weekday > wednesday_weekday || (current_weekday == wednesday_weekday && anchor.time() >= three_am);
+    if before_wednesday_case {
+        anchor.add(Duration::from_secs(60 * 60 * 24 * ((wednesday_weekday - current_weekday) as u64)))
+            .replace_time(three_am)
+    } else {
+        anchor.add(Duration::from_secs(60 * 60 * 24 * ((7 - (current_weekday - wednesday_weekday)) as u64)))
+            .replace_time(three_am)
+    }
+}
+
+pub const INDIA_OFFSET: UtcOffset = UtcOffset::from_hms(5, 30, 0).ok().unwrap();
+
+mod test {
+    use time::{Date, Month, OffsetDateTime, PrimitiveDateTime, Time, UtcOffset};
+    use crate::{INDIA_OFFSET, next_wednesday_3am};
+
+    #[test]
+    fn t2() {
+        dbg!(OffsetDateTime::now_utc().to_offset(Utc))
+    }
+
+    #[test]
+    fn t1() {
+        assert_eq!(
+            next_wednesday_3am(
+                PrimitiveDateTime::new(
+                    Date::from_calendar_date(2023, Month::April, 14).unwrap(),
+                    Time::from_hms(13, 20, 0).unwrap()
+                ).assume_offset(INDIA_OFFSET)
+            ),
+            PrimitiveDateTime::new(
+                Date::from_calendar_date(2023, Month::April, 19).unwrap(),
+                Time::from_hms(3, 30, 0).unwrap()
+            ).assume_offset(INDIA_OFFSET)
+        );
+
+        assert_eq!(
+            next_wednesday_3am(
+                PrimitiveDateTime::new(
+                    Date::from_calendar_date(2023, Month::April, 18).unwrap(),
+                    Time::from_hms(13, 20, 0).unwrap()
+                ).assume_offset(INDIA_OFFSET)
+            ),
+            PrimitiveDateTime::new(
+                Date::from_calendar_date(2023, Month::April, 19).unwrap(),
+                Time::from_hms(3, 30, 0).unwrap()
+            ).assume_offset(INDIA_OFFSET)
+        );
+
+        assert_eq!(
+            next_wednesday_3am(
+                PrimitiveDateTime::new(
+                    Date::from_calendar_date(2023, Month::April, 19).unwrap(),
+                    Time::from_hms(1, 20, 0).unwrap()
+                ).assume_offset(INDIA_OFFSET)
+            ),
+            PrimitiveDateTime::new(
+                Date::from_calendar_date(2023, Month::April, 19).unwrap(),
+                Time::from_hms(3, 30, 0).unwrap()
+            ).assume_offset(INDIA_OFFSET)
+        );
+
+        assert_eq!(
+            next_wednesday_3am(
+                PrimitiveDateTime::new(
+                    Date::from_calendar_date(2023, Month::April, 19).unwrap(),
+                    Time::from_hms(13, 20, 0).unwrap()
+                ).assume_offset(INDIA_OFFSET)
+            ),
+            PrimitiveDateTime::new(
+                Date::from_calendar_date(2023, Month::April, 26).unwrap(),
+                Time::from_hms(3, 30, 0).unwrap()
+            ).assume_offset(INDIA_OFFSET)
+        );
+    }
+}