Return a concrete type from server::listen (#113)

* Return a concrete type from `server::listen`.
* Change `FutureServiceExt::listen` to return `(SocketAddr, Listen)`, where `Listen` is a struct created by the `service!` macro that `impls Future<Item=(),  Error=()>` and represents server execution.
* Disable `conservative_impl_trait` as it's no longer used.
* Update `FutureServiceExt` doc comment.
* Update `SyncServiceExt` doc comment. Also annotate `server::Handle` with `#[must_use]`.
* `cargo fmt`

examples/concurrency.rs

@@ -167,11 +167,12 @@ fn main() {
         .unwrap_or(4);
 
     let mut reactor = reactor::Core::new().unwrap();
-    let addr = Server::new()
+    let (addr, server) = Server::new()
         .listen("localhost:0".first_socket_addr(),
                 &reactor.handle(),
                 server::Options::default())
         .unwrap();
+    reactor.handle().spawn(server);
     info!("Server listening on {}.", addr);
 
     let clients = (0..num_clients)

examples/pubsub.rs

@@ -3,7 +3,7 @@
 // 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.
 
-#![feature(conservative_impl_trait, plugin)]
+#![feature(plugin)]
 #![plugin(tarpc_plugins)]
 
 extern crate env_logger;
@@ -59,9 +59,11 @@ impl subscriber::FutureService for Subscriber {
 
 impl Subscriber {
     fn listen(id: u32, handle: &reactor::Handle, options: server::Options) -> SocketAddr {
-        Subscriber { id: id }
+        let (addr, server) = Subscriber { id: id }
             .listen("localhost:0".first_socket_addr(), handle, options)
-            .unwrap()
+            .unwrap();
+        handle.spawn(server);
+        addr
     }
 }
 
@@ -118,11 +120,12 @@ impl publisher::FutureService for Publisher {
 fn main() {
     let _ = env_logger::init();
     let mut reactor = reactor::Core::new().unwrap();
-    let publisher_addr = Publisher::new()
+    let (publisher_addr, server) = Publisher::new()
         .listen("localhost:0".first_socket_addr(),
                 &reactor.handle(),
                 server::Options::default())
         .unwrap();
+    reactor.handle().spawn(server);
 
     let subscriber1 = Subscriber::listen(0, &reactor.handle(), server::Options::default());
     let subscriber2 = Subscriber::listen(1, &reactor.handle(), server::Options::default());

examples/readme_errors.rs

@@ -3,7 +3,7 @@
 // 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.
 
-#![feature(conservative_impl_trait, plugin)]
+#![feature(plugin)]
 #![plugin(tarpc_plugins)]
 
 extern crate futures;
@@ -19,7 +19,6 @@ use std::sync::mpsc;
 use std::thread;
 use tarpc::{client, server};
 use tarpc::client::sync::ClientExt;
-use tarpc::util::FirstSocketAddr;
 
 service! {
     rpc hello(name: String) -> String | NoNameGiven;

examples/readme_futures.rs

@@ -3,7 +3,7 @@
 // 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.
 
-#![feature(conservative_impl_trait, plugin)]
+#![feature(plugin)]
 #![plugin(tarpc_plugins)]
 
 extern crate futures;
@@ -34,10 +34,12 @@ impl FutureService for HelloServer {
 
 fn main() {
     let mut reactor = reactor::Core::new().unwrap();
-    let addr = HelloServer.listen("localhost:10000".first_socket_addr(),
+    let (addr, server) = HelloServer.listen("localhost:10000".first_socket_addr(),
                 &reactor.handle(),
                 server::Options::default())
         .unwrap();
+    reactor.handle().spawn(server);
+
     let options = client::Options::default().handle(reactor.handle());
     reactor.run(FutureClient::connect(addr, options)
             .map_err(tarpc::Error::from)

examples/readme_sync.rs

@@ -4,7 +4,7 @@
 // This file may not be copied, modified, or distributed except according to those terms.
 
 // required by `FutureClient` (not used directly in this example)
-#![feature(conservative_impl_trait, plugin)]
+#![feature(plugin)]
 #![plugin(tarpc_plugins)]
 
 extern crate futures;
@@ -16,7 +16,7 @@ use std::sync::mpsc;
 use std::thread;
 use tarpc::{client, server};
 use tarpc::client::sync::ClientExt;
-use tarpc::util::{FirstSocketAddr, Never};
+use tarpc::util::Never;
 
 service! {
     rpc hello(name: String) -> String;

examples/server_calling_server.rs

@@ -3,7 +3,7 @@
 // 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.
 
-#![feature(conservative_impl_trait, plugin)]
+#![feature(plugin)]
 #![plugin(tarpc_plugins)]
 
 extern crate env_logger;
@@ -72,19 +72,21 @@ impl DoubleFutureService for DoubleServer {
 fn main() {
     let _ = env_logger::init();
     let mut reactor = reactor::Core::new().unwrap();
-    let add_addr = AddServer.listen("localhost:0".first_socket_addr(),
+    let (add_addr, server) = AddServer.listen("localhost:0".first_socket_addr(),
                 &reactor.handle(),
                 server::Options::default())
         .unwrap();
+    reactor.handle().spawn(server);
 
     let options = client::Options::default().handle(reactor.handle());
     let add_client = reactor.run(add::FutureClient::connect(add_addr, options)).unwrap();
 
-    let double_addr = DoubleServer::new(add_client)
+    let (double_addr, server) = DoubleServer::new(add_client)
         .listen("localhost:0".first_socket_addr(),
                 &reactor.handle(),
                 server::Options::default())
         .unwrap();
+    reactor.handle().spawn(server);
 
     let double_client =
         reactor.run(double::FutureClient::connect(double_addr, client::Options::default()))

examples/throughput.rs

@@ -3,7 +3,7 @@
 // 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.
 
-#![feature(conservative_impl_trait, plugin)]
+#![feature(plugin)]
 #![plugin(tarpc_plugins)]
 
 #[macro_use]
@@ -56,10 +56,11 @@ const CHUNK_SIZE: u32 = 1 << 19;
 
 fn bench_tarpc(target: u64) {
     let reactor = reactor::Core::new().unwrap();
-    let addr = Server.listen("localhost:0".first_socket_addr(),
+    let (addr, server) = Server.listen("localhost:0".first_socket_addr(),
                 &reactor.handle(),
                 server::Options::default())
         .unwrap();
+    reactor.handle().spawn(server);
     let mut client = SyncClient::connect(addr, client::Options::default()).unwrap();
     let start = time::Instant::now();
     let mut nread = 0;

examples/two_clients.rs

@@ -3,7 +3,7 @@
 // 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.
 
-#![feature(conservative_impl_trait, plugin)]
+#![feature(plugin)]
 #![plugin(tarpc_plugins)]
 
 #[macro_use]
@@ -17,6 +17,8 @@ extern crate tokio_core;
 
 use bar::FutureServiceExt as BarExt;
 use baz::FutureServiceExt as BazExt;
+use std::sync::mpsc;
+use std::thread;
 use tarpc::{client, server};
 use tarpc::client::sync::ClientExt;
 use tarpc::util::{FirstSocketAddr, Never};
@@ -61,23 +63,32 @@ macro_rules! pos {
 fn main() {
     let _ = env_logger::init();
     let mut bar_client = {
-        let reactor = reactor::Core::new().unwrap();
-        let addr = Bar.listen("localhost:0".first_socket_addr(),
-                    &reactor.handle(),
-                    server::Options::default())
-            .unwrap();
-        // TODO: Need to set up each client with its own reactor. Should it be shareable across
-        // multiple clients? e.g. Rc<RefCell<Core>> or something similar?
+        let (tx, rx) = mpsc::channel();
+        thread::spawn(move || {
+            let mut reactor = reactor::Core::new().unwrap();
+            let (addr, server) = Bar.listen("localhost:0".first_socket_addr(),
+                        &reactor.handle(),
+                        server::Options::default())
+                .unwrap();
+            tx.send(addr).unwrap();
+            reactor.run(server).unwrap();
+        });
+        let addr = rx.recv().unwrap();
         bar::SyncClient::connect(addr, client::Options::default()).unwrap()
     };
 
     let mut baz_client = {
-        // Need to set up each client with its own reactor.
-        let reactor = reactor::Core::new().unwrap();
-        let addr = Baz.listen("localhost:0".first_socket_addr(),
-                    &reactor.handle(),
-                    server::Options::default())
-            .unwrap();
+        let (tx, rx) = mpsc::channel();
+        thread::spawn(move || {
+            let mut reactor = reactor::Core::new().unwrap();
+            let (addr, server) = Baz.listen("localhost:0".first_socket_addr(),
+                        &reactor.handle(),
+                        server::Options::default())
+                .unwrap();
+            tx.send(addr).unwrap();
+            reactor.run(server).unwrap();
+        });
+        let addr = rx.recv().unwrap();
         baz::SyncClient::connect(addr, client::Options::default()).unwrap()
     };