runtime agnostic Instant

Author: shashitnak

src/report_aggregator/mod.rs

@@ -4,13 +4,11 @@ use futures::{
     channel::mpsc::{self, Sender},
     StreamExt,
 };
-#[cfg(feature = "tokio-comp")]
-use tokio::time::Instant;
 
 use crate::{
     packages::uname::Uname,
     proto::report::{Report, ReportHeader, Trace, TracesAndStats},
-    runtime::{spawn, JoinHandle},
+    runtime::{spawn, JoinHandle, abort, Instant},
 };
 
 /// The [ReportAggregator] is the structure which control the background task spawned to aggregate
@@ -145,14 +143,7 @@ impl ReportAggregator {
 
 impl Drop for ReportAggregator {
     fn drop(&mut self) {
-        cfg_if::cfg_if! {
-            if #[cfg(all(feature = "tokio-comp", not(feature = "async-std-comp")))] {
-                self.handle.abort();
-            } else if #[cfg(feature = "async-std-comp")] {
-            } else {
-                compile_error!("tokio-comp or async-std-comp features required");
-            }
-        }
+        abort(&self.handle);
         // TODO: Wait for the proper aborted task
     }
 }

src/runtime.rs

@@ -7,11 +7,38 @@ cfg_if::cfg_if! {
             tokio::spawn(f)
         }
 
+        pub fn abort(handle: &JoinHandle<()>) {
+            handle.abort();
+        }
+
+        pub struct Instant(tokio::time::Instant);
+        impl Instant {
+            pub fn now() -> Instant {
+                Instant(tokio::time::Instant::now())
+            }
+
+            pub fn elapsed(&self) -> std::time::Duration {
+                self.0.elapsed()
+            }
+        }
     } else if #[cfg(feature = "async-std-comp")] {
         pub use async_std::task::JoinHandle;
         pub fn spawn(f: impl Future<Output = ()> + Send + 'static) -> JoinHandle<()> {
             async_std::task::spawn(f)
         }
+
+        pub fn abort(handle: &JoinHandle<()>) {}
+
+        pub struct Instant(std::time::Instant);
+        impl Instant {
+            pub fn now() -> Instant {
+                Instant(std::time::Instant::now())
+            }
+
+            pub fn elapsed(&self) -> std::time::Duration {
+                self.0.elapsed()
+            }
+        }
     } else {
         compile_error!("tokio-comp or async-std-comp features required");
     }