Remove the Send bound from FutureService (#96)

* Make a reactor handle mandatory for server.

This removes the Send bound from FutureService. The Send bound
is still required for SyncService, since clones are sent to
new threads for each request. (This is more fodder for the argument
that there should be a distinct Options struct for each combination of
async/sync and client/server.)

This commit also makes FutureService::listen return an io::Result
rather than a Future; the future was never really necessary and
had the unintended consequence of making SyncService::listen
deadlock when the options specified a handle (because that means
the reactor driving the service lives on the same thread that
SyncService is waiting on).

`SyncClient` is no longer `Clone` because it needs to create
a new `reactor::Core` when cloning. Tokio Clients are `Clone` but
they don't allow moving the cloned client onto a new reactor.

* Change pubsub to use Rc<Refcell<>> instead of Arc<Mutex<>>.

This is possible since services no longer need to be Send.

* Remove some unnecessary unstable features.

There 3 remaining unstable features. The hardest to remove is plugin, because
we rely on compiler plugins to rewrite types from snake case to camel. It's
possible this can be removed before the proc macros rewrite lands if
impl Trait is extended to work with traits.

* Clean up example

* Sync servers now spawn a reactor on a thread. It's decided that
   sync users should not have to know about tokio at all.

* Don't allow specifying a reactor::Core on client options.

* Fail fast in server::listen if local_addr() returns Err.

src/server.rs

@@ -3,7 +3,6 @@
 // Licensed under the MIT License, <LICENSE or http://opensource.org/licenses/MIT>.
 // This file may not be copied, modified, or distributed except according to those terms.
 
-use {REMOTE, Reactor};
 use bincode;
 use errors::WireError;
 use futures::{self, Async, Future, Stream, future};
@@ -35,24 +34,11 @@ enum Acceptor {
 /// Additional options to configure how the server operates.
 #[derive(Default)]
 pub struct Options {
-    reactor: Option<Reactor>,
     #[cfg(feature = "tls")]
     tls_acceptor: Option<TlsAcceptor>,
 }
 
 impl Options {
-    /// Listen using the given reactor handle.
-    pub fn handle(mut self, handle: reactor::Handle) -> Self {
-        self.reactor = Some(Reactor::Handle(handle));
-        self
-    }
-
-    /// Listen using the given reactor remote.
-    pub fn remote(mut self, remote: reactor::Remote) -> Self {
-        self.reactor = Some(Reactor::Remote(remote));
-        self
-    }
-
     /// Set the `TlsAcceptor`
     #[cfg(feature = "tls")]
     pub fn tls(mut self, tls_acceptor: TlsAcceptor) -> Self {
@@ -66,10 +52,14 @@ impl Options {
 pub type Response<T, E> = Result<T, WireError<E>>;
 
 #[doc(hidden)]
-pub fn listen<S, Req, Resp, E>(new_service: S, addr: SocketAddr, options: Options) -> ListenFuture
+pub fn listen<S, Req, Resp, E>(new_service: S,
+                               addr: SocketAddr,
+                               handle: &reactor::Handle,
+                               _options: Options)
+                               -> io::Result<SocketAddr>
     where S: NewService<Request = Result<Req, bincode::Error>,
                         Response = Response<Resp, E>,
-                        Error = io::Error> + Send + 'static,
+                        Error = io::Error> + 'static,
           Req: Deserialize + 'static,
           Resp: Serialize + 'static,
           E: Serialize + 'static
@@ -77,53 +67,30 @@ pub fn listen<S, Req, Resp, E>(new_service: S, addr: SocketAddr, options: Option
     // Similar to the client, since `Options` is not `Send`, we take the `TlsAcceptor` when it is
     // available.
     #[cfg(feature = "tls")]
-    let acceptor = match options.tls_acceptor {
+    let acceptor = match _options.tls_acceptor {
         Some(tls_acceptor) => Acceptor::Tls(tls_acceptor),
         None => Acceptor::Tcp,
     };
     #[cfg(not(feature = "tls"))]
     let acceptor = Acceptor::Tcp;
 
-    match options.reactor {
-        None => {
-            let (tx, rx) = futures::oneshot();
-            REMOTE.spawn(move |handle| {
-                Ok(tx.complete(listen_with(new_service, addr, handle.clone(), acceptor)))
-            });
-            ListenFuture { inner: future::Either::A(rx) }
-        }
-        Some(Reactor::Remote(remote)) => {
-            let (tx, rx) = futures::oneshot();
-            remote.spawn(move |handle| {
-                Ok(tx.complete(listen_with(new_service, addr, handle.clone(), acceptor)))
-            });
-            ListenFuture { inner: future::Either::A(rx) }
-        }
-        Some(Reactor::Handle(handle)) => {
-            ListenFuture {
-                inner: future::Either::B(future::ok(listen_with(new_service,
-                                                                addr,
-                                                                handle,
-                                                                acceptor))),
-            }
-        }
-    }
+    listen_with(new_service, addr, handle, acceptor)
 }
 
 /// Spawns a service that binds to the given address using the given handle.
 fn listen_with<S, Req, Resp, E>(new_service: S,
                                 addr: SocketAddr,
-                                handle: Handle,
+                                handle: &Handle,
                                 _acceptor: Acceptor)
                                 -> io::Result<SocketAddr>
     where S: NewService<Request = Result<Req, bincode::Error>,
                         Response = Response<Resp, E>,
-                        Error = io::Error> + Send + 'static,
+                        Error = io::Error> + 'static,
           Req: Deserialize + 'static,
           Resp: Serialize + 'static,
           E: Serialize + 'static
 {
-    let listener = listener(&addr, &handle)?;
+    let listener = listener(&addr, handle)?;
     let addr = listener.local_addr()?;
 
     let handle2 = handle.clone();
@@ -175,8 +142,7 @@ fn listener(addr: &SocketAddr, handle: &Handle) -> io::Result<TcpListener> {
 /// A future that resolves to a `ServerHandle`.
 #[doc(hidden)]
 pub struct ListenFuture {
-    inner: future::Either<futures::Oneshot<io::Result<SocketAddr>>,
-                          future::FutureResult<io::Result<SocketAddr>, futures::Canceled>>,
+    inner: future::FutureResult<io::Result<SocketAddr>, futures::Canceled>,
 }
 
 impl Future for ListenFuture {