Remove chrono dependency

Removing that dependency didn't take a lot of code, and fewer
dependencies are better

1 files changed, 50 insertions, 50 deletions

diff --git a/src/updater.rs b/src/updater.rs
index 689aa57..938bc52 100644
--- a/src/updater.rs
+++ b/src/updater.rs
@@ -1,9 +1,9 @@
 use crate::version::{VersionPattern, CompareOutcome};
 use crate::docker::DockerRef;
 use crate::db::{Db, Image, Tag};
+use crate::time::Timestamp;
 use crate::registry::Registries;
 use crate::metrics;
-use chrono::{DateTime, Utc};
 use std::ops::Range;
 
 #[derive(Debug)]
@@ -18,7 +18,7 @@ pub struct FileInput {
     pub images: Vec<Range<usize>>,
 }
 
-pub fn update_images(now: &DateTime<Utc>, db: &dyn Db, reg: &dyn Registries, files: &[FileInput], outcomes: &mut Vec<Result<Vec<FilePatch>, String>>) {
+pub fn update_images(now: Timestamp, db: &dyn Db, reg: &dyn Registries, files: &[FileInput], outcomes: &mut Vec<Result<Vec<FilePatch>, String>>) {
     let mut file_idxs: Vec<usize> = vec![];
     let mut parsed: Vec<DockerRef> = vec![];
     let mut images: Vec<Image> = vec![];
@@ -38,7 +38,7 @@ pub fn update_images(now: &DateTime<Utc>, db: &dyn Db, reg: &dyn Registries, fil
                         id: 0,
                         registry: registry.to_string(),
                         image: image_name.to_string(),
-                        expires_at: DateTime::<Utc>::UNIX_EPOCH,
+                        expires_at: Timestamp::ZERO,
                     }];
                     db.insert_images(&mut new_images);
                     new_images[0].clone()
@@ -80,11 +80,11 @@ pub fn update_images(now: &DateTime<Utc>, db: &dyn Db, reg: &dyn Registries, fil
                 }
                 db.delete_tags(&to_delete);
                 db.insert_tags(&mut to_insert);
-                expired.expires_at = *now + cache_max_age;
+                expired.expires_at = now + cache_max_age;
                 db.update_images(&[expired]);
             }
             None => {
-                expired.expires_at = *now + cache_max_age;
+                expired.expires_at = now + cache_max_age;
                 db.update_images(&[expired]);
             }
         }
