Switch from time to chrono

Author: djc

Cargo.toml

@@ -18,6 +18,7 @@ webpki-roots = ["hyper-rustls/webpki-roots"]
 [dependencies]
 async-trait = "0.1"
 base64 = "0.21"
+chrono = { version = "0.4.31", features = ["serde"] }
 dirs-next = "2.0"
 hyper = { version = "0.14.2", features = ["client", "runtime", "http2"] }
 hyper-rustls = { version = "0.24", default-features = false, features = ["tokio-runtime", "http1", "http2"] }
@@ -27,7 +28,6 @@ rustls-pemfile = "1.0.0"
 serde = { version = "1.0", features = ["derive", "rc"] }
 serde_json = "1.0"
 thiserror = "1.0"
-time = { version = "0.3.5", features = ["serde"] }
 tokio = { version = "1.1", features = ["fs", "sync"] }
 tracing = "0.1.29"
 tracing-futures = "0.2.5"

src/gcloud_authorized_user.rs

@@ -1,9 +1,9 @@
 use std::path::{Path, PathBuf};
 use std::process::Command;
 use std::sync::RwLock;
+use std::time::Duration;
 
 use async_trait::async_trait;
-use time::Duration;
 use which::which;
 
 use crate::authentication_manager::ServiceAccount;
@@ -15,7 +15,7 @@ use crate::Token;
 /// The default number of seconds that it takes for a Google Cloud auth token to expire.
 /// This appears to be the default from practical testing, but we have not found evidence
 /// that this will always be the default duration.
-pub(crate) const DEFAULT_TOKEN_DURATION: Duration = Duration::seconds(3600);
+pub(crate) const DEFAULT_TOKEN_DURATION: Duration = Duration::from_secs(3600);
 
 #[derive(Debug)]
 pub(crate) struct GCloudAuthorizedUser {
@@ -79,7 +79,8 @@ fn run(gcloud: &Path, cmd: &[&str]) -> Result<String, Error> {
 
 #[cfg(test)]
 mod tests {
-    use time::{Duration, OffsetDateTime};
+    use chrono::Utc;
+    use std::time::Duration;
 
     use super::*;
 
@@ -89,11 +90,11 @@ mod tests {
         let gcloud = GCloudAuthorizedUser::new().await.unwrap();
         println!("{:?}", gcloud.project_id);
         if let Some(t) = gcloud.get_token(&[""]) {
-            let expires = OffsetDateTime::now_utc() + DEFAULT_TOKEN_DURATION;
+            let expires = Utc::now() + DEFAULT_TOKEN_DURATION;
             println!("{:?}", t);
             assert!(!t.has_expired());
-            assert!(t.expires_at() < expires + Duration::seconds(1));
-            assert!(t.expires_at() > expires - Duration::seconds(1));
+            assert!(t.expires_at() < expires + Duration::from_secs(1));
+            assert!(t.expires_at() > expires - Duration::from_secs(1));
         } else {
             panic!("GCloud Authorized User failed to get a token");
         }
@@ -106,12 +107,12 @@ mod tests {
     fn test_token_from_string() {
         let s = String::from("abc123");
         let token = Token::from_string(s, DEFAULT_TOKEN_DURATION);
-        let expires = OffsetDateTime::now_utc() + DEFAULT_TOKEN_DURATION;
+        let expires = Utc::now() + DEFAULT_TOKEN_DURATION;
 
         assert_eq!(token.as_str(), "abc123");
         assert!(!token.has_expired());
-        assert!(token.expires_at() < expires + Duration::seconds(1));
-        assert!(token.expires_at() > expires - Duration::seconds(1));
+        assert!(token.expires_at() < expires + Duration::from_secs(1));
+        assert!(token.expires_at() > expires - Duration::from_secs(1));
     }
 
     #[test]

src/jwt.rs

@@ -1,6 +1,7 @@
 //! Copyright (c) 2016 Google Inc ([email protected]).
 
 use base64::{engine::general_purpose::URL_SAFE, Engine};
+use chrono::Utc;
 use serde::Serialize;
 
 use crate::custom_service_account::ApplicationCredentials;
@@ -31,7 +32,7 @@ impl<'a> Claims<'a> {
     where
         T: std::string::ToString,
     {
-        let iat = time::OffsetDateTime::now_utc().unix_timestamp();
+        let iat = Utc::now().timestamp();
         let expiry = iat + 3600 - 5; // Max validity is 1h.
 
         let scope: String = scopes

src/types.rs

@@ -1,14 +1,15 @@
 use std::sync::Arc;
+use std::time::Duration;
 use std::{fmt, io};
 
+use chrono::{DateTime, Utc};
 use hyper::Client;
 use hyper_rustls::HttpsConnectorBuilder;
 use ring::{
     rand::SystemRandom,
     signature::{RsaKeyPair, RSA_PKCS1_SHA256},
 };
 use serde::{Deserialize, Deserializer};
-use time::{Duration, OffsetDateTime};
 
 use crate::Error;
 /// Represents an access token. All access tokens are Bearer tokens.
@@ -34,7 +35,7 @@ impl Token {
         Token {
             inner: Arc::new(InnerToken {
                 access_token,
-                expires_at: OffsetDateTime::now_utc() + expires_in,
+                expires_at: Utc::now() + expires_in,
             }),
         }
     }
@@ -56,7 +57,7 @@ struct InnerToken {
         deserialize_with = "deserialize_time",
         rename(deserialize = "expires_in")
     )]
-    expires_at: OffsetDateTime,
+    expires_at: DateTime<Utc>,
 }
 
 impl Token {
@@ -71,7 +72,7 @@ impl Token {
     /// The docs state, the metadata server caches tokens until 5 minutes before expiry.
     /// We use 20s to be on the safe side.
     pub fn has_expired(&self) -> bool {
-        self.inner.expires_at - Duration::seconds(20) <= OffsetDateTime::now_utc()
+        self.inner.expires_at - Duration::from_secs(20) <= Utc::now()
     }
 
     /// Get str representation of the token.
@@ -80,7 +81,7 @@ impl Token {
     }
 
     /// Get expiry of token, if available
-    pub fn expires_at(&self) -> OffsetDateTime {
+    pub fn expires_at(&self) -> DateTime<Utc> {
         self.inner.expires_at
     }
 }
@@ -138,12 +139,12 @@ impl fmt::Debug for Signer {
     }
 }
 
-fn deserialize_time<'de, D>(deserializer: D) -> Result<OffsetDateTime, D::Error>
+fn deserialize_time<'de, D>(deserializer: D) -> Result<DateTime<Utc>, D::Error>
 where
     D: Deserializer<'de>,
 {
-    let seconds_from_now: i64 = Deserialize::deserialize(deserializer)?;
-    Ok(OffsetDateTime::now_utc() + Duration::seconds(seconds_from_now))
+    let seconds_from_now: u64 = Deserialize::deserialize(deserializer)?;
+    Ok(Utc::now() + Duration::from_secs(seconds_from_now))
 }
 
 pub(crate) fn client() -> HyperClient {
@@ -166,13 +167,13 @@ mod tests {
     fn test_deserialize_with_time() {
         let s = r#"{"access_token":"abc123","expires_in":100}"#;
         let token: Token = serde_json::from_str(s).unwrap();
-        let expires = OffsetDateTime::now_utc() + Duration::seconds(100);
+        let expires = Utc::now() + Duration::from_secs(100);
 
         assert_eq!(token.as_str(), "abc123");
 
         // Testing time is always racy, give it 1s leeway.
         let expires_at = token.expires_at();
-        assert!(expires_at < expires + Duration::seconds(1));
-        assert!(expires_at > expires - Duration::seconds(1));
+        assert!(expires_at < expires + Duration::from_secs(1));
+        assert!(expires_at > expires - Duration::from_secs(1));
     }
 }