torrust · da2ce7 · Sep 14, 2022 · Sep 12, 2022 · Sep 12, 2022 · josecelano
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -19,7 +19,13 @@ lto = "fat"
 strip = true
 
 [dependencies]
-tokio = { version = "1.7", features = ["rt-multi-thread", "net", "sync", "macros", "signal"] }
+tokio = { version = "1.7", features = [
+    "rt-multi-thread",
+    "net",
+    "sync",
+    "macros",
+    "signal",
+] }
 
 serde = { version = "1.0", features = ["derive"] }
 serde_bencode = "^0.2.3"
@@ -28,6 +34,7 @@ serde_with = "2.0.0"
 hex = "0.4.3"
 percent-encoding = "2.1.0"
 binascii = "0.1"
+lazy_static = "1.4.0"
 
 openssl = { version = "0.10.41", features = ["vendored"] }
 

diff --git a/src/api/server.rs b/src/api/server.rs
@@ -2,6 +2,7 @@ use std::cmp::min;
 use std::collections::{HashMap, HashSet};
 use std::net::SocketAddr;
 use std::sync::Arc;
+use std::time::Duration;
 
 use serde::{Deserialize, Serialize};
 use warp::{filters, reply, serve, Filter};
@@ -268,7 +269,7 @@ pub fn start(socket_addr: SocketAddr, tracker: Arc<TorrentTracker>) -> impl warp
             (seconds_valid, tracker)
         })
         .and_then(|(seconds_valid, tracker): (u64, Arc<TorrentTracker>)| async move {
-            match tracker.generate_auth_key(seconds_valid).await {
+            match tracker.generate_auth_key(Duration::from_secs(seconds_valid)).await {
                 Ok(auth_key) => Ok(warp::reply::json(&auth_key)),
                 Err(..) => Err(warp::reject::custom(ActionStatus::Err {
                     reason: "failed to generate key".into(),

diff --git a/src/databases/mysql.rs b/src/databases/mysql.rs
@@ -1,4 +1,5 @@
 use std::str::FromStr;
+use std::time::Duration;
 
 use async_trait::async_trait;
 use log::debug;
@@ -94,7 +95,7 @@ impl Database for MysqlDatabase {
                 "SELECT `key`, valid_until FROM `keys`",
                 |(key, valid_until): (String, i64)| AuthKey {
                     key,
-                    valid_until: Some(valid_until as u64),
+                    valid_until: Some(Duration::from_secs(valid_until as u64)),
                 },
             )
             .map_err(|_| database::Error::QueryReturnedNoRows)?;
@@ -187,7 +188,7 @@ impl Database for MysqlDatabase {
         {
             Some((key, valid_until)) => Ok(AuthKey {
                 key,
-                valid_until: Some(valid_until as u64),
+                valid_until: Some(Duration::from_secs(valid_until as u64)),
             }),
             None => Err(database::Error::InvalidQuery),
         }
@@ -197,7 +198,7 @@ impl Database for MysqlDatabase {
         let mut conn = self.pool.get().map_err(|_| database::Error::DatabaseError)?;
 
         let key = auth_key.key.to_string();
-        let valid_until = auth_key.valid_until.unwrap_or(0).to_string();
+        let valid_until = auth_key.valid_until.unwrap_or(Duration::ZERO).as_secs().to_string();
 
         match conn.exec_drop(
             "INSERT INTO `keys` (`key`, valid_until) VALUES (:key, :valid_until)",

diff --git a/src/databases/sqlite.rs b/src/databases/sqlite.rs
@@ -7,6 +7,7 @@ use r2d2_sqlite::SqliteConnectionManager;
 
 use crate::databases::database;
 use crate::databases::database::{Database, Error};
+use crate::protocol::clock::clock::SinceUnixEpoch;
 use crate::tracker::key::AuthKey;
 use crate::InfoHash;
 
@@ -85,7 +86,7 @@ impl Database for SqliteDatabase {
 
             Ok(AuthKey {
                 key,
-                valid_until: Some(valid_until as u64),
+                valid_until: Some(SinceUnixEpoch::from_secs(valid_until as u64)),
             })
         })?;
 
@@ -192,7 +193,7 @@ impl Database for SqliteDatabase {
 
             Ok(AuthKey {
                 key,
-                valid_until: Some(valid_until_i64 as u64),
+                valid_until: Some(SinceUnixEpoch::from_secs(valid_until_i64 as u64)),
             })
         } else {
             Err(database::Error::QueryReturnedNoRows)
@@ -204,7 +205,7 @@ impl Database for SqliteDatabase {
 
         match conn.execute(
             "INSERT INTO keys (key, valid_until) VALUES (?1, ?2)",
-            [auth_key.key.to_string(), auth_key.valid_until.unwrap().to_string()],
+            [auth_key.key.to_string(), auth_key.valid_until.unwrap().as_secs().to_string()],
         ) {
             Ok(updated) => {
                 if updated > 0 {

diff --git a/src/lib.rs b/src/lib.rs
@@ -16,3 +16,14 @@ pub mod protocol;
 pub mod setup;
 pub mod tracker;
 pub mod udp;
+
+#[macro_use]
+extern crate lazy_static;
+
+pub mod static_time {
+    use std::time::SystemTime;
+
+    lazy_static! {
+        pub static ref TIME_AT_APP_START: SystemTime = SystemTime::now();
+    }
+}
diff --git a/src/main.rs b/src/main.rs
@@ -2,12 +2,15 @@ use std::sync::Arc;
 
 use log::info;
 use torrust_tracker::tracker::tracker::TorrentTracker;
-use torrust_tracker::{logging, setup, Configuration};
+use torrust_tracker::{logging, setup, static_time, Configuration};
 
 #[tokio::main]
 async fn main() {
     const CONFIG_PATH: &str = "config.toml";
 
+    // Set the time of Torrust app starting
+    lazy_static::initialize(&static_time::TIME_AT_APP_START);
+
     // Initialize Torrust config
     let config = match Configuration::load_from_file(CONFIG_PATH) {
         Ok(config) => Arc::new(config),

diff --git a/src/protocol/clock/clock.rs b/src/protocol/clock/clock.rs
@@ -0,0 +1,248 @@
+use std::num::IntErrorKind;
+pub use std::time::Duration;
+
+pub type SinceUnixEpoch = Duration;
+
+#[derive(Debug)]
+pub enum ClockType {
+    WorkingClock,
+    StoppedClock,
+}
+
+#[derive(Debug)]
+pub struct Clock<const T: usize>;
+
+pub type WorkingClock = Clock<{ ClockType::WorkingClock as usize }>;
+pub type StoppedClock = Clock<{ ClockType::StoppedClock as usize }>;
+
+#[cfg(not(test))]
+pub type DefaultClock = WorkingClock;
+
+#[cfg(test)]
+pub type DefaultClock = StoppedClock;
+
+pub trait Time: Sized {
+    fn now() -> SinceUnixEpoch;
+}
+
+pub trait TimeNow: Time {
+    fn add(add_time: &Duration) -> Option<SinceUnixEpoch> {
+        Self::now().checked_add(*add_time)
+    }
+    fn sub(sub_time: &Duration) -> Option<SinceUnixEpoch> {
+        Self::now().checked_sub(*sub_time)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::any::TypeId;
+
+    use crate::protocol::clock::clock::{DefaultClock, StoppedClock, Time, WorkingClock};
+
+    #[test]
+    fn it_should_be_the_stopped_clock_as_default_when_testing() {
+        // We are testing, so we should default to the fixed time.
+        assert_eq!(TypeId::of::<StoppedClock>(), TypeId::of::<DefaultClock>());
+        assert_eq!(StoppedClock::now(), DefaultClock::now())
+    }
+
+    #[test]
+    fn it_should_have_different_times() {
+        assert_ne!(TypeId::of::<StoppedClock>(), TypeId::of::<WorkingClock>());
+        assert_ne!(StoppedClock::now(), WorkingClock::now())
+    }
+}
+
+mod working_clock {
+    use std::time::SystemTime;
+
+    use super::{SinceUnixEpoch, Time, TimeNow, WorkingClock};
+
+    impl Time for WorkingClock {
+        fn now() -> SinceUnixEpoch {
+            SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap()
+        }
+    }
+
+    impl TimeNow for WorkingClock {}
+}
+
+pub trait StoppedTime: TimeNow {
+    fn local_set(unix_time: &SinceUnixEpoch);
+    fn local_set_to_unix_epoch() {
+        Self::local_set(&SinceUnixEpoch::ZERO)
+    }
+    fn local_set_to_app_start_time();
+    fn local_set_to_system_time_now();
+    fn local_add(duration: &Duration) -> Result<(), IntErrorKind>;
+    fn local_sub(duration: &Duration) -> Result<(), IntErrorKind>;
+    fn local_reset();
+}
+
+mod stopped_clock {
+    use std::num::IntErrorKind;
+    use std::time::Duration;
+
+    use super::{SinceUnixEpoch, StoppedClock, StoppedTime, Time, TimeNow};
+
+    impl Time for StoppedClock {
+        fn now() -> SinceUnixEpoch {
+            detail::FIXED_TIME.with(|time| {
+                return *time.borrow();
+            })
+        }
+    }
+
+    impl TimeNow for StoppedClock {}
+
+    impl StoppedTime for StoppedClock {
+        fn local_set(unix_time: &SinceUnixEpoch) {
+            detail::FIXED_TIME.with(|time| {
+                *time.borrow_mut() = *unix_time;
+            })
+        }
+
+        fn local_set_to_app_start_time() {
+            Self::local_set(&detail::get_app_start_time())
+        }
+
+        fn local_set_to_system_time_now() {
+            Self::local_set(&detail::get_app_start_time())
+        }
+
+        fn local_add(duration: &Duration) -> Result<(), IntErrorKind> {
+            detail::FIXED_TIME.with(|time| {
+                let time_borrowed = *time.borrow();
+                *time.borrow_mut() = match time_borrowed.checked_add(*duration) {
+                    Some(time) => time,
+                    None => {
+                        return Err(IntErrorKind::PosOverflow);
+                    }
+                };
+                Ok(())
+            })
+        }
+
+        fn local_sub(duration: &Duration) -> Result<(), IntErrorKind> {
+            detail::FIXED_TIME.with(|time| {
+                let time_borrowed = *time.borrow();
+                *time.borrow_mut() = match time_borrowed.checked_sub(*duration) {
+                    Some(time) => time,
+                    None => {
+                        return Err(IntErrorKind::NegOverflow);
+                    }
+                };
+                Ok(())
+            })
+        }
+
+        fn local_reset() {
+            Self::local_set(&detail::get_default_fixed_time())
+        }
+    }
+
+    #[cfg(test)]
+    mod tests {
+        use std::thread;
+        use std::time::Duration;
+
+        use crate::protocol::clock::clock::{SinceUnixEpoch, StoppedClock, StoppedTime, Time, TimeNow, WorkingClock};
+
+        #[test]
+        fn it_should_default_to_zero_when_testing() {
+            assert_eq!(StoppedClock::now(), SinceUnixEpoch::ZERO)
+        }
+
+        #[test]
+        fn it_should_possible_to_set_the_time() {
+            // Check we start with ZERO.
+            assert_eq!(StoppedClock::now(), Duration::ZERO);
+
+            // Set to Current Time and Check
+            let timestamp = WorkingClock::now();
+            StoppedClock::local_set(&timestamp);
+            assert_eq!(StoppedClock::now(), timestamp);
+
+            // Elapse the Current Time and Check
+            StoppedClock::local_add(&timestamp).unwrap();
+            assert_eq!(StoppedClock::now(), timestamp + timestamp);
+
+            // Reset to ZERO and Check
+            StoppedClock::local_reset();
+            assert_eq!(StoppedClock::now(), Duration::ZERO);
+        }
+
+        #[test]
+        fn it_should_default_to_zero_on_thread_exit() {
+            assert_eq!(StoppedClock::now(), Duration::ZERO);
+            let after5 = WorkingClock::add(&Duration::from_secs(5)).unwrap();
+            StoppedClock::local_set(&after5);
+            assert_eq!(StoppedClock::now(), after5);
+
+            let t = thread::spawn(move || {
+                // each thread starts out with the initial value of ZERO
+                assert_eq!(StoppedClock::now(), Duration::ZERO);
+
+                // and gets set to the current time.
+                let timestamp = WorkingClock::now();
+                StoppedClock::local_set(&timestamp);
+                assert_eq!(StoppedClock::now(), timestamp);
+            });
+
+            // wait for the thread to complete and bail out on panic
+            t.join().unwrap();
+
+            // we retain our original value of current time + 5sec despite the child thread
+            assert_eq!(StoppedClock::now(), after5);
+
+            // Reset to ZERO and Check
+            StoppedClock::local_reset();
+            assert_eq!(StoppedClock::now(), Duration::ZERO);
+        }
+    }
+
+    mod detail {
+        use std::cell::RefCell;
+        use std::time::SystemTime;
+
+        use crate::protocol::clock::clock::SinceUnixEpoch;
+        use crate::static_time;
+
+        pub fn get_app_start_time() -> SinceUnixEpoch {
+            (*static_time::TIME_AT_APP_START)
+                .duration_since(SystemTime::UNIX_EPOCH)
+                .unwrap()
+        }
+
+        #[cfg(not(test))]
+        pub fn get_default_fixed_time() -> SinceUnixEpoch {
+            get_app_start_time()
+        }
+
+        #[cfg(test)]
+        pub fn get_default_fixed_time() -> SinceUnixEpoch {
+            SinceUnixEpoch::ZERO
+        }
+
+        thread_local!(pub static FIXED_TIME: RefCell<SinceUnixEpoch>   = RefCell::new(get_default_fixed_time()));
+
+        #[cfg(test)]
+        mod tests {
+            use std::time::Duration;
+
+            use crate::protocol::clock::clock::stopped_clock::detail::{get_app_start_time, get_default_fixed_time};
+
+            #[test]
+            fn it_should_get_the_zero_start_time_when_testing() {
+                assert_eq!(get_default_fixed_time(), Duration::ZERO);
+            }
+
+            #[test]
+            fn it_should_get_app_start_time() {
+                const TIME_AT_WRITING_THIS_TEST: Duration = Duration::new(1662983731, 000022312);
+                assert!(get_app_start_time() > TIME_AT_WRITING_THIS_TEST);
+            }
+        }
+    }
+}
diff --git a/src/protocol/clock/mod.rs b/src/protocol/clock/mod.rs
@@ -0,0 +1 @@
+pub mod clock;