rename Server to ServerBuilder

actix-rt/src/arbiter.rs

@@ -5,7 +5,7 @@
 use std::cell::{Cell, RefCell};
 use std::collections::HashMap;
 use std::sync::atomic::{AtomicUsize, Ordering};
-use std::thread;
+use std::{fmt, thread};
 
 use futures::sync::mpsc::{unbounded, UnboundedReceiver, UnboundedSender};
 use futures::sync::oneshot::{channel, Sender};
@@ -23,9 +23,18 @@ thread_local!(
 
 pub(crate) const COUNT: AtomicUsize = AtomicUsize::new(0);
 
-#[derive(Debug)]
 pub(crate) enum ArbiterCommand {
     Stop,
+    Execute(Box<Future<Item = (), Error = ()> + Send>),
+}
+
+impl fmt::Debug for ArbiterCommand {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            ArbiterCommand::Stop => write!(f, "ArbiterCommand::Stop"),
+            ArbiterCommand::Execute(_) => write!(f, "ArbiterCommand::Execute"),
+        }
+    }
 }
 
 #[derive(Debug, Clone)]
@@ -49,6 +58,14 @@ impl Arbiter {
         arb
     }
 
+    /// Returns current arbiter's address
+    pub fn current() -> Arbiter {
+        ADDR.with(|cell| match *cell.borrow() {
+            Some(ref addr) => addr.clone(),
+            None => panic!("Arbiter is not running"),
+        })
+    }
+
     /// Stop arbiter
     pub fn stop(&self) {
         let _ = self.0.unbounded_send(ArbiterCommand::Stop);
@@ -113,7 +130,7 @@ impl Arbiter {
         RUNNING.with(|cell| cell.set(false));
     }
 
-    /// Executes a future on the current thread.
+    /// Spawn a future on the current thread.
     pub fn spawn<F>(future: F)
     where
         F: Future<Item = (), Error = ()> + 'static,
@@ -135,6 +152,16 @@ impl Arbiter {
     {
         Arbiter::spawn(future::lazy(f))
     }
+
+    /// Send a future on the arbiter's thread and spawn.
+    pub fn send<F>(&self, future: F)
+    where
+        F: Future<Item = (), Error = ()> + Send + 'static,
+    {
+        let _ = self
+            .0
+            .unbounded_send(ArbiterCommand::Execute(Box::new(future)));
+    }
 }
 
 struct ArbiterController {
@@ -158,17 +185,22 @@ impl Future for ArbiterController {
     type Error = ();
 
     fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        match self.rx.poll() {
-            Ok(Async::Ready(None)) | Err(_) => Ok(Async::Ready(())),
-            Ok(Async::Ready(Some(item))) => match item {
-                ArbiterCommand::Stop => {
-                    if let Some(stop) = self.stop.take() {
-                        let _ = stop.send(0);
-                    };
-                    Ok(Async::Ready(()))
-                }
-            },
-            Ok(Async::NotReady) => Ok(Async::NotReady),
+        loop {
+            match self.rx.poll() {
+                Ok(Async::Ready(None)) | Err(_) => return Ok(Async::Ready(())),
+                Ok(Async::Ready(Some(item))) => match item {
+                    ArbiterCommand::Stop => {
+                        if let Some(stop) = self.stop.take() {
+                            let _ = stop.send(0);
+                        };
+                        return Ok(Async::Ready(()));
+                    }
+                    ArbiterCommand::Execute(fut) => {
+                        spawn(fut);
+                    }
+                },
+                Ok(Async::NotReady) => return Ok(Async::NotReady),
+            }
         }
     }
 }

actix-rt/src/lib.rs

@@ -5,8 +5,23 @@ mod builder;
 mod runtime;
 mod system;
 
+pub use self::arbiter::Arbiter;
 pub use self::builder::{Builder, SystemRunner};
 pub use self::runtime::{Handle, Runtime};
 pub use self::system::System;
-// pub use tokio_current_thread::spawn;
-// pub use tokio_current_thread::TaskExecutor;
+
+/// Spawns a future on the current arbiter.
+///
+/// # Panics
+///
+/// This function panics if actix system is not running.
+pub fn spawn<F>(f: F)
+where
+    F: futures::Future<Item = (), Error = ()> + 'static,
+{
+    if !System::is_set() {
+        panic!("System is not running");
+    }
+
+    Arbiter::spawn(f);
+}

actix-rt/src/system.rs

@@ -58,8 +58,7 @@ impl System {
     }
 
     /// Set current running system.
-    #[doc(hidden)]
-    pub(crate) fn _is_set() -> bool {
+    pub(crate) fn is_set() -> bool {
         CURRENT.with(|cell| cell.borrow().is_some())
     }