[runtime/tokio] Simplify sleep_until (#3464)

Author: patrick-ogrady

runtime/src/lib.rs

@@ -824,7 +824,7 @@ mod tests {
     use commonware_utils::{
         channel::{mpsc, oneshot},
         sync::Mutex,
-        NZUsize,
+        NZUsize, SystemTimeExt,
     };
     use futures::{
         future::{pending, ready},
@@ -889,6 +889,17 @@ mod tests {
         });
     }
 
+    fn test_clock_sleep_until_far_future<R: Runner>(runner: R)
+    where
+        R::Context: Spawner + Clock,
+    {
+        runner.start(|context| async move {
+            let sleep = context.sleep_until(SystemTime::limit());
+            let result = context.timeout(Duration::from_millis(1), sleep).await;
+            assert!(matches!(result, Err(Error::Timeout)));
+        });
+    }
+
     fn test_clock_timeout<R: Runner>(runner: R)
     where
         R::Context: Spawner + Clock,
@@ -3147,6 +3158,12 @@ mod tests {
         test_clock_sleep_until(executor);
     }
 
+    #[test]
+    fn test_deterministic_clock_sleep_until_far_future() {
+        let executor = deterministic::Runner::default();
+        test_clock_sleep_until_far_future(executor);
+    }
+
     #[test]
     fn test_deterministic_clock_timeout() {
         let executor = deterministic::Runner::default();
@@ -3490,6 +3507,12 @@ mod tests {
         test_clock_sleep_until(executor);
     }
 
+    #[test]
+    fn test_tokio_clock_sleep_until_far_future() {
+        let executor = tokio::Runner::default();
+        test_clock_sleep_until_far_future(executor);
+    }
+
     #[test]
     fn test_tokio_clock_timeout() {
         let executor = tokio::Runner::default();

runtime/src/tokio/runtime.rs

@@ -740,13 +740,8 @@ impl Clock for Context {
     }
 
     fn sleep_until(&self, deadline: SystemTime) -> impl Future<Output = ()> + Send + 'static {
-        let now = SystemTime::now();
-        let duration_until_deadline = deadline.duration_since(now).unwrap_or_else(|_| {
-            // Deadline is in the past
-            Duration::from_secs(0)
-        });
-        let target_instant = tokio::time::Instant::now() + duration_until_deadline;
-        tokio::time::sleep_until(target_instant)
+        let duration_until_deadline = deadline.duration_since(self.current()).unwrap_or_default();
+        tokio::time::sleep(duration_until_deadline)
     }
 }