Consolidate errors for context missing

tokio/src/io/driver/mod.rs

@@ -259,8 +259,7 @@ cfg_rt! {
         /// This function panics if there is no current reactor set and `rt` feature
         /// flag is not enabled.
         pub(super) fn current() -> Self {
-            crate::runtime::context::io_handle()
-                .expect("there is no reactor running, must be called from the context of Tokio runtime")
+            crate::runtime::context::io_handle().expect("io not enabled on Tokio context")
         }
     }
 }
@@ -274,7 +273,7 @@ cfg_not_rt! {
         /// This function panics if there is no current reactor set, or if the `rt`
         /// feature flag is not enabled.
         pub(super) fn current() -> Self {
-            panic!("there is no reactor running, must be called from the context of Tokio runtime with `rt` enabled.")
+            panic!(crate::util::error::context_missing_error(&[&"rt"]))
         }
     }
 }

tokio/src/runtime/blocking/pool.rs

@@ -9,6 +9,7 @@ use crate::runtime::builder::ThreadNameFn;
 use crate::runtime::context;
 use crate::runtime::task::{self, JoinHandle};
 use crate::runtime::{Builder, Callback, Handle};
+use crate::util::error::context_missing_error;
 
 use std::collections::{HashMap, VecDeque};
 use std::fmt;
@@ -81,7 +82,7 @@ where
     F: FnOnce() -> R + Send + 'static,
     R: Send + 'static,
 {
-    let rt = context::current().expect("not currently running on the Tokio runtime.");
+    let rt = context::current().unwrap_or_else(|| panic!(context_missing_error(&[])));
     rt.spawn_blocking(func)
 }
 
