fix: Use Instant instead of SystemTime when aplicable

If a time value doesn't need to be sent to another host, saved to the db or otherwise used across
program restarts, a monotonically nondecreasing clock should be used.

Author: iequidoo

src/context.rs

@@ -6,7 +6,7 @@ use std::ops::Deref;
 use std::path::{Path, PathBuf};
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
-use std::time::{Duration, Instant, SystemTime};
+use std::time::{Duration, Instant};
 
 use anyhow::{bail, ensure, Context as _, Result};
 use async_channel::{self as channel, Receiver, Sender};
@@ -232,7 +232,7 @@ pub struct InnerContext {
     /// be identified by this ID.
     pub(crate) id: u32,
 
-    creation_time: SystemTime,
+    creation_time: Instant,
 
     /// The text of the last error logged and emitted as an event.
     /// If the ui wants to display an error after a failure,
@@ -384,7 +384,7 @@ impl Context {
             resync_request: AtomicBool::new(false),
             new_msgs_notify,
             server_id: RwLock::new(None),
-            creation_time: std::time::SystemTime::now(),
+            creation_time: std::time::Instant::now(),
             last_full_folder_scan: Mutex::new(None),
             last_error: std::sync::RwLock::new("".to_string()),
             debug_logging: std::sync::RwLock::new(None),
@@ -790,7 +790,7 @@ impl Context {
         );
 
         let elapsed = self.creation_time.elapsed();
-        res.insert("uptime", duration_to_str(elapsed.unwrap_or_default()));
+        res.insert("uptime", duration_to_str(elapsed));
 
         Ok(res)
     }
@@ -1051,7 +1051,7 @@ pub fn get_version_str() -> &'static str {
 
 #[cfg(test)]
 mod tests {
-    use std::time::Duration;
+    use std::time::{Duration, SystemTime};
 
     use anyhow::Context as _;
     use strum::IntoEnumIterator;

src/imap/idle.rs

@@ -1,4 +1,4 @@
-use std::time::{Duration, SystemTime};
+use std::time::{Duration, Instant};
 
 use anyhow::{bail, Context as _, Result};
 use async_channel::Receiver;
@@ -106,7 +106,7 @@ impl Imap {
         // Idle using polling. This is also needed if we're not yet configured -
         // in this case, we're waiting for a configure job (and an interrupt).
 
-        let fake_idle_start_time = SystemTime::now();
+        let fake_idle_start_time = Instant::now();
 
         // Do not poll, just wait for an interrupt when no folder is passed in.
         let watch_folder = if let Some(watch_folder) = watch_folder {
@@ -196,9 +196,8 @@ impl Imap {
         info!(
             context,
             "IMAP-fake-IDLE done after {:.4}s",
-            SystemTime::now()
+            Instant::now()
                 .duration_since(fake_idle_start_time)
-                .unwrap_or_default()
                 .as_millis() as f64
                 / 1000.,
         );

src/key.rs

@@ -207,7 +207,7 @@ async fn generate_keypair(context: &Context) -> Result<KeyPair> {
     match load_keypair(context, &addr).await? {
         Some(key_pair) => Ok(key_pair),
         None => {
-            let start = std::time::SystemTime::now();
+            let start = std::time::Instant::now();
             let keytype = KeyGenType::from_i32(context.get_config_int(Config::KeyGenType).await?)
                 .unwrap_or_default();
             info!(context, "Generating keypair with type {}", keytype);
@@ -219,7 +219,7 @@ async fn generate_keypair(context: &Context) -> Result<KeyPair> {
             info!(
                 context,
                 "Keypair generated in {:.3}s.",
-                start.elapsed().unwrap_or_default().as_secs()
+                start.elapsed().as_secs(),
             );
             Ok(keypair)
         }

src/quota.rs

@@ -1,6 +1,7 @@
 //! # Support for IMAP QUOTA extension.
 
 use std::collections::BTreeMap;
+use std::time::Instant;
 
 use anyhow::{anyhow, Context as _, Result};
 use async_imap::types::{Quota, QuotaResource};
@@ -12,7 +13,6 @@ use crate::imap::scan_folders::get_watched_folders;
 use crate::imap::session::Session as ImapSession;
 use crate::imap::Imap;
 use crate::message::{Message, Viewtype};
-use crate::tools::time;
 use crate::{stock_str, EventType};
 
 /// warn about a nearly full mailbox after this usage percentage is reached.
@@ -40,8 +40,8 @@ pub struct QuotaInfo {
     /// set to `Ok()` for valid quota information.
     pub(crate) recent: Result<BTreeMap<String, Vec<QuotaResource>>>,
 
-    /// Timestamp when structure was modified.
-    pub(crate) modified: i64,
+    /// When the structure was modified.
+    pub(crate) modified: Instant,
 }
 
 async fn get_unique_quota_roots_and_usage(
@@ -147,7 +147,7 @@ impl Context {
 
         *self.quota.write().await = Some(QuotaInfo {
             recent: quota,
-            modified: time(),
+            modified: Instant::now(),
         });
 
         self.emit_event(EventType::ConnectivityChanged);

src/scheduler.rs

@@ -2,6 +2,7 @@ use std::cmp;
 use std::iter::{self, once};
 use std::num::NonZeroUsize;
 use std::sync::atomic::Ordering;
+use std::time::Duration;
 
 use anyhow::{bail, Context as _, Error, Result};
 use async_channel::{self as channel, Receiver, Sender};
@@ -384,7 +385,7 @@ async fn inbox_loop(
                     let quota = ctx.quota.read().await;
                     quota
                         .as_ref()
-                        .filter(|quota| quota.modified + 60 > time())
+                        .filter(|quota| quota.modified.elapsed() > Duration::from_secs(60))
                         .is_none()
                 };
 

src/smtp.rs

@@ -2,7 +2,7 @@
 
 pub mod send;
 
-use std::time::{Duration, SystemTime};
+use std::time::{Duration, Instant};
 
 use anyhow::{bail, format_err, Context as _, Error, Result};
 use async_smtp::response::{Category, Code, Detail};
@@ -41,7 +41,7 @@ pub(crate) struct Smtp {
     /// Timestamp of last successful send/receive network interaction
     /// (eg connect or send succeeded). On initialization and disconnect
     /// it is set to None.
-    last_success: Option<SystemTime>,
+    last_success: Option<Instant>,
 
     pub(crate) connectivity: ConnectivityStore,
 
@@ -70,11 +70,7 @@ impl Smtp {
     /// have been successfully used the last 60 seconds
     pub fn has_maybe_stale_connection(&self) -> bool {
         if let Some(last_success) = self.last_success {
-            SystemTime::now()
-                .duration_since(last_success)
-                .unwrap_or_default()
-                .as_secs()
-                > 60
+            Instant::now().duration_since(last_success).as_secs() > 60
         } else {
             false
         }
@@ -334,7 +330,7 @@ impl Smtp {
         }
 
         self.transport = Some(transport);
-        self.last_success = Some(SystemTime::now());
+        self.last_success = Some(Instant::now());
 
         context.emit_event(EventType::SmtpConnected(format!(
             "SMTP-LOGIN as {} ok",

src/smtp/send.rs

@@ -69,7 +69,7 @@ impl Smtp {
                 );
                 info!(context, "{info_msg}.");
                 context.emit_event(EventType::SmtpMessageSent(info_msg));
-                self.last_success = Some(std::time::SystemTime::now());
+                self.last_success = Some(std::time::Instant::now());
             } else {
                 warn!(
                     context,