Service registry (#204)

# Changes

## Client is now a trait
And `Channel<Req, Resp>` implements `Client<Req, Resp>`. Previously, `Client<Req, Resp>` was a thin wrapper around `Channel<Req, Resp>`.

This was changed to allow for mapping the request and response types. For example, you can take a `channel: Channel<Req, Resp>` and do:

```rust
channel
    .with_request(|req: Req2| -> Req { ... })
    .map_response(|resp: Resp| -> Resp2 { ... })
```

...which returns a type that implements `Client<Req2, Resp2>`.

### Why would you want to map request and response types?

The main benefit of this is that it enables creating different client types backed by the same channel. For example, you could run multiple clients multiplexing requests over a single `TcpStream`. I have a demo in `tarpc/examples/service_registry.rs` showing how you might do this with a bincode transport. I am considering factoring out the service registry portion of that to an actual library, because it's doing pretty cool stuff. For this PR, though, it'll just be part of the example.

## Client::new is now client::new

This is pretty minor, but necessary because async fns can't currently exist on traits. I changed `Server::new` to match this as well.

## Macro-generated Clients are generic over the backing Client.

This is a natural consequence of the above change. However, it is transparent to the user by keeping `Channel<Req, Resp>` as the default type for the `<C: Client>` type parameter. `new_stub` returns `Client<Channel<Req, Resp>>`, and other clients can be created via the `From` trait.

## example-service/ now has two binaries, one for client and one for server.

This serves as a "realistic" example of how one might set up a service. The other examples all run the client and server in the same binary, which isn't realistic in distributed systems use cases.

## `service!` trait fns take self by value.

Services are already cloned per request, so this just passes on that flexibility to the trait implementers.

# Open Questions

In the service registry example, multiple services are running on a single port, and thus multiple clients are sending requests over a single `TcpStream`. This has implications for throttling: [`max_in_flight_requests_per_connection`](https://github.com/google/tarpc/blob/master/rpc/src/server/mod.rs#L57-L60) will set a maximum for the sum of requests for all clients sharing a single connection. I think this is reasonable behavior, but users may expect this setting to act like `max_in_flight_requests_per_client`.

Fixes #103 #153 #205

bincode-transport/src/compat.rs

@@ -4,9 +4,12 @@ use futures_legacy::{
         self as executor01, Notify as Notify01, NotifyHandle as NotifyHandle01,
         UnsafeNotify as UnsafeNotify01,
     },
-    Async as Async01, AsyncSink as AsyncSink01, Stream as Stream01, Sink as Sink01
+    Async as Async01, AsyncSink as AsyncSink01, Sink as Sink01, Stream as Stream01,
+};
+use std::{
+    pin::Pin,
+    task::{self, LocalWaker, Poll},
 };
-use std::{pin::Pin, task::{self, LocalWaker, Poll}};
 
 /// A shim to convert a 0.1 Sink + Stream to a 0.3 Sink + Stream.
 #[derive(Debug)]
@@ -18,7 +21,10 @@ pub struct Compat<S, SinkItem> {
 impl<S, SinkItem> Compat<S, SinkItem> {
     /// Returns a new Compat.
     pub fn new(inner: S) -> Self {
-        Compat { inner, staged_item: None }
+        Compat {
+            inner,
+            staged_item: None,
+        }
     }
 
     /// Unwraps Compat, returning the inner value.
@@ -34,7 +40,7 @@ impl<S, SinkItem> Compat<S, SinkItem> {
 
 impl<S, SinkItem> Stream for Compat<S, SinkItem>
 where
-    S: Stream01
+    S: Stream01,
 {
     type Item = Result<S::Item, S::Error>;
 
@@ -142,4 +148,3 @@ impl<'a> From<WakerToHandle<'a>> for NotifyHandle01 {
         unsafe { NotifyWaker(handle.0.clone().into_waker()).clone_raw() }
     }
 }
-

bincode-transport/src/lib.rs

@@ -11,16 +11,27 @@
     pin,
     arbitrary_self_types,
     await_macro,
-    async_await,
+    async_await
 )]
 #![deny(missing_docs, missing_debug_implementations)]
 
-use async_bincode::{AsyncBincodeStream, AsyncDestination};
-use futures::{compat::{Compat01As03, Future01CompatExt, Stream01CompatExt}, prelude::*, ready};
-use pin_utils::unsafe_pinned;
-use serde::{Serialize, Deserialize};
 use self::compat::Compat;
-use std::{error::Error, io, marker::PhantomData, net::SocketAddr, pin::Pin, task::{LocalWaker, Poll}};
+use async_bincode::{AsyncBincodeStream, AsyncDestination};
+use futures::{
+    compat::{Compat01As03, Future01CompatExt, Stream01CompatExt},
+    prelude::*,
+    ready,
+};
+use pin_utils::unsafe_pinned;
+use serde::{Deserialize, Serialize};
+use std::{
+    error::Error,
+    io,
+    marker::PhantomData,
+    net::SocketAddr,
+    pin::Pin,
+    task::{LocalWaker, Poll},
+};
 use tokio_io::{AsyncRead, AsyncWrite};
 use tokio_tcp::{TcpListener, TcpStream};
 
@@ -29,7 +40,7 @@ mod compat;
 /// A transport that serializes to, and deserializes from, a [`TcpStream`].
 #[derive(Debug)]
 pub struct Transport<S, Item, SinkItem> {
-    inner: Compat<AsyncBincodeStream<S, Item, SinkItem, AsyncDestination>, SinkItem>
+    inner: Compat<AsyncBincodeStream<S, Item, SinkItem, AsyncDestination>, SinkItem>,
 }
 
 impl<S, Item, SinkItem> Transport<S, Item, SinkItem> {
@@ -40,7 +51,9 @@ impl<S, Item, SinkItem> Transport<S, Item, SinkItem> {
 }
 
 impl<S, Item, SinkItem> Transport<S, Item, SinkItem> {
-    unsafe_pinned!(inner: Compat<AsyncBincodeStream<S, Item, SinkItem, AsyncDestination>, SinkItem>);
+    unsafe_pinned!(
+        inner: Compat<AsyncBincodeStream<S, Item, SinkItem, AsyncDestination>, SinkItem>
+    );
 }
 
 impl<S, Item, SinkItem> Stream for Transport<S, Item, SinkItem>
@@ -55,7 +68,9 @@ where
             Poll::Pending => Poll::Pending,
             Poll::Ready(None) => Poll::Ready(None),
             Poll::Ready(Some(Ok(next))) => Poll::Ready(Some(Ok(next))),
-            Poll::Ready(Some(Err(e))) => Poll::Ready(Some(Err(io::Error::new(io::ErrorKind::Other, e)))),
+            Poll::Ready(Some(Err(e))) => {
+                Poll::Ready(Some(Err(io::Error::new(io::ErrorKind::Other, e))))
+            }
         }
     }
 }
@@ -119,7 +134,6 @@ where
     SinkItem: Serialize,
 {
     Transport::from(io)
-
 }
 
 impl<S, Item, SinkItem> From<S> for Transport<S, Item, SinkItem> {
@@ -131,7 +145,9 @@ impl<S, Item, SinkItem> From<S> for Transport<S, Item, SinkItem> {
 }
 
 /// Connects to `addr`, wrapping the connection in a bincode transport.
-pub async fn connect<Item, SinkItem>(addr: &SocketAddr) -> io::Result<Transport<TcpStream, Item, SinkItem>>
+pub async fn connect<Item, SinkItem>(
+    addr: &SocketAddr,
+) -> io::Result<Transport<TcpStream, Item, SinkItem>>
 where
     Item: for<'de> Deserialize<'de>,
     SinkItem: Serialize,
@@ -184,4 +200,3 @@ where
         Poll::Ready(next.map(|conn| Ok(new(conn))))
     }
 }
-