@@ -91,7 +92,7 @@ where
     F: FnOnce() -> R + Send + 'static,
     R: Send + 'static,
 {
-    let rt = context::current().expect("not currently running on the Tokio runtime.");
+    let rt = context::current().unwrap_or_else(|| panic!(context_missing_error(&[])));
 
     let (task, _handle) = task::joinable(BlockingTask::new(func));
     rt.blocking_spawner.spawn(task, &rt)

tokio/src/runtime/context.rs

@@ -13,28 +13,28 @@ pub(crate) fn current() -> Option<Handle> {
 
 cfg_io_driver! {
     pub(crate) fn io_handle() -> crate::runtime::driver::IoHandle {
-        CONTEXT.with(|ctx| match *ctx.borrow() {
-            Some(ref ctx) => ctx.io_handle.clone(),
-            None => Default::default(),
+        CONTEXT.with(|ctx| {
+            let ctx = ctx.borrow();
+            ctx.as_ref().unwrap_or_else(|| panic!(crate::util::error::context_missing_error(&[]))).io_handle.clone()
         })
     }
 }
 
 cfg_signal_internal! {
     #[cfg(unix)]
     pub(crate) fn signal_handle() -> crate::runtime::driver::SignalHandle {
-        CONTEXT.with(|ctx| match *ctx.borrow() {
-            Some(ref ctx) => ctx.signal_handle.clone(),
-            None => Default::default(),
+        CONTEXT.with(|ctx| {
+            let ctx = ctx.borrow();
+            ctx.as_ref().unwrap_or_else(|| panic!(crate::util::error::context_missing_error(&[]))).signal_handle.clone()
         })
     }
 }
 
 cfg_time! {
     pub(crate) fn time_handle() -> crate::runtime::driver::TimeHandle {
-        CONTEXT.with(|ctx| match *ctx.borrow() {
-            Some(ref ctx) => ctx.time_handle.clone(),
-            None => Default::default(),
+        CONTEXT.with(|ctx| {
+            let ctx = ctx.borrow();
+            ctx.as_ref().unwrap_or_else(|| panic!(crate::util::error::context_missing_error(&[]))).time_handle.clone()
         })
     }
 

tokio/src/runtime/handle.rs

@@ -1,6 +1,7 @@
 use crate::runtime::blocking::task::BlockingTask;
 use crate::runtime::task::{self, JoinHandle};
 use crate::runtime::{blocking, context, driver, Spawner};
+use crate::util::error::context_missing_error;
 
 use std::future::Future;
 use std::{error, fmt};
@@ -97,7 +98,7 @@ impl Handle {
     /// # }
     /// ```
     pub fn current() -> Self {
-        context::current().expect("not currently running on the Tokio runtime.")
+        context::current().unwrap_or_else(|| panic!(context_missing_error(&[])))
     }
 
     /// Returns a Handle view over the currently running Runtime
@@ -213,7 +214,7 @@ impl fmt::Debug for TryCurrentError {
 
 impl fmt::Display for TryCurrentError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str("no tokio Runtime has been initialized")
+        f.write_str(&context_missing_error(&[]))
     }
 }
 

tokio/src/task/spawn.rs

@@ -1,5 +1,6 @@
 use crate::runtime;
 use crate::task::JoinHandle;
+use crate::util::error::context_missing_error;
 
 use std::future::Future;
 
@@ -129,7 +130,7 @@ cfg_rt! {
         T::Output: Send + 'static,
     {
         let spawn_handle = runtime::context::spawn_handle()
-        .expect("must be called from the context of Tokio runtime configured with either `basic_scheduler` or `threaded_scheduler`");
+        .unwrap_or_else(|| panic!(context_missing_error(&[])));
         let task = crate::util::trace::task(task, "task");
         spawn_handle.spawn(task)
     }

tokio/src/time/driver/handle.rs

@@ -47,7 +47,7 @@ cfg_rt! {
         /// panicking.
         pub(crate) fn current() -> Self {
             crate::runtime::context::time_handle()
-                .expect("there is no timer running, must be called from the context of Tokio runtime")
+                .expect("time must be enabled on the Tokio 1.x context")
         }
     }
 }
@@ -71,8 +71,7 @@ cfg_not_rt! {
         /// lazy, and so outside executed inside the runtime successfuly without
         /// panicking.
         pub(crate) fn current() -> Self {
-            panic!("there is no timer running, must be called from the context of Tokio runtime or \
-            `rt` is not enabled")
+            panic!("`rt` must be enabled")
         }
     }
 }

tokio/src/util/error.rs

@@ -0,0 +1,61 @@
+use std::fmt::Write;
+
+/// Returns an error string explaining that the Tokio context hasn't been instantiated.
+pub(crate) fn context_missing_error(features: &[&str]) -> String {
+    // TODO: Include Tokio version
+    let sfx = if !features.is_empty() {
+        let mut sfx = String::from(" with ");
+        for (i, feat) in features.iter().enumerate() {
+            if i == 0 {
+                if features.len() > 1 {
+                    write!(&mut sfx, "either ").expect("failed to write to string");
+                }
+            } else if i == features.len() - 1 {
+                write!(&mut sfx, " or ").expect("failed to write to string");
+            } else {
+                write!(&mut sfx, ", ").expect("failed to write to string");
+            }
+            write!(&mut sfx, "{}", feat).expect("failed to write to string");
+        }
+        write!(&mut sfx, " enabled").expect("failed to write to string");
+        sfx
+    } else {
+        String::new()
+    };
+    format!(
+        "there is no reactor running, must be called from the context of a Tokio 1.x runtime{}",
+        sfx
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_context_missing_error_no_features() {
+        assert_eq!(
+            &context_missing_error(&[]),
+            "there is no reactor running, must be called from the context of a Tokio 1.x runtime"
+        );
+    }
+
+    #[test]
+    fn test_context_missing_error_one_feature() {
+        assert_eq!(&context_missing_error(&["rt"]), 
+                   "there is no reactor running, must be called from the context of a Tokio 1.x runtime with rt enabled");
+    }
+
+    #[test]
+    fn test_context_missing_error_two_features() {
+        assert_eq!(&context_missing_error(&["rt", "signal"]), 
+                "there is no reactor running, must be called from the context of a Tokio 1.x runtime with either rt or signal enabled");
+    }
+
+    #[test]
+    fn test_context_missing_error_three_features() {
+        assert_eq!(&context_missing_error(&["rt", "signal", "sync"]), 
+                   "there is no reactor running, must be called from the context of a Tokio 1.x runtime with either rt, signal or sync enabled"
+                );
+    }
+}

tokio/src/util/mod.rs

@@ -35,3 +35,6 @@ pub(crate) mod trace;
 #[cfg(any(feature = "macros"))]
 #[cfg_attr(not(feature = "macros"), allow(unreachable_pub))]
 pub use rand::thread_rng_n;
+
+#[cfg(any(feature = "rt", feature = "net"))]
+pub(crate) mod error;

tokio/tests/no_rt.rs

@@ -7,8 +7,8 @@ use futures::executor::block_on;
 use std::net::TcpListener;
 
 #[test]
-#[should_panic(expected = "no timer running")]
-fn panics_when_no_timer() {
+#[should_panic(expected = "no reactor running")]
+fn timeout_panics_when_no_tokio_context() {
     block_on(timeout_value());
 }
 

tokio/tests/rt_basic.rs

@@ -6,7 +6,7 @@ use tokio::sync::oneshot;
 use tokio_test::{assert_err, assert_ok};
 
 use std::thread;
-use std::time::Duration;
+use tokio::time::{timeout, Duration};
 
 mod support {
     pub(crate) mod mpsc_stream;
@@ -135,6 +135,19 @@ fn acquire_mutex_in_drop() {
     drop(rt);
 }
 
+#[test]
+#[should_panic(expected = "time must be enabled on the Tokio 1.x context")]
+fn timeout_panics_when_no_time_handle() {
+    let rt = tokio::runtime::Builder::new_current_thread()
+        .build()
+        .unwrap();
+    rt.block_on(async {
+        let (_tx, rx) = oneshot::channel::<()>();
+        let dur = Duration::from_millis(20);
+        let _ = timeout(dur, rx).await;
+    });
+}
+
 fn rt() -> Runtime {
     tokio::runtime::Builder::new_current_thread()
         .enable_all()