@@ -114,7 +114,7 @@ pub fn update_images(now: &DateTime<Utc>, db: &dyn Db, reg: &dyn Registries, fil
 
         let tags = db.get_tags_sorted(image_record.id);
 
-        if image_record.expires_at <= *now && tags.is_empty() {
+        if image_record.expires_at <= now && tags.is_empty() {
             file_errors[file_idx] = Some(format!("{}/{} was not refreshed", image_record.registry, image_record.image));
             continue;
         }
@@ -148,7 +148,7 @@ pub fn update_images(now: &DateTime<Utc>, db: &dyn Db, reg: &dyn Registries, fil
 
         if let Some(ref digest) = img.digest {
             let tag_for_digest = tag.as_deref().unwrap_or("latest");
-            let cached_digest = if image_record.expires_at > *now {
+            let cached_digest = if image_record.expires_at > now {
                 tags.iter().find(|t| t.tag == tag_for_digest).and_then(|t| t.digest.clone())
             } else {
                 None
@@ -204,19 +204,19 @@ mod tests {
     use super::*;
     use crate::db::StubDb;
     use crate::registry::{StubRegistry, StubTag};
-    use chrono::TimeZone;
+    use std::time::Duration;
 
     #[test]
     fn stale_cache_fetches_from_registry() {
         crate::metrics::init();
-        let now = Utc.with_ymd_and_hms(2000, 1, 1, 0, 0, 0).unwrap();
+        let now = Timestamp::ZERO;
         let db = StubDb::default();
         let reg = StubRegistry::new(vec![
             StubTag { registry: "registry.hub.docker.com".into(), image: "nginx".into(), tag: "1.21".into(), digest: "sha256:0000000000000000000000000000000000000000000000000000000000000001".into() },
             StubTag { registry: "registry.hub.docker.com".into(), image: "nginx".into(), tag: "1.22".into(), digest: "sha256:0000000000000000000000000000000000000000000000000000000000000002".into() },
         ]);
 
-        let past_expiry = now - chrono::Duration::days(1);
+        let past_expiry = Timestamp::ZERO - Duration::from_secs(86400);
         let mut images = [Image { id: 0, registry: "registry.hub.docker.com".into(), image: "nginx".into(), expires_at: past_expiry }];
         db.insert_images(&mut images);
         db.insert_tags(&mut [
@@ -230,7 +230,7 @@ mod tests {
             images: vec![7..17]
         }];
         let mut outcomes = vec![];
-        update_images(&now, &db, &reg, &files, &mut outcomes);
+        update_images(now, &db, &reg, &files, &mut outcomes);
 
         let tags: Vec<String> = db.get_tags_sorted(images[0].id).into_iter().map(|t| t.tag).collect();
         assert_eq!(tags, vec!["1.21", "1.22"]);
@@ -241,11 +241,11 @@ mod tests {
     #[test]
     fn fresh_cache_uses_cached_tags() {
         crate::metrics::init();
-        let now = Utc.with_ymd_and_hms(2000, 1, 1, 0, 0, 0).unwrap();
+        let now = Timestamp::ZERO;
         let db = StubDb::default();
         let reg = StubRegistry::new(vec![]);
 
-        let future_expiry = now + chrono::Duration::minutes(30);
+        let future_expiry = Timestamp::ZERO + Duration::from_secs(1800);
         let mut images = [Image { id: 0, registry: "registry.hub.docker.com".into(), image: "nginx".into(), expires_at: future_expiry }];
         db.insert_images(&mut images);
         db.insert_tags(&mut [Tag { id: 0, image_id: images[0].id, tag: "1.21".into(), digest: None }]);
@@ -256,7 +256,7 @@ mod tests {
             images: vec![7..17]
         }];
         let mut outcomes = vec![];
-        update_images(&now, &db, &reg, &files, &mut outcomes);
+        update_images(now, &db, &reg, &files, &mut outcomes);
 
         assert!(outcomes[0].as_ref().unwrap().is_empty());
     }
@@ -264,7 +264,7 @@ mod tests {
     #[test]
     fn no_patch_when_at_highest() {
         crate::metrics::init();
-        let now = Utc.with_ymd_and_hms(2000, 1, 1, 0, 0, 0).unwrap();
+        let now = Timestamp::ZERO;
         let db = StubDb::default();
         let reg = StubRegistry::new(vec![
             StubTag { registry: "registry.hub.docker.com".into(), image: "nginx".into(), tag: "1.21".into(), digest: "sha256:0000000000000000000000000000000000000000000000000000000000000001".into() },
@@ -276,7 +276,7 @@ mod tests {
             images: vec![7..17]
         }];
         let mut outcomes = vec![];
-        update_images(&now, &db, &reg, &files, &mut outcomes);
+        update_images(now, &db, &reg, &files, &mut outcomes);
 
         assert!(outcomes[0].as_ref().unwrap().is_empty());
     }
@@ -284,7 +284,7 @@ mod tests {
     #[test]
     fn patch_to_higher_version() {
         crate::metrics::init();
-        let now = Utc.with_ymd_and_hms(2000, 1, 1, 0, 0, 0).unwrap();
+        let now = Timestamp::ZERO;
         let db = StubDb::default();
         let reg = StubRegistry::new(vec![
             StubTag { registry: "registry.hub.docker.com".into(), image: "nginx".into(), tag: "1.21".into(), digest: "sha256:0000000000000000000000000000000000000000000000000000000000000001".into() },
@@ -297,7 +297,7 @@ mod tests {
             images: vec![7..17]
         }];
         let mut outcomes = vec![];
-        update_images(&now, &db, &reg, &files, &mut outcomes);
+        update_images(now, &db, &reg, &files, &mut outcomes);
 
         assert_eq!(outcomes[0].as_ref().unwrap()[0].content, "1.22");
     }
@@ -305,7 +305,7 @@ mod tests {
     #[test]
     fn picks_highest_of_multiple() {
         crate::metrics::init();
-        let now = Utc.with_ymd_and_hms(2000, 1, 1, 0, 0, 0).unwrap();
+        let now = Timestamp::ZERO;
         let db = StubDb::default();
         let reg = StubRegistry::new(vec![
             StubTag { registry: "registry.hub.docker.com".into(), image: "nginx".into(), tag: "1.21".into(), digest: "sha256:0000000000000000000000000000000000000000000000000000000000000001".into() },
@@ -319,7 +319,7 @@ mod tests {
             images: vec![7..17]
         }];
         let mut outcomes = vec![];
-        update_images(&now, &db, &reg, &files, &mut outcomes);
+        update_images(now, &db, &reg, &files, &mut outcomes);
 
         assert_eq!(outcomes[0].as_ref().unwrap()[0].content, "1.25");
     }
@@ -327,7 +327,7 @@ mod tests {
     #[test]
     fn no_tag_skips_comparison() {
         crate::metrics::init();
-        let now = Utc.with_ymd_and_hms(2000, 1, 1, 0, 0, 0).unwrap();
+        let now = Timestamp::ZERO;
         let db = StubDb::default();
         let reg = StubRegistry::new(vec![
             StubTag { registry: "registry.hub.docker.com".into(), image: "nginx".into(), tag: "latest".into(), digest: "sha256:0000000000000000000000000000000000000000000000000000000000000001".into() },
@@ -339,7 +339,7 @@ mod tests {
             images: vec![7..84]
         }];
         let mut outcomes = vec![];
-        update_images(&now, &db, &reg, &files, &mut outcomes);
+        update_images(now, &db, &reg, &files, &mut outcomes);
 
         let patches = outcomes[0].as_ref().unwrap();
         assert_eq!(patches.len(), 1);
@@ -349,11 +349,11 @@ mod tests {
     #[test]
     fn uses_cached_digest_when_fresh() {
         crate::metrics::init();
-        let now = Utc.with_ymd_and_hms(2000, 1, 1, 0, 0, 0).unwrap();
+        let now = Timestamp::ZERO;
         let db = StubDb::default();
         let reg = StubRegistry::new(vec![]);
 
-        let future_expiry = now + chrono::Duration::minutes(30);
+        let future_expiry = Timestamp::ZERO + Duration::from_secs(1800);
         let mut images = [Image { id: 0, registry: "registry.hub.docker.com".into(), image: "nginx".into(), expires_at: future_expiry }];
         db.insert_images(&mut images);
         db.insert_tags(&mut [Tag { id: 0, image_id: images[0].id, tag: "1.21".into(), digest: Some("sha256:0000000000000000000000000000000000000000000000000000000000000003".into()) }]);
@@ -364,7 +364,7 @@ mod tests {
             images: vec![7..89]
         }];
         let mut outcomes = vec![];
-        update_images(&now, &db, &reg, &files, &mut outcomes);
+        update_images(now, &db, &reg, &files, &mut outcomes);
 
         let patches = outcomes[0].as_ref().unwrap();
         assert_eq!(patches.len(), 1);
@@ -374,7 +374,7 @@ mod tests {
     #[test]
     fn fetches_digest_when_not_cached() {
         crate::metrics::init();
-        let now = Utc.with_ymd_and_hms(2000, 1, 1, 0, 0, 0).unwrap();
+        let now = Timestamp::ZERO;
         let db = StubDb::default();
         let reg = StubRegistry::new(vec![
             StubTag { registry: "registry.hub.docker.com".into(), image: "nginx".into(), tag: "1.21".into(), digest: "sha256:0000000000000000000000000000000000000000000000000000000000000004".into() },
@@ -386,7 +386,7 @@ mod tests {
             images: vec![7..89]
         }];
         let mut outcomes = vec![];
-        update_images(&now, &db, &reg, &files, &mut outcomes);
+        update_images(now, &db, &reg, &files, &mut outcomes);
 
         let patches = outcomes[0].as_ref().unwrap();
         assert_eq!(patches.len(), 1);
@@ -396,7 +396,7 @@ mod tests {
     #[test]
     fn no_patch_when_digest_matches() {
         crate::metrics::init();
-        let now = Utc.with_ymd_and_hms(2000, 1, 1, 0, 0, 0).unwrap();
+        let now = Timestamp::ZERO;
         let db = StubDb::default();
         let reg = StubRegistry::new(vec![
             StubTag { registry: "registry.hub.docker.com".into(), image: "nginx".into(), tag: "1.21".into(), digest: "sha256:0000000000000000000000000000000000000000000000000000000000000002".into() },
@@ -408,7 +408,7 @@ mod tests {
             images: vec![7..89]
         }];
         let mut outcomes = vec![];
-        update_images(&now, &db, &reg, &files, &mut outcomes);
+        update_images(now, &db, &reg, &files, &mut outcomes);
 
         assert!(outcomes[0].as_ref().unwrap().is_empty());
     }
@@ -416,7 +416,7 @@ mod tests {
     #[test]
     fn patch_when_digest_differs() {
         crate::metrics::init();
-        let now = Utc.with_ymd_and_hms(2000, 1, 1, 0, 0, 0).unwrap();
+        let now = Timestamp::ZERO;
         let db = StubDb::default();
         let reg = StubRegistry::new(vec![
             StubTag { registry: "registry.hub.docker.com".into(), image: "nginx".into(), tag: "1.21".into(), digest: "sha256:0000000000000000000000000000000000000000000000000000000000000002".into() },
@@ -428,7 +428,7 @@ mod tests {
             images: vec![7..89]
         }];
         let mut outcomes = vec![];
-        update_images(&now, &db, &reg, &files, &mut outcomes);
+        update_images(now, &db, &reg, &files, &mut outcomes);
 
         let patches = outcomes[0].as_ref().unwrap();
         assert_eq!(patches.len(), 1);
@@ -438,7 +438,7 @@ mod tests {
     #[test]
     fn digest_uses_updated_tag() {
         crate::metrics::init();
-        let now = Utc.with_ymd_and_hms(2000, 1, 1, 0, 0, 0).unwrap();
+        let now = Timestamp::ZERO;
         let db = StubDb::default();
         let reg = StubRegistry::new(vec![
             StubTag { registry: "registry.hub.docker.com".into(), image: "nginx".into(), tag: "1.21".into(), digest: "sha256:0000000000000000000000000000000000000000000000000000000000000001".into() },
@@ -451,7 +451,7 @@ mod tests {
             images: vec![7..89]
         }];
         let mut outcomes = vec![];
-        update_images(&now, &db, &reg, &files, &mut outcomes);
+        update_images(now, &db, &reg, &files, &mut outcomes);
 
         let patches = outcomes[0].as_ref().unwrap();
         assert_eq!(patches.len(), 2);
@@ -462,7 +462,7 @@ mod tests {
     #[test]
     fn error_when_image_not_found() {
         crate::metrics::init();
-        let now = Utc.with_ymd_and_hms(2000, 1, 1, 0, 0, 0).unwrap();
+        let now = Timestamp::ZERO;
         let db = StubDb::default();
         let reg = StubRegistry::new(vec![]);
 
@@ -472,7 +472,7 @@ mod tests {
             images: vec![7..17]
         }];
         let mut outcomes = vec![];
-        update_images(&now, &db, &reg, &files, &mut outcomes);
+        update_images(now, &db, &reg, &files, &mut outcomes);
 
         assert!(outcomes[0].is_err());
         let got = db.get_image("registry.hub.docker.com", "nginx").unwrap();
@@ -482,7 +482,7 @@ mod tests {
     #[test]
     fn error_when_digest_not_found() {
         crate::metrics::init();
-        let now = Utc.with_ymd_and_hms(2000, 1, 1, 0, 0, 0).unwrap();
+        let now = Timestamp::ZERO;
         let db = StubDb::default();
         let reg = StubRegistry::new(vec![
             StubTag { registry: "registry.hub.docker.com".into(), image: "nginx".into(), tag: "1.21".into(), digest: "sha256:0000000000000000000000000000000000000000000000000000000000000001".into() },
@@ -494,7 +494,7 @@ mod tests {
             images: vec![7..89]
         }];
         let mut outcomes = vec![];
-        update_images(&now, &db, &reg, &files, &mut outcomes);
+        update_images(now, &db, &reg, &files, &mut outcomes);
 
         assert!(outcomes[0].is_err());
     }
@@ -502,7 +502,7 @@ mod tests {
     #[test]
     fn multiple_images_produce_patches() {
         crate::metrics::init();
-        let now = Utc.with_ymd_and_hms(2000, 1, 1, 0, 0, 0).unwrap();
+        let now = Timestamp::ZERO;
         let db = StubDb::default();
         let reg = StubRegistry::new(vec![
             StubTag { registry: "registry.hub.docker.com".into(), image: "nginx".into(), tag: "1.21".into(), digest: "sha256:0000000000000000000000000000000000000000000000000000000000000001".into() },
@@ -517,7 +517,7 @@ mod tests {
             images: vec![7..17, 25..34]
         }];
         let mut outcomes = vec![];
-        update_images(&now, &db, &reg, &files, &mut outcomes);
+        update_images(now, &db, &reg, &files, &mut outcomes);
 
         let patches = outcomes[0].as_ref().unwrap();
         assert_eq!(patches.len(), 2);
@@ -526,7 +526,7 @@ mod tests {
     #[test]
     fn patches_sorted_by_position() {
         crate::metrics::init();
-        let now = Utc.with_ymd_and_hms(2000, 1, 1, 0, 0, 0).unwrap();
+        let now = Timestamp::ZERO;
         let db = StubDb::default();
         let reg = StubRegistry::new(vec![
             StubTag { registry: "registry.hub.docker.com".into(), image: "nginx".into(), tag: "1.21".into(), digest: "sha256:0000000000000000000000000000000000000000000000000000000000000001".into() },
@@ -541,7 +541,7 @@ mod tests {
             images: vec![7..17, 25..34]
         }];
         let mut outcomes = vec![];
-        update_images(&now, &db, &reg, &files, &mut outcomes);
+        update_images(now, &db, &reg, &files, &mut outcomes);
 
         let patches = outcomes[0].as_ref().unwrap();
         assert!(patches[0].position.start < patches[1].position.start);
@@ -550,7 +550,7 @@ mod tests {
     #[test]
     fn multiple_files_independent() {
         crate::metrics::init();
-        let now = Utc.with_ymd_and_hms(2000, 1, 1, 0, 0, 0).unwrap();
+        let now = Timestamp::ZERO;
         let db = StubDb::default();
         let reg = StubRegistry::new(vec![
             StubTag { registry: "registry.hub.docker.com".into(), image: "nginx".into(), tag: "1.21".into(), digest: "sha256:0000000000000000000000000000000000000000000000000000000000000001".into() },
@@ -570,7 +570,7 @@ mod tests {
             },
         ];
         let mut outcomes = vec![];
-        update_images(&now, &db, &reg, &files, &mut outcomes);
+        update_images(now, &db, &reg, &files, &mut outcomes);
 
         assert!(outcomes[0].is_err());
         assert!(outcomes[1].is_ok());
@@ -580,13 +580,13 @@ mod tests {
     #[test]
     fn stale_cache_ignores_cached_digest() {
         crate::metrics::init();
-        let now = Utc.with_ymd_and_hms(2000, 1, 1, 0, 0, 0).unwrap();
+        let now = Timestamp::ZERO;
         let db = StubDb::default();
         let reg = StubRegistry::new(vec![
             StubTag { registry: "registry.hub.docker.com".into(), image: "nginx".into(), tag: "1.21".into(), digest: "sha256:0000000000000000000000000000000000000000000000000000000000000005".into() },
         ]);
 
-        let past_expiry = now - chrono::Duration::days(1);
+        let past_expiry = Timestamp::ZERO - Duration::from_secs(86400);
         let mut images = [Image { id: 0, registry: "registry.hub.docker.com".into(), image: "nginx".into(), expires_at: past_expiry }];
         db.insert_images(&mut images);
         db.insert_tags(&mut [Tag { id: 0, image_id: images[0].id, tag: "1.21".into(), digest: Some("sha256:0000000000000000000000000000000000000000000000000000000000000003".into()) }]);
@@ -597,7 +597,7 @@ mod tests {
             images: vec![7..89]
         }];
         let mut outcomes = vec![];
-        update_images(&now, &db, &reg, &files, &mut outcomes);
+        update_images(now, &db, &reg, &files, &mut outcomes);
 
         let patches = outcomes[0].as_ref().unwrap();
         assert_eq!(patches[0].content, "sha256:0000000000000000000000000000000000000000000000000000000000000005");
@@ -606,7 +606,7 @@ mod tests {
     #[test]
     fn error_in_first_image_skips_remaining() {
         crate::metrics::init();
-        let now = Utc.with_ymd_and_hms(2000, 1, 1, 0, 0, 0).unwrap();
+        let now = Timestamp::ZERO;
         let db = StubDb::default();
         let reg = StubRegistry::new(vec![
             StubTag { registry: "registry.hub.docker.com".into(), image: "redis".into(), tag: "6.0".into(), digest: "sha256:0000000000000000000000000000000000000000000000000000000000000001".into() },
@@ -619,7 +619,7 @@ mod tests {
             images: vec![7..17, 25..34]
         }];
         let mut outcomes = vec![];
-        update_images(&now, &db, &reg, &files, &mut outcomes);
+        update_images(now, &db, &reg, &files, &mut outcomes);
 
         assert!(outcomes[0].is_err());
         assert!(db.get_image("registry.hub.docker.com", "redis").is_some());
@@ -631,7 +631,7 @@ mod tests {
     #[test]
     fn same_image_multiple_files_fetches_twice() {
         crate::metrics::init();
-        let now = Utc.with_ymd_and_hms(2000, 1, 1, 0, 0, 0).unwrap();
+        let now = Timestamp::ZERO;
         let db = StubDb::default();
         let reg = StubRegistry::new(vec![
             StubTag { registry: "registry.hub.docker.com".into(), image: "nginx".into(), tag: "1.21".into(), digest: "sha256:0000000000000000000000000000000000000000000000000000000000000001".into() },
@@ -643,7 +643,7 @@ mod tests {
             FileInput { path: "/b".into(), content: "image: nginx:1.21".into(), images: vec![7..17] },
         ];
         let mut outcomes = vec![];
-        update_images(&now, &db, &reg, &files, &mut outcomes);
+        update_images(now, &db, &reg, &files, &mut outcomes);
 
         assert_eq!(outcomes[0].as_ref().unwrap()[0].content, "1.22");
         assert_eq!(outcomes[1].as_ref().unwrap()[0].content, "1.22");