Do not use/re-export tokio::time::Instant

ntex-rt/CHANGES.md

@@ -1,5 +1,9 @@
 # Changes
 
+## [0.3.0] - 2021-08-26
+
+* Do not use/re-export tokio::time::Instant
+
 ## [0.2.2] - 2021-04-03
 
 * precise futures crate dependency

ntex-rt/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ntex-rt"
-version = "0.2.2"
+version = "0.3.0"
 authors = ["ntex contributors <team@ntex.rs>"]
 description = "ntex runtime"
 keywords = ["network", "framework", "async", "futures"]
@@ -17,4 +17,5 @@ path = "src/lib.rs"
 
 [dependencies]
 ntex-util = "0.1.0"
+pin-project-lite = "0.2"
 tokio = { version = "1", default-features = false, features = ["rt", "net", "time", "signal", "sync"] }

ntex-rt/src/lib.rs

@@ -6,6 +6,7 @@ mod arbiter;
 mod builder;
 mod runtime;
 mod system;
+pub mod time;
 
 pub use self::arbiter::Arbiter;
 pub use self::builder::{Builder, SystemRunner};
@@ -69,18 +70,6 @@ pub mod net {
     pub use self::unix::*;
 }
 
-/// Utilities for tracking time.
-pub mod time {
-    pub use tokio::time::Instant;
-    pub use tokio::time::{interval, interval_at, Interval};
-    pub use tokio::time::{sleep, sleep_until, Sleep};
-    #[doc(hidden)]
-    pub use tokio::time::{
-        sleep as delay_for, sleep_until as delay_until, Sleep as Delay,
-    };
-    pub use tokio::time::{timeout, Timeout};
-}
-
 /// Task management.
 pub mod task {
     pub use tokio::task::{spawn_blocking, yield_now, JoinError, JoinHandle};

ntex-rt/src/time.rs

@@ -0,0 +1,87 @@
+/// Utilities for tracking time.
+use std::{future::Future, pin::Pin, task, task::Poll, time::Duration, time::Instant};
+use tokio::time;
+
+pub use tokio::time::{interval, Interval};
+pub use tokio::time::{timeout, Timeout};
+
+/// Waits until `deadline` is reached.
+///
+/// No work is performed while awaiting on the sleep future to complete. `Sleep`
+/// operates at millisecond granularity and should not be used for tasks that
+/// require high-resolution timers.
+///
+/// # Cancellation
+///
+/// Canceling a sleep instance is done by dropping the returned future. No additional
+/// cleanup work is required.
+#[inline]
+pub fn sleep_until(deadline: Instant) -> Sleep {
+    Sleep {
+        inner: time::sleep_until(deadline.into()),
+    }
+}
+
+/// Waits until `duration` has elapsed.
+///
+/// Equivalent to `sleep_until(Instant::now() + duration)`. An asynchronous
+/// analog to `std::thread::sleep`.
+pub fn sleep(duration: Duration) -> Sleep {
+    Sleep {
+        inner: time::sleep(duration),
+    }
+}
+
+/// Creates new [`Interval`] that yields with interval of `period` with the
+/// first tick completing at `start`. The default [`MissedTickBehavior`] is
+/// [`Burst`](MissedTickBehavior::Burst), but this can be configured
+/// by calling [`set_missed_tick_behavior`](Interval::set_missed_tick_behavior).
+#[inline]
+pub fn interval_at(start: Instant, period: Duration) -> Interval {
+    time::interval_at(start.into(), period)
+}
+
+pin_project_lite::pin_project! {
+    /// Future returned by [`sleep`](sleep) and [`sleep_until`](sleep_until).
+    #[derive(Debug)]
+    pub struct Sleep {
+        #[pin]
+        inner: time::Sleep,
+    }
+}
+
+impl Sleep {
+    /// Returns the instant at which the future will complete.
+    #[inline]
+    pub fn deadline(&self) -> Instant {
+        self.inner.deadline().into_std()
+    }
+
+    /// Returns `true` if `Sleep` has elapsed.
+    ///
+    /// A `Sleep` instance is elapsed when the requested duration has elapsed.
+    #[inline]
+    pub fn is_elapsed(&self) -> bool {
+        self.inner.is_elapsed()
+    }
+
+    /// Resets the `Sleep` instance to a new deadline.
+    ///
+    /// Calling this function allows changing the instant at which the `Sleep`
+    /// future completes without having to create new associated state.
+    ///
+    /// This function can be called both before and after the future has
+    /// completed.
+    #[inline]
+    pub fn reset(self: Pin<&mut Self>, deadline: Instant) {
+        self.project().inner.reset(deadline.into());
+    }
+}
+
+impl Future for Sleep {
+    type Output = ();
+
+    fn poll(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::Output> {
+        self.project().inner.poll(cx)
+    }
+}