Use tokio_threadpool's new panic_handler (#2188)

cli/compiler.rs

@@ -35,7 +35,7 @@ lazy_static! {
  static ref C_RID: Mutex<Option<ResourceId>> = Mutex::new(None);
  // tokio runtime specifically for spawning logic that is dependent on
  // completetion of the compiler worker future
- static ref C_RUNTIME: Mutex<Runtime> = Mutex::new(Runtime::new().unwrap());
+ static ref C_RUNTIME: Mutex<Runtime> = Mutex::new(tokio_util::create_threadpool_runtime());
 }
 
 // This corresponds to JS ModuleMetaData.
@@ -111,8 +111,6 @@ fn lazy_start(parent_state: ThreadSafeState) -> ResourceId {
 
  let mut runtime = C_RUNTIME.lock().unwrap();
  runtime.spawn(lazy(move || {
- tokio_util::abort_on_panic();
-
  worker.then(move |result| -> Result<(), ()> {
  // Close resource so the future created by
  // handle_worker_message_stream exits

cli/tokio_util.rs

@@ -8,25 +8,28 @@ use std::mem;
 use std::net::SocketAddr;
 use tokio;
 use tokio::net::TcpStream;
+use tokio::runtime;
+
+pub fn create_threadpool_runtime() -> tokio::runtime::Runtime {
+ // This code can be simplified once the following PR is landed and
+ // released: https://github.com/tokio-rs/tokio/pull/1055
+ use tokio_threadpool::Builder as ThreadPoolBuilder;
+ let mut threadpool_builder = ThreadPoolBuilder::new();
+ threadpool_builder.panic_handler(|err| std::panic::resume_unwind(err));
+ #[allow(deprecated)]
+ runtime::Builder::new()
+ .threadpool_builder(threadpool_builder)
+ .build()
+ .unwrap()
+}
 
 pub fn run<F>(future: F)
 where
  F: Future<Item = (), Error = ()> + Send + 'static,
 {
- abort_on_panic();
  // tokio::runtime::current_thread::run(future)
- tokio::run(future)
-}
-
-// Tokio swallows panics. In order to actually crash when we panic, we
-// have to set this custom hook.
-// https://github.com/tokio-rs/tokio/issues/495
-// https://github.com/tokio-rs/tokio/issues/209
-pub fn abort_on_panic() {
- std::panic::set_hook(Box::new(|panic_info| {
- eprintln!("{}", panic_info.to_string());
- std::process::abort();
- }));
+ let rt = create_threadpool_runtime();
+ rt.block_on_all(future).unwrap();
 }
 
 pub fn block_on<F, R, E>(future: F) -> Result<R, E>
@@ -48,13 +51,10 @@ pub fn init<F>(f: F)
 where
  F: FnOnce(),
 {
- let rt = tokio::runtime::Runtime::new().unwrap();
+ let rt = create_threadpool_runtime();
  let mut executor = rt.executor();
  let mut enter = tokio_executor::enter().expect("Multiple executors at once");
- tokio_executor::with_default(&mut executor, &mut enter, move |_enter| {
- abort_on_panic();
- f()
- });
+ tokio_executor::with_default(&mut executor, &mut enter, move |_enter| f());
 }
 
 #[derive(Debug)]