Add talpid-future crate

Refactor some parts of `talpid-core` to `talpid-future`.

Author: MarkusPettersson98

Cargo.lock

@@ -11,31 +11,32 @@ members = [
     "android/translations-converter",
     "ios/MullvadREST/Transport/Shadowsocks/shadowsocks-proxy",
     "ios/TunnelObfuscation/tunnel-obfuscator-proxy",
-    "mullvad-daemon",
+    "mullvad-api",
     "mullvad-cli",
+    "mullvad-daemon",
+    "mullvad-exclude",
     "mullvad-fs",
-    "mullvad-setup",
-    "mullvad-problem-report",
     "mullvad-jni",
+    "mullvad-management-interface",
+    "mullvad-nsis",
     "mullvad-paths",
+    "mullvad-problem-report",
     "mullvad-relay-selector",
+    "mullvad-setup",
     "mullvad-types",
-    "mullvad-api",
-    "mullvad-exclude",
     "mullvad-version",
-    "mullvad-nsis",
-    "talpid-openvpn-plugin",
     "talpid-core",
     "talpid-dbus",
+    "talpid-future",
     "talpid-openvpn",
+    "talpid-openvpn-plugin",
     "talpid-platform-metadata",
     "talpid-routing",
     "talpid-time",
     "talpid-tunnel",
     "talpid-tunnel-config-client",
     "talpid-windows",
     "talpid-wireguard",
-    "mullvad-management-interface",
     "tunnel-obfuscation",
 ]
 

Cargo.toml

@@ -92,7 +92,3 @@ features = [
 
 [build-dependencies]
 tonic-build = { workspace = true, default-features = false, features = ["transport", "prost"] }
-
-[dev-dependencies]
-proptest = "1.4"
-tokio = { workspace = true, features = [ "test-util" ] }

talpid-core/Cargo.toml

@@ -149,105 +149,3 @@ fn apply_jitter(duration: Duration, jitter: f64) -> Duration {
     let millis = (secs * 1000f64) + (nanos / 1000000f64);
     Duration::from_millis(millis as u64)
 }
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    use proptest::prelude::*;
-
-    #[test]
-    fn test_constant_interval() {
-        let mut ivl = ConstantInterval::new(Duration::from_secs(2), Some(3));
-
-        assert_eq!(ivl.next(), Some(Duration::from_secs(2)));
-        assert_eq!(ivl.next(), Some(Duration::from_secs(2)));
-        assert_eq!(ivl.next(), Some(Duration::from_secs(2)));
-        assert_eq!(ivl.next(), None);
-    }
-
-    #[test]
-    fn test_constant_interval_no_max() {
-        let mut ivl = ConstantInterval::new(Duration::from_secs(2), None);
-        assert_eq!(ivl.next(), Some(Duration::from_secs(2)));
-    }
-
-    #[test]
-    fn test_exponential_backoff() {
-        let mut backoff = ExponentialBackoff::new(Duration::from_secs(2), 3);
-
-        assert_eq!(backoff.next(), Some(Duration::from_secs(2)));
-        assert_eq!(backoff.next(), Some(Duration::from_secs(6)));
-        assert_eq!(backoff.next(), Some(Duration::from_secs(18)));
-    }
-
-    #[test]
-    fn test_at_maximum_value() {
-        let max = Duration::MAX;
-        let mu = Duration::from_micros(1);
-        let mut backoff = ExponentialBackoff::new(max - mu, 2);
-
-        assert_eq!(backoff.next(), Some(max - mu));
-        assert_eq!(backoff.next(), Some(max));
-        assert_eq!(backoff.next(), Some(max));
-    }
-
-    #[test]
-    fn test_maximum_bound() {
-        let mut backoff = ExponentialBackoff::new(Duration::from_millis(2), 3)
-            .max_delay(Some(Duration::from_millis(7)));
-
-        assert_eq!(backoff.next(), Some(Duration::from_millis(2)));
-        assert_eq!(backoff.next(), Some(Duration::from_millis(6)));
-        assert_eq!(backoff.next(), Some(Duration::from_millis(7)));
-    }
-
-    #[test]
-    fn test_minimum_value() {
-        let zero = Duration::from_millis(0);
-        let mut backoff = ExponentialBackoff::new(zero, 10);
-
-        assert_eq!(backoff.next(), Some(zero));
-        assert_eq!(backoff.next(), Some(zero));
-
-        let mut backoff = ExponentialBackoff::new(Duration::from_millis(1), 0);
-
-        assert_eq!(backoff.next(), Some(Duration::from_millis(1)));
-        assert_eq!(backoff.next(), Some(zero));
-    }
-
-    #[test]
-    fn test_rounding() {
-        let second = Duration::from_secs(1);
-        assert_eq!(apply_jitter(second, 1.0), second);
-    }
-
-    proptest! {
-        #[test]
-        fn test_jitter(millis: u64, jitter: u64) {
-            let max_num = 2u64.checked_pow(f64::MANTISSA_DIGITS).unwrap();
-            let jitter = (jitter % max_num) as f64 / (max_num as f64);
-            let unjittered_duration = Duration::from_millis(millis);
-            let jittered_duration = apply_jitter(unjittered_duration, jitter);
-            prop_assert!(jittered_duration <= unjittered_duration);
-        }
-    }
-
-    // NOTE: The test is disabled because the clock does not advance.
-    #[ignore]
-    #[tokio::test]
-    async fn test_exponential_backoff_delay() {
-        let retry_interval_initial = Duration::from_secs(4);
-        let retry_interval_factor = 5;
-        let retry_interval_max = Duration::from_secs(24 * 60 * 60);
-        tokio::time::pause();
-
-        let _ = retry_future(
-            || async { 0 },
-            |_| true,
-            ExponentialBackoff::new(retry_interval_initial, retry_interval_factor)
-                .max_delay(Some(retry_interval_max))
-                .take(5),
-        )
-        .await;
-    }
-}

talpid-core/src/future_retry.rs

@@ -0,0 +1,19 @@
+[package]
+name = "talpid-future"
+description = "Utilities for working with futures"
+authors.workspace = true
+repository.workspace = true
+license.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+
+[lints]
+workspace = true
+
+[dependencies]
+rand = "0.8.5"
+talpid-time = { path = "../talpid-time" }
+
+[dev-dependencies]
+proptest = "1.4"
+tokio = { workspace = true, features = [ "test-util", "macros" ] }

talpid-future/Cargo.toml

@@ -0,0 +1,5 @@
+//! This library provides utility functions and types for working with futures.
+#![deny(missing_docs)]
+
+/// Retry futures
+pub mod retry;