new_async -> run_in_executor and return future directly + builder cleanup

actix-rt/src/builder.rs

@@ -73,7 +73,7 @@ impl Builder {
     /// Create new System that can run asynchronously.
     ///
     /// This method panics if it cannot start the system arbiter
-    pub fn build_async(self, executor: Handle) -> AsyncSystemRunner {
+    pub(crate) fn build_async(self, executor: Handle) -> AsyncSystemRunner {
         self.create_async_runtime(executor)
     }
 
@@ -87,8 +87,7 @@ impl Builder {
         self.create_runtime(f).run()
     }
 
-    fn create_async_runtime(self, executor: Handle) -> AsyncSystemRunner
+    fn create_async_runtime(self, executor: Handle) -> AsyncSystemRunner {
-    {
         let (stop_tx, stop) = channel();
         let (sys_sender, sys_receiver) = unbounded();
 
@@ -152,7 +151,7 @@ impl Builder {
 }
 
 #[derive(Debug)]
-pub struct AsyncSystemRunner {
+pub(crate) struct AsyncSystemRunner {
     stop: Receiver<i32>,
     system: System,
 }
@@ -160,36 +159,30 @@ pub struct AsyncSystemRunner {
 impl AsyncSystemRunner {
     /// This function will start event loop and returns a future that
     /// resolves once the `System::stop()` function is called.
-    pub fn run_nonblocking(self) -> Box<Future<Item = (), Error = io::Error> + Send + 'static> {
+    pub(crate) fn run_nonblocking(self) -> Box<Future<Item = (), Error = io::Error> + Send + 'static> {
         let AsyncSystemRunner { stop, .. } = self;
 
         // run loop
-        Box::new(future::ok(())
+        Box::new(future::lazy(|| {
-            .and_then(|_| {
+            Arbiter::run_system();
-                Arbiter::run_system();
+            stop.then(|res| match res {
-                future::ok(())
+                Ok(code) => {
-            }).
+                    if code != 0 {
-            and_then(|_| {
+                        Err(io::Error::new(
-                stop.then(|res| {
+                            io::ErrorKind::Other,
-                    match res {
+                            format!("Non-zero exit code: {}", code),
-                        Ok(code) => {
+                        ))
-                            if code != 0 {
+                    } else {
-                                Err(io::Error::new(
+                        Ok(())
-                                    io::ErrorKind::Other,
-                                    format!("Non-zero exit code: {}", code),
-                                ))
-                            } else {
-                                Ok(())
-                            }
-                        }
-                        Err(e) => Err(io::Error::new(io::ErrorKind::Other, e)),
                     }
-                })
+                }
-            }).then(|result| {
+                Err(e) => Err(io::Error::new(io::ErrorKind::Other, e)),
+            })
+            .then(|result| {
                 Arbiter::stop_system();
                 result
             })
-        )
+        }))
     }
 }
 

actix-rt/src/system.rs

@@ -2,11 +2,12 @@ use std::cell::RefCell;
 use std::io;
 use std::sync::atomic::{AtomicUsize, Ordering};
 
-use tokio_current_thread::Handle;
 use futures::sync::mpsc::UnboundedSender;
+use futures::Future;
+use tokio_current_thread::Handle;
 
 use crate::arbiter::{Arbiter, SystemCommand};
-use crate::builder::{Builder, SystemRunner, AsyncSystemRunner};
+use crate::builder::{AsyncSystemRunner, Builder, SystemRunner};
 
 static SYSTEM_COUNT: AtomicUsize = AtomicUsize::new(0);
 
@@ -60,8 +61,14 @@ impl System {
     /// Create new system using provided CurrentThread Handle.
     ///
     /// This method panics if it can not spawn system arbiter
-    pub fn new_async<T: Into<String>>(name: T, executor: Handle) -> AsyncSystemRunner {
+    pub fn run_in_executor<T: Into<String>>(
-        Self::builder().name(name).build_async(executor)
+        name: T,
+        executor: Handle,
+    ) -> Box<Future<Item = (), Error = io::Error> + Send + 'static> {
+        Self::builder()
+            .name(name)
+            .build_async(executor)
+            .run_nonblocking()
     }
 
     /// Get current running system.