feat: normalize durations and timestamps (#837)

feat: normalize durations and timestamps

Author: taddes

Cargo.toml

@@ -108,4 +108,4 @@ autoconnect_ws_clientsm = { path = "./autoconnect/autoconnect-ws/autoconnect-ws-
 autopush_common = { path = "./autopush-common", features = ["bigtable"] }
 
 [profile.release]
-debug = 1
+debug = 1

autoendpoint/src/extractors/notification_headers.rs

@@ -70,7 +70,7 @@ impl NotificationHeaders {
             // Enforce a maximum TTL, but don't error
             // NOTE: In order to trap for negative TTLs, this should be a
             // signed value, otherwise we will error out with NO_TTL.
-            .map(|ttl| min(ttl, MAX_NOTIFICATION_TTL as i64))
+            .map(|ttl| min(ttl, MAX_NOTIFICATION_TTL.num_seconds()))
             .ok_or(ApiErrorKind::NoTTL)?;
         let topic = get_owned_header(req, "topic");
 
@@ -218,6 +218,7 @@ mod tests {
     use crate::error::{ApiErrorKind, ApiResult};
     use actix_web::test::TestRequest;
     use autopush_common::MAX_NOTIFICATION_TTL;
+    use chrono::TimeDelta;
 
     /// Assert that a result is a validation error and check its serialization
     /// against the JSON value.
@@ -283,12 +284,17 @@ mod tests {
     #[test]
     fn maximum_ttl() {
         let req = TestRequest::post()
-            .insert_header(("TTL", (MAX_NOTIFICATION_TTL + 1).to_string()))
+            .insert_header((
+                "TTL",
+                (MAX_NOTIFICATION_TTL + TimeDelta::seconds(1))
+                    .num_seconds()
+                    .to_string(),
+            ))
             .to_http_request();
         let result = NotificationHeaders::from_request(&req, false);
 
         assert!(result.is_ok());
-        assert_eq!(result.unwrap().ttl, MAX_NOTIFICATION_TTL as i64);
+        assert_eq!(result.unwrap().ttl, MAX_NOTIFICATION_TTL.num_seconds());
     }
 
     /// A valid topic results in no errors

autoendpoint/src/headers/vapid.rs

@@ -3,11 +3,12 @@ use std::collections::HashMap;
 use std::fmt;
 
 use base64::Engine;
+use chrono::TimeDelta;
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
 
 use crate::headers::util::split_key_value;
-use autopush_common::util::{sec_since_epoch, ONE_DAY_IN_SECONDS};
+use autopush_common::util::sec_since_epoch;
 
 pub const ALLOWED_SCHEMES: [&str; 3] = ["bearer", "webpush", "vapid"];
 
@@ -37,8 +38,9 @@ impl Default for VapidClaims {
 }
 
 impl VapidClaims {
+    /// Returns default expiration of one day from creation (in seconds).
     pub fn default_exp() -> u64 {
-        sec_since_epoch() + ONE_DAY_IN_SECONDS
+        sec_since_epoch() + TimeDelta::days(1).num_seconds() as u64
     }
 }
 

autoendpoint/src/routers/fcm/router.rs

@@ -164,7 +164,7 @@ impl Router for FcmRouter {
 
         let (routing_token, app_id) =
             self.routing_info(router_data, &notification.subscription.user.uaid)?;
-        let ttl = MAX_FCM_NOTIFICATION_TTL
+        let ttl = (MAX_FCM_NOTIFICATION_TTL.num_seconds() as u64)
             .min(self.settings.min_ttl.max(notification.headers.ttl as u64));
 
         // Send the notification to FCM

autopush-common/src/db/bigtable/bigtable_client/mod.rs

@@ -9,6 +9,7 @@ use std::time::{Duration, SystemTime};
 use again::RetryPolicy;
 use async_trait::async_trait;
 use cadence::{CountedExt, StatsdClient};
+use chrono::TimeDelta;
 use futures_util::StreamExt;
 use google_cloud_rust_raw::bigtable::admin::v2::bigtable_table_admin::DropRowRangeRequest;
 use google_cloud_rust_raw::bigtable::admin::v2::bigtable_table_admin_grpc::BigtableTableAdminClient;
@@ -55,7 +56,9 @@ const MESSAGE_TOPIC_FAMILY: &str = "message_topic";
 #[cfg(feature = "reliable_report")]
 const RELIABLE_LOG_FAMILY: &str = "reliability";
 #[cfg(feature = "reliable_report")]
-const RELIABLE_LOG_TTL: u64 = crate::db::MAX_NOTIFICATION_TTL * 2;
+/// The maximum TTL for reliability logging (60 days).
+/// /// In most use cases, converted to seconds through .num_seconds().
+pub const RELIABLE_LOG_TTL: TimeDelta = TimeDelta::days(60);
 
 pub(crate) const RETRY_COUNT: usize = 5;
 
@@ -799,7 +802,8 @@ impl BigTableClientImpl {
     fn user_to_row(&self, user: &User, version: &Uuid) -> Row {
         let row_key = user.uaid.simple().to_string();
         let mut row = Row::new(row_key);
-        let expiry = std::time::SystemTime::now() + Duration::from_secs(MAX_ROUTER_TTL);
+        let expiry =
+            std::time::SystemTime::now() + Duration::from_secs(MAX_ROUTER_TTL.num_seconds() as u64);
 
         let mut cells: Vec<cell::Cell> = vec![
             cell::Cell {
@@ -1081,7 +1085,8 @@ impl DbClient for BigTableClientImpl {
         // easy/efficient
         let row_key = uaid.simple().to_string();
         let mut row = Row::new(row_key);
-        let expiry = std::time::SystemTime::now() + Duration::from_secs(MAX_ROUTER_TTL);
+        let expiry =
+            std::time::SystemTime::now() + Duration::from_secs(MAX_ROUTER_TTL.num_seconds() as u64);
 
         // Note: updating the version column isn't necessary here because this
         // write only adds a new (or updates an existing) column with a 0 byte
@@ -1124,7 +1129,8 @@ impl DbClient for BigTableClientImpl {
 
         // and write a new version cell
         let mut row = Row::new(row_key);
-        let expiry = std::time::SystemTime::now() + Duration::from_secs(MAX_ROUTER_TTL);
+        let expiry =
+            std::time::SystemTime::now() + Duration::from_secs(MAX_ROUTER_TTL.num_seconds() as u64);
         row.cells
             .insert(ROUTER_FAMILY.to_owned(), vec![new_version_cell(expiry)]);
         mutations.extend(self.get_mutations(row.cells)?);
@@ -1295,7 +1301,8 @@ impl DbClient for BigTableClientImpl {
             &row_key,
             timestamp.to_be_bytes().to_vec()
         );
-        let expiry = std::time::SystemTime::now() + Duration::from_secs(MAX_ROUTER_TTL);
+        let expiry =
+            std::time::SystemTime::now() + Duration::from_secs(MAX_ROUTER_TTL.num_seconds() as u64);
         let mut row = Row::new(row_key.clone());
 
         row.cells.insert(
@@ -1478,7 +1485,7 @@ impl DbClient for BigTableClientImpl {
         let row_key = reliability_id.to_owned();
 
         let mut row = Row::new(row_key);
-        let expiry = SystemTime::now() + Duration::from_secs(RELIABLE_LOG_TTL);
+        let expiry = SystemTime::now() + Duration::from_secs(RELIABLE_LOG_TTL.num_seconds() as u64);
 
         // Log the latest transition time for this id.
         let cells: Vec<cell::Cell> = vec![cell::Cell {

autopush-common/src/db/mod.rs

@@ -31,7 +31,7 @@ pub use reporter::spawn_pool_periodic_reporter;
 
 use crate::notification::Notification;
 use crate::util::timing::ms_since_epoch;
-use crate::{MAX_NOTIFICATION_TTL, MAX_ROUTER_TTL};
+use crate::MAX_ROUTER_TTL;
 use models::RangeKey;
 
 pub const USER_RECORD_VERSION: u64 = 1;

autopush-common/src/lib.rs

@@ -24,34 +24,40 @@ pub mod test_support;
 #[macro_use]
 pub mod util;
 
-/// Define some global TTLs.
-///
-/// [RFC8030 notes](https://datatracker.ietf.org/doc/html/rfc8030#section-5.2) that
-/// technically these are u32 values, but we should be kind and use u64. The RFC also
-/// does not define a maximum TTL duration. Traditionally, Autopush has capped this
-/// to 60 days, partly because we used to require monthly message table rotation.
-/// (The TTL was given an extra 30 days grace in order to handle dates near the
-/// turn of the month, when we might need to look in two tables for the data.)
-/// Since we now have automatically applied garbage collection, we are at a bit of
-/// liberty about how long these should be.
-///
-/// That gets back to the concept that Push messages are supposed to be "timely".
-/// A user may not appreciate that they have an undelivered calendar reminder from
-/// 58 days ago, nor should they be interested in a meeting alert that happened last
-/// month. When a User Agent (UA) connects, it receives all pending messages. If
-/// a user has not used the User Agent in more than
-/// [60 days](https://searchfox.org/mozilla-central/search?q=OFFER_PROFILE_RESET_INTERVAL_MS),
-/// the User Agent suggest "refreshing Firefox", which essentially throws away one's
-/// current profile. This would include all subscriptions a user may have had.
-///
-/// To that end, messages left unread for more than 30 days should be considered
-/// "abandoned" and any router info assigned to a User Agent that has not contacted
-/// Autopush in 60 days can be discarded.
-///
-const ONE_DAY_IN_SECONDS: u64 = 24 * 60 * 60;
-/// The maximum TTL for notifications, 30 days in seconds
-pub const MAX_NOTIFICATION_TTL: u64 = 30 * ONE_DAY_IN_SECONDS;
-/// FCM has a max TTL of 4 weeks.
-pub const MAX_FCM_NOTIFICATION_TTL: u64 = 4 * 7 * ONE_DAY_IN_SECONDS;
-/// The maximum TTL for router records, 60 days in seconds
-pub const MAX_ROUTER_TTL: u64 = 2 * MAX_NOTIFICATION_TTL;
+use chrono::TimeDelta;
+
+// Define some global TTLs.
+//
+// [RFC8030 notes](https://datatracker.ietf.org/doc/html/rfc8030#section-5.2) that
+// technically these are u32 values, but we should be kind and use u64. The RFC also
+// does not define a maximum TTL duration. Traditionally, Autopush has capped this
+// to 60 days, partly because we used to require monthly message table rotation.
+// (The TTL was given an extra 30 days grace in order to handle dates near the
+// turn of the month, when we might need to look in two tables for the data.)
+// Since we now have automatically applied garbage collection, we are at a bit of
+// liberty about how long these should be.
+//
+// That gets back to the concept that Push messages are supposed to be "timely".
+// A user may not appreciate that they have an undelivered calendar reminder from
+// 58 days ago, nor should they be interested in a meeting alert that happened last
+// month. When a User Agent (UA) connects, it receives all pending messages. If
+// a user has not used the User Agent in more than
+// [60 days](https://searchfox.org/mozilla-central/search?q=OFFER_PROFILE_RESET_INTERVAL_MS),
+// the User Agent suggest "refreshing Firefox", which essentially throws away one's
+// current profile. This would include all subscriptions a user may have had.
+//
+// To that end, messages left unread for more than 30 days should be considered
+// "abandoned" and any router info assigned to a User Agent that has not contacted
+// Autopush in 60 days can be discarded.
+
+/// The maximum TTL for notifications (30 days).
+/// In most use cases, converted to seconds through .num_seconds().
+pub const MAX_NOTIFICATION_TTL: TimeDelta = TimeDelta::days(30);
+
+/// FCM has a max TTL of 4 weeks (28 days).
+/// In most use cases, converted to seconds through .num_seconds().
+pub const MAX_FCM_NOTIFICATION_TTL: TimeDelta = TimeDelta::days(28);
+
+/// The maximum TTL for router records (60 days).
+/// In most use cases, converted to seconds through .num_seconds().
+pub const MAX_ROUTER_TTL: TimeDelta = TimeDelta::days(60);

autopush-common/src/reliability.rs

@@ -5,11 +5,12 @@
 /// and where messages expire early. Message expiration can lead to message loss
 use std::collections::HashMap;
 use std::sync::Arc;
-use std::time::Duration;
 
 use actix_web::HttpResponse;
 use cadence::{CountedExt, StatsdClient};
+use chrono::TimeDelta;
 use deadpool_redis::Config;
+
 use prometheus_client::{
     encoding::text::encode, metrics::family::Family, metrics::gauge::Gauge, registry::Registry,
 };
@@ -24,7 +25,7 @@ use crate::util::timing::sec_since_epoch;
 pub const COUNTS: &str = "state_counts";
 pub const EXPIRY: &str = "expiry";
 
-const CONNECTION_EXPIRATION: Duration = Duration::from_secs(10);
+const CONNECTION_EXPIRATION: TimeDelta = TimeDelta::seconds(10);
 
 /// The various states that a message may transit on the way from reception to delivery.
 // Note: "Message" in this context refers to the Subscription Update.
@@ -90,7 +91,7 @@ impl PushReliability {
                 .map_err(|e| {
                     ApcErrorKind::GeneralError(format!("Could not config reliability pool {:?}", e))
                 })?
-                .create_timeout(Some(CONNECTION_EXPIRATION))
+                .create_timeout(Some(CONNECTION_EXPIRATION.to_std().unwrap()))
                 .runtime(deadpool::Runtime::Tokio1)
                 .build()
                 .map_err(|e| {

autopush-common/src/util/mod.rs

@@ -11,8 +11,6 @@ pub mod user_agent;
 
 pub use self::timing::{ms_since_epoch, ms_utc_midnight, sec_since_epoch, us_since_epoch};
 
-pub const ONE_DAY_IN_SECONDS: u64 = 60 * 60 * 24;
-
 pub trait InsertOpt<K: Eq + Hash, V> {
     /// Insert an item only if it exists
     fn insert_opt(&mut self, key: impl Into<K>, value: Option<impl Into<V>>);

autopush-common/src/util/timing.rs

@@ -22,8 +22,7 @@ pub fn ms_utc_midnight() -> u64 {
 /// Get the time since the UNIX epoch in microseconds
 #[allow(dead_code)]
 pub fn us_since_epoch() -> u64 {
-    let now = Utc::now();
-    (now.timestamp() as u64) * 1_000_000 + (now.timestamp_subsec_micros() as u64)
+    Utc::now().timestamp_micros() as u64
 }
 
 /// Display a formatted date-time string from a SystemTime