Switch from time crate to jiff

Author: sourcefrog

Cargo.lock

@@ -61,19 +61,17 @@ strum_macros = "0.26"
 tempfile = "3"
 thiserror = "2.0"
 thousands = "0.2.0"
-time = { version = "0.3.47", features = [
-    "local-offset",
-    "macros",
-    "serde",
-    "serde-human-readable",
-] }
 tokio = { version = "1.43", features = ["full", "test-util", "tracing"] }
 tracing = "0.1"
 tracing-appender = "0.2"
 unix_mode = "0.1"
 url = "2.2.2"
 whoami = "1.5.2"
 
+[dependencies.jiff]
+version = "0.2"
+features = ["serde"]
+
 [target.'cfg(unix)'.dependencies]
 uzers = "0.11"
 nix = { version = "0.28", features = ["fs", "user"] }

Cargo.toml

@@ -26,8 +26,8 @@ use std::sync::Arc;
 
 use crate::transport::Transport;
 use itertools::Itertools;
+use jiff::Timestamp;
 use serde::{Deserialize, Serialize};
-use time::OffsetDateTime;
 use tracing::{debug, trace, warn};
 
 use crate::jsonio::{read_json, write_json};
@@ -83,7 +83,7 @@ pub struct Band {
 #[derive(Debug, Clone, Serialize, Deserialize)]
 struct Head {
     /// Seconds since the Unix epoch when writing of this band began.
-    start_time: i64,
+    start_time: i64, // TODO: Maybe a timestamp with custom serializer
 
     /// Semver string for the minimum Conserve version to read this band
     /// correctly.
@@ -99,7 +99,7 @@ struct Head {
 #[derive(Debug, Serialize, Deserialize)]
 struct Tail {
     /// Seconds since the Unix epoch when the band was closed.
-    end_time: i64,
+    end_time: i64, // TODO: Maybe a timestamp with custom serializer
 
     /// Number of index hunks in this band, to enable validation that none are missing.
     ///
@@ -113,10 +113,10 @@ pub struct Info {
     pub is_closed: bool,
 
     /// Time Conserve started writing this band.
-    pub start_time: OffsetDateTime,
+    pub start_time: Timestamp,
 
     /// Time this band was completed, if it is complete.
-    pub end_time: Option<OffsetDateTime>,
+    pub end_time: Option<Timestamp>,
 
     /// Number of hunks present in the index, if that is known.
     pub index_hunk_count: Option<u64>,
@@ -153,7 +153,7 @@ impl Band {
             Some("23.2.0".to_owned())
         };
         let head = Head {
-            start_time: OffsetDateTime::now_utc().unix_timestamp(),
+            start_time: Timestamp::now().as_second(),
             band_format_version,
             format_flags: format_flags.into(),
         };
@@ -171,7 +171,7 @@ impl Band {
             &self.transport,
             BAND_TAIL_FILENAME,
             &Tail {
-                end_time: OffsetDateTime::now_utc().unix_timestamp(),
+                end_time: Timestamp::now().as_second(),
                 index_hunk_count: Some(index_hunk_count),
             },
         )
@@ -267,18 +267,14 @@ impl Band {
     pub async fn get_info(&self) -> Result<Info> {
         let tail_option: Option<Tail> = read_json(&self.transport, BAND_TAIL_FILENAME).await?;
         let start_time =
-            OffsetDateTime::from_unix_timestamp(self.head.start_time).map_err(|_| {
-                Error::InvalidMetadata {
-                    details: format!("Invalid band start timestamp {:?}", self.head.start_time),
-                }
+            Timestamp::from_second(self.head.start_time).map_err(|_| Error::InvalidMetadata {
+                details: format!("Invalid band start timestamp {:?}", self.head.start_time),
             })?;
         let end_time = tail_option
             .as_ref()
             .map(|tail| {
-                OffsetDateTime::from_unix_timestamp(tail.end_time).map_err(|_| {
-                    Error::InvalidMetadata {
-                        details: format!("Invalid band end timestamp {:?}", tail.end_time),
-                    }
+                Timestamp::from_second(tail.end_time).map_err(|_| Error::InvalidMetadata {
+                    details: format!("Invalid band end timestamp {:?}", tail.end_time),
                 })
             })
             .transpose()?;
@@ -312,7 +308,6 @@ impl Band {
 mod tests {
     use std::fs;
     use std::str::FromStr;
-    use std::time::Duration;
 
     use serde_json::json;
 
@@ -355,7 +350,7 @@ mod tests {
         let dur = info.end_time.expect("info has an end_time") - info.start_time;
         // Test should have taken (much) less than 5s between starting and finishing
         // the band.  (It might fail if you set a breakpoint right there.)
-        assert!(dur < Duration::from_secs(5));
+        assert!(dur.get_seconds() < 5);
     }
 
     #[tokio::test]

src/band.rs

@@ -17,24 +17,19 @@ use std::cell::RefCell;
 use std::fs::{File, OpenOptions};
 use std::io::{self, BufWriter, Write};
 use std::path::{Path, PathBuf};
-use std::sync::{Arc, RwLock};
+use std::sync::Arc;
 use std::time::Instant;
 
 use clap::builder::{Styles, styling};
 use clap::{Parser, Subcommand};
 use conserve::change::Change;
-use time::UtcOffset;
 #[allow(unused_imports)]
 use tracing::{Level, debug, error, info, trace, warn};
 
 use crate::transport::Transport;
 use conserve::termui::{TermUiMonitor, TraceTimeStyle, enable_tracing};
 use conserve::*;
 
-/// Local timezone offset, calculated once at startup, to avoid issues about
-/// looking at the environment once multiple threads are running.
-static LOCAL_OFFSET: RwLock<UtcOffset> = RwLock::new(UtcOffset::UTC);
-
 #[mutants::skip] // only visual effects, not worth testing
 fn clap_styles() -> Styles {
     styling::Styles::styled()
@@ -630,16 +625,11 @@ impl Command {
                 sizes,
                 utc,
             } => {
-                let timezone = if *utc {
-                    None
-                } else {
-                    Some(*LOCAL_OFFSET.read().unwrap())
-                };
                 let archive = Archive::open(Transport::new(archive).await?).await?;
                 let options = ShowVersionsOptions {
                     newest_first: *newest,
                     tree_size: *sizes,
-                    timezone,
+                    utc: *utc,
                     start_time: !*short,
                     backup_duration: !*short,
                 };
@@ -716,10 +706,6 @@ fn make_change_callback(
 }
 
 fn main() -> Result<ExitCode> {
-    // Before anything else, get the local time offset, to avoid `time-rs`
-    // problems with loading it when threads are running.
-    *LOCAL_OFFSET.write().unwrap() =
-        UtcOffset::current_local_offset().expect("get local time offset");
     let args = Args::parse();
     let start_time = Instant::now();
     let console_level = if args.debug {

src/bin/conserve.rs

@@ -15,8 +15,8 @@
 
 use std::fmt;
 
+use jiff::Timestamp;
 use serde::Serialize;
-use time::OffsetDateTime;
 
 use crate::{Apath, EntryTrait, Kind, Owner, Result, UnixMode};
 
@@ -138,7 +138,7 @@ pub struct EntryMetadata {
     // TODO: Eventually unify with EntryValue or Entry?
     #[serde(flatten)]
     pub kind: KindMetadata,
-    pub mtime: OffsetDateTime,
+    pub mtime: Timestamp,
     #[serde(flatten)]
     pub owner: Owner,
     pub unix_mode: UnixMode,

src/change.rs

@@ -16,8 +16,8 @@
 
 use std::fmt::Debug;
 
+use jiff::Timestamp;
 use serde::Serialize;
-use time::OffsetDateTime;
 
 use crate::*;
 
@@ -29,7 +29,7 @@ use crate::*;
 pub trait EntryTrait: Debug {
     fn apath(&self) -> &Apath;
     fn kind(&self) -> Kind;
-    fn mtime(&self) -> OffsetDateTime;
+    fn mtime(&self) -> Timestamp;
     fn size(&self) -> Option<u64>;
     fn symlink_target(&self) -> Option<&str>;
     fn unix_mode(&self) -> UnixMode;

src/entry.rs

@@ -11,15 +11,14 @@
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 // GNU General Public License for more details.
 
+use jiff::Timestamp;
 use serde_json::json;
-use time::OffsetDateTime;
 
 use crate::apath::Apath;
 use crate::entry::EntryTrait;
 use crate::kind::Kind;
 use crate::owner::Owner;
 use crate::unix_mode::UnixMode;
-use crate::unix_time::FromUnixAndNanos;
 use crate::{blockdir, source};
 
 /// Description of one archived file.
@@ -83,8 +82,9 @@ impl EntryTrait for IndexEntry {
     }
 
     #[inline]
-    fn mtime(&self) -> OffsetDateTime {
-        OffsetDateTime::from_unix_seconds_and_nanos(self.mtime, self.mtime_nanos)
+    fn mtime(&self) -> Timestamp {
+        Timestamp::new(self.mtime, self.mtime_nanos.try_into().unwrap())
+            .expect("Failed to convert mtime and mtime_nanos to Timestamp")
     }
 
     /// Size of the file, if it is a file. None for directories and symlinks.
@@ -142,8 +142,8 @@ impl IndexEntry {
             kind: source.kind(),
             addrs: Vec::new(),
             target: source.symlink_target().map(|t| t.to_owned()),
-            mtime: mtime.unix_timestamp(),
-            mtime_nanos: mtime.nanosecond(),
+            mtime: mtime.as_second(),
+            mtime_nanos: mtime.subsec_nanosecond().try_into().unwrap(),
             unix_mode: source.unix_mode(),
             owner: source.owner().to_owned(),
         }

src/index/entry.rs

@@ -21,7 +21,7 @@ use std::sync::Arc;
 use filetime::set_file_handle_times;
 #[cfg(unix)]
 use filetime::set_symlink_file_times;
-use time::OffsetDateTime;
+use jiff::Timestamp;
 use tracing::{instrument, trace};
 
 use crate::blockdir::BlockDir;
@@ -176,7 +176,7 @@ fn restore_dir(apath: &Apath, restore_path: &Path, options: &RestoreOptions) ->
 struct DirDeferral {
     path: PathBuf,
     unix_mode: UnixMode,
-    mtime: OffsetDateTime,
+    mtime: Timestamp,
     owner: Owner,
 }
 
@@ -200,7 +200,7 @@ fn apply_deferrals(deferrals: &[DirDeferral], monitor: Arc<dyn Monitor>) -> Resu
                 source,
             });
         }
-        if let Err(source) = filetime::set_file_mtime(path, (*mtime).to_file_time()) {
+        if let Err(source) = filetime::set_file_mtime(path, mtime.to_file_time()) {
             monitor.error(Error::RestoreModificationTime {
                 path: path.clone(),
                 source,