Prepare for tarpc release v0.20.0

Fixes #289

.github/workflows/main.yml

@@ -0,0 +1,66 @@
+on: [push, pull_request]
+
+name: Continuous integration
+
+jobs:
+  check:
+    name: Check
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v1
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: stable
+          override: true
+      - uses: actions-rs/cargo@v1
+        with:
+          command: check
+          args: --all-features
+
+  test:
+    name: Test Suite
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v1
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: stable
+          override: true
+      - uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --all-features
+
+  fmt:
+    name: Rustfmt
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v1
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: stable
+          override: true
+      - run: rustup component add rustfmt
+      - uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --all -- --check
+
+  clippy:
+    name: Clippy
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v1
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: stable
+          override: true
+      - run: rustup component add clippy
+      - uses: actions-rs/cargo@v1
+        with:
+          command: clippy
+          args: --all-features -- -D warnings

.travis.yml

@@ -1,13 +0,0 @@
-language: rust
-rust:
-    - nightly
-sudo: false
-cache: cargo
-
-os:
-    - osx
-    - linux
-
-script:
-  - cargo test --all-targets --all-features
-  - cargo test --doc --all-features

Cargo.toml

@@ -2,9 +2,6 @@
 
 members = [
     "example-service",
-    "rpc",
-    "trace",
-    "bincode-transport",
     "tarpc",
     "plugins",
 ]

README.md

@@ -1,9 +1,8 @@
-## tarpc: Tim & Adam's RPC lib
-[![Travis-CI Status](https://travis-ci.org/google/tarpc.png?branch=master)](https://travis-ci.org/google/tarpc)
-[![Coverage Status](https://coveralls.io/repos/github/google/tarpc/badge.svg?branch=master)](https://coveralls.io/github/google/tarpc?branch=master)
-[![Software License](https://img.shields.io/badge/license-MIT-brightgreen.svg)](LICENSE)
+[![Build Status](https://github.com/google/tarpc/workflows/Continuous%20integration/badge.svg)](https://github.com/google/tarpc/actions?query=workflow%3A%22Continuous+integration%22)
 [![Latest Version](https://img.shields.io/crates/v/tarpc.svg)](https://crates.io/crates/tarpc)
-[![Join the chat at https://gitter.im/tarpc/Lobby](https://badges.gitter.im/tarpc/Lobby.svg)](https://gitter.im/tarpc/Lobby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[![Chat on Discord](https://img.shields.io/discord/647529123996237854)](https://discordapp.com/channels/647529123996237854)
+
+# tarpc
 
 *Disclaimer*: This is not an official Google product.
 
@@ -13,7 +12,7 @@ writing a server is taken care of for you.
 
 [Documentation](https://docs.rs/crate/tarpc/)
 
-## What is an RPC framework?
+### What is an RPC framework?
 "RPC" stands for "Remote Procedure Call," a function call where the work of
 producing the return value is being done somewhere else. When an rpc function is
 invoked, behind the scenes the function contacts some other process somewhere
@@ -26,34 +25,53 @@ architectures. Two well-known ones are [gRPC](http://www.grpc.io) and
 
 tarpc differentiates itself from other RPC frameworks by defining the schema in code,
 rather than in a separate language such as .proto. This means there's no separate compilation
-process, and no cognitive context switching between different languages. Additionally, it
-works with the community-backed library serde: any serde-serializable type can be used as
-arguments to tarpc fns.
+process, and no context switching between different languages.
 
-## Usage
+Some other features of tarpc:
+- Pluggable transport: any type impling `Stream<Item = Request> + Sink<Response>` can be
+  used as a transport to connect the client and server.
+- `Send` optional: if the transport doesn't require it, neither does tarpc!
+- Cascading cancellation: dropping a request will send a cancellation message to the server.
+  The server will cease any unfinished work on the request, subsequently cancelling any of its
+  own requests, repeating for the entire chain of transitive dependencies.
+- Configurable deadlines and deadline propagation: request deadlines default to 10s if
+  unspecified. The server will automatically cease work when the deadline has passed. Any
+  requests sent by the server that use the request context will propagate the request deadline.
+  For example, if a server is handling a request with a 10s deadline, does 2s of work, then
+  sends a request to another server, that server will see an 8s deadline.
+- Serde serialization: enabling the `serde1` Cargo feature will make service requests and
+  responses `Serialize + Deserialize`. It's entirely optional, though: in-memory transports can
+  be used, as well, so the price of serialization doesn't have to be paid when it's not needed.
+
+### Usage
 Add to your `Cargo.toml` dependencies:
 
 ```toml
-tarpc = "0.14.0"
+tarpc = { version = "0.18.0", features = ["full"] }
 ```
 
-The `service!` macro expands to a collection of items that form an
-rpc service. In the above example, the macro is called within the
-`hello_service` module. This module will contain a `Client` stub and `Service` trait.  There is
-These generated types make it easy and ergonomic to write servers without dealing with serialization
-directly. Simply implement one of the generated traits, and you're off to the
-races!
+The `tarpc::service` attribute expands to a collection of items that form an rpc service.
+These generated types make it easy and ergonomic to write servers with less boilerplate.
+Simply implement the generated service trait, and you're off to the races!
 
-## Example
+### Example
 
-Here's a small service.
+For this example, in addition to tarpc, also add two other dependencies to
+your `Cargo.toml`:
+
+```toml
+futures = "0.3"
+tokio = "0.2"
+```
+
+In the following example, we use an in-process channel for communication between
+client and server. In real code, you will likely communicate over the network.
+For a more real-world example, see [example-service](example-service).
+
+First, let's set up the dependencies and service definition.
 
 ```rust
-#![feature(futures_api, pin, arbitrary_self_types, await_macro, async_await, proc_macro_hygiene)]
-
-
 use futures::{
-    compat::TokioDefaultSpawner,
     future::{self, Ready},
     prelude::*,
 };
@@ -65,17 +83,23 @@ use std::io;
 
 // This is the service definition. It looks a lot like a trait definition.
 // It defines one RPC, hello, which takes one arg, name, and returns a String.
-tarpc::service! {
+#[tarpc::service]
+trait World {
     /// Returns a greeting for name.
-    rpc hello(name: String) -> String;
+    async fn hello(name: String) -> String;
 }
+```
 
-// This is the type that implements the generated Service trait. It is the business logic
+This service definition generates a trait called `World`. Next we need to
+implement it for our Server struct.
+
+```rust
+// This is the type that implements the generated World trait. It is the business logic
 // and is used to start the server.
 #[derive(Clone)]
 struct HelloServer;
 
-impl Service for HelloServer {
+impl World for HelloServer {
     // Each defined rpc generates two items in the trait, a fn that serves the RPC, and
     // an associated type representing the future output by the fn.
 
@@ -85,53 +109,45 @@ impl Service for HelloServer {
         future::ready(format!("Hello, {}!", name))
     }
 }
+```
 
-async fn run() -> io::Result<()> {
-    // bincode_transport is provided by the associated crate bincode-transport. It makes it easy
-    // to start up a serde-powered bincode serialization strategy over TCP.
-    let transport = bincode_transport::listen(&"0.0.0.0:0".parse().unwrap())?;
-    let addr = transport.local_addr();
+Lastly let's write our `main` that will start the server. While this example uses an
+[in-process
+channel](https://docs.rs/tarpc/0.18.0/tarpc/transport/channel/struct.UnboundedChannel.html),
+tarpc also ships bincode and JSON
+tokio-net based TCP transports that are generic over all serializable types.
+
+```rust
+#[tokio::main]
+async fn main() -> io::Result<()> {
+    let (client_transport, server_transport) = tarpc::transport::channel::unbounded();
 
-    // The server is configured with the defaults.
     let server = server::new(server::Config::default())
-        // Server can listen on any type that implements the Transport trait.
-        .incoming(transport)
-        // Close the stream after the client connects
-        .take(1)
-        // serve is generated by the service! macro. It takes as input any type implementing
-        // the generated Service trait.
-        .respond_with(serve(HelloServer));
+        // incoming() takes a stream of transports such as would be returned by
+        // TcpListener::incoming (but a stream instead of an iterator).
+        .incoming(stream::once(future::ready(server_transport)))
+        .respond_with(HelloServer.serve());
 
-    tokio_executor::spawn(server.unit_error().boxed().compat());
+    tokio::spawn(server);
 
-    let transport = await!(bincode_transport::connect(&addr))?;
+    // WorldClient is generated by the macro. It has a constructor `new` that takes a config and
+    // any Transport as input
+    let mut client = WorldClient::new(client::Config::default(), client_transport).spawn()?;
 
-    // new_stub is generated by the service! macro. Like Server, it takes a config and any
-    // Transport as input, and returns a Client, also generated by the macro.
-    // by the service mcro.
-    let mut client = await!(new_stub(client::Config::default(), transport))?;
-
-    // The client has an RPC method for each RPC defined in service!. It takes the same args
-    // as defined, with the addition of a Context, which is always the first arg. The Context
+    // The client has an RPC method for each RPC defined in the annotated trait. It takes the same
+    // args as defined, with the addition of a Context, which is always the first arg. The Context
     // specifies a deadline and trace information which can be helpful in debugging requests.
-    let hello = await!(client.hello(context::current(), "Stim".to_string()))?;
+    let hello = client.hello(context::current(), "Stim".to_string()).await?;
 
     println!("{}", hello);
 
     Ok(())
 }
-
-fn main() {
-    tarpc::init(TokioDefaultSpawner);
-    tokio::run(run()
-            .map_err(|e| eprintln!("Oh no: {}", e))
-            .boxed()
-            .compat(),
-    );
-}
 ```
 
-## Service Documentation
+### Service Documentation
 
 Use `cargo doc` as you normally would to see the documentation created for all
 items expanded by a `service!` invocation.
+
+License: MIT

RELEASES.md

@@ -1,3 +1,13 @@
+## 0.20.0 (2019-12-11)
+
+### Breaking Changes
+
+1. tarpc has updated its tokio dependency to the latest 0.2 version.
+2. The tarpc crates have been unified into just `tarpc`, with new Cargo features to enable
+   functionality.
+   - The bincode-transport and json-transport crates are deprecated and superseded by
+     the `serde_transport` module, which unifies much of the logic present in both crates.
+
 ## 0.13.0 (2018-10-16)
 
 ### Breaking Changes 

bincode-transport/Cargo.toml

@@ -1,40 +0,0 @@
-cargo-features = ["rename-dependency"]
-
-[package]
-name = "tarpc-bincode-transport"
-version = "0.3.0"
-authors = ["Tim Kuehn <tikue@google.com>"]
-edition = '2018'
-license = "MIT"
-documentation = "https://docs.rs/tarpc-bincode-transport"
-homepage = "https://github.com/google/tarpc"
-repository = "https://github.com/google/tarpc"
-keywords = ["rpc", "network", "bincode", "serde", "tarpc"]
-categories = ["asynchronous", "network-programming"]
-readme = "../README.md"
-description = "A bincode-based transport for tarpc services."
-
-[dependencies]
-bincode = { version = "1.0", features = ["i128"] }
-futures_legacy = { version = "0.1", package = "futures" }
-pin-utils = "0.1.0-alpha.3"
-rpc = { package = "tarpc-lib", version = "0.2", path = "../rpc", features = ["serde1"] }
-serde = "1.0"
-tokio-io = "0.1"
-async-bincode = "0.4"
-tokio-tcp = "0.1"
-
-[target.'cfg(not(test))'.dependencies]
-futures-preview = { version = "0.3.0-alpha.9", features = ["compat"] }
-
-[dev-dependencies]
-futures-preview = { version = "0.3.0-alpha.9", features = ["compat", "tokio-compat"] }
-env_logger = "0.5"
-humantime = "1.0"
-log = "0.4"
-rand = "0.5"
-tokio = "0.1"
-tokio-executor = "0.1"
-tokio-reactor = "0.1"
-tokio-serde = "0.2"
-tokio-timer = "0.2"

bincode-transport/rustfmt.toml

@@ -1 +0,0 @@
-edition = "2018"

bincode-transport/src/compat.rs

@@ -1,150 +0,0 @@
-use futures::{compat::Stream01CompatExt, prelude::*, ready};
-use futures_legacy::{
-    executor::{
-        self as executor01, Notify as Notify01, NotifyHandle as NotifyHandle01,
-        UnsafeNotify as UnsafeNotify01,
-    },
-    Async as Async01, AsyncSink as AsyncSink01, Sink as Sink01, Stream as Stream01,
-};
-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)]
-pub struct Compat<S, SinkItem> {
-    staged_item: Option<SinkItem>,
-    inner: S,
-}
-
-impl<S, SinkItem> Compat<S, SinkItem> {
-    /// Returns a new Compat.
-    pub fn new(inner: S) -> Self {
-        Compat {
-            inner,
-            staged_item: None,
-        }
-    }
-
-    /// Unwraps Compat, returning the inner value.
-    pub fn into_inner(self) -> S {
-        self.inner
-    }
-
-    /// Returns a reference to the value wrapped by Compat.
-    pub fn get_ref(&self) -> &S {
-        &self.inner
-    }
-}
-
-impl<S, SinkItem> Stream for Compat<S, SinkItem>
-where
-    S: Stream01,
-{
-    type Item = Result<S::Item, S::Error>;
-
-    fn poll_next(self: Pin<&mut Self>, waker: &LocalWaker) -> Poll<Option<Self::Item>> {
-        unsafe {
-            let inner = &mut Pin::get_mut_unchecked(self).inner;
-            let mut compat = inner.compat();
-            let compat = Pin::new_unchecked(&mut compat);
-            match ready!(compat.poll_next(waker)) {
-                None => Poll::Ready(None),
-                Some(Ok(next)) => Poll::Ready(Some(Ok(next))),
-                Some(Err(e)) => Poll::Ready(Some(Err(e))),
-            }
-        }
-    }
-}
-
-impl<S, SinkItem> Sink for Compat<S, SinkItem>
-where
-    S: Sink01<SinkItem = SinkItem>,
-{
-    type SinkItem = SinkItem;
-    type SinkError = S::SinkError;
-
-    fn start_send(self: Pin<&mut Self>, item: SinkItem) -> Result<(), S::SinkError> {
-        let me = unsafe { Pin::get_mut_unchecked(self) };
-        assert!(me.staged_item.is_none());
-        me.staged_item = Some(item);
-        Ok(())
-    }
-
-    fn poll_ready(self: Pin<&mut Self>, waker: &LocalWaker) -> Poll<Result<(), S::SinkError>> {
-        let notify = &WakerToHandle(waker);
-
-        executor01::with_notify(notify, 0, move || {
-            let me = unsafe { Pin::get_mut_unchecked(self) };
-            match me.staged_item.take() {
-                Some(staged_item) => match me.inner.start_send(staged_item) {
-                    Ok(AsyncSink01::Ready) => Poll::Ready(Ok(())),
-                    Ok(AsyncSink01::NotReady(item)) => {
-                        me.staged_item = Some(item);
-                        Poll::Pending
-                    }
-                    Err(e) => Poll::Ready(Err(e)),
-                },
-                None => Poll::Ready(Ok(())),
-            }
-        })
-    }
-
-    fn poll_flush(self: Pin<&mut Self>, waker: &LocalWaker) -> Poll<Result<(), S::SinkError>> {
-        let notify = &WakerToHandle(waker);
-
-        executor01::with_notify(notify, 0, move || {
-            let me = unsafe { Pin::get_mut_unchecked(self) };
-            match me.inner.poll_complete() {
-                Ok(Async01::Ready(())) => Poll::Ready(Ok(())),
-                Ok(Async01::NotReady) => Poll::Pending,
-                Err(e) => Poll::Ready(Err(e)),
-            }
-        })
-    }
-
-    fn poll_close(self: Pin<&mut Self>, waker: &LocalWaker) -> Poll<Result<(), S::SinkError>> {
-        let notify = &WakerToHandle(waker);
-
-        executor01::with_notify(notify, 0, move || {
-            let me = unsafe { Pin::get_mut_unchecked(self) };
-            match me.inner.close() {
-                Ok(Async01::Ready(())) => Poll::Ready(Ok(())),
-                Ok(Async01::NotReady) => Poll::Pending,
-                Err(e) => Poll::Ready(Err(e)),
-            }
-        })
-    }
-}
-
-#[derive(Clone, Debug)]
-struct WakerToHandle<'a>(&'a LocalWaker);
-
-#[derive(Debug)]
-struct NotifyWaker(task::Waker);
-
-impl Notify01 for NotifyWaker {
-    fn notify(&self, _: usize) {
-        self.0.wake();
-    }
-}
-
-unsafe impl UnsafeNotify01 for NotifyWaker {
-    unsafe fn clone_raw(&self) -> NotifyHandle01 {
-        let ptr = Box::new(NotifyWaker(self.0.clone()));
-
-        NotifyHandle01::new(Box::into_raw(ptr))
-    }
-
-    unsafe fn drop_raw(&self) {
-        let ptr: *const dyn UnsafeNotify01 = self;
-        drop(Box::from_raw(ptr as *mut dyn UnsafeNotify01));
-    }
-}
-
-impl<'a> From<WakerToHandle<'a>> for NotifyHandle01 {
-    fn from(handle: WakerToHandle<'a>) -> NotifyHandle01 {
-        unsafe { NotifyWaker(handle.0.clone().into_waker()).clone_raw() }
-    }
-}

bincode-transport/src/lib.rs

@@ -1,202 +0,0 @@
-// Copyright 2018 Google LLC
-//
-// Use of this source code is governed by an MIT-style
-// license that can be found in the LICENSE file or at
-// https://opensource.org/licenses/MIT.
-
-//! A TCP [`Transport`] that serializes as bincode.
-
-#![feature(
-    futures_api,
-    pin,
-    arbitrary_self_types,
-    await_macro,
-    async_await
-)]
-#![deny(missing_docs, missing_debug_implementations)]
-
-use self::compat::Compat;
-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};
-
-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>,
-}
-
-impl<S, Item, SinkItem> Transport<S, Item, SinkItem> {
-    /// Returns the transport underlying the bincode transport.
-    pub fn into_inner(self) -> S {
-        self.inner.into_inner().into_inner()
-    }
-}
-
-impl<S, Item, SinkItem> Transport<S, Item, SinkItem> {
-    unsafe_pinned!(
-        inner: Compat<AsyncBincodeStream<S, Item, SinkItem, AsyncDestination>, SinkItem>
-    );
-}
-
-impl<S, Item, SinkItem> Stream for Transport<S, Item, SinkItem>
-where
-    S: AsyncRead,
-    Item: for<'a> Deserialize<'a>,
-{
-    type Item = io::Result<Item>;
-
-    fn poll_next(mut self: Pin<&mut Self>, waker: &LocalWaker) -> Poll<Option<io::Result<Item>>> {
-        match self.inner().poll_next(waker) {
-            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))))
-            }
-        }
-    }
-}
-
-impl<S, Item, SinkItem> Sink for Transport<S, Item, SinkItem>
-where
-    S: AsyncWrite,
-    SinkItem: Serialize,
-{
-    type SinkItem = SinkItem;
-    type SinkError = io::Error;
-
-    fn start_send(mut self: Pin<&mut Self>, item: SinkItem) -> io::Result<()> {
-        self.inner()
-            .start_send(item)
-            .map_err(|e| io::Error::new(io::ErrorKind::Other, e))
-    }
-
-    fn poll_ready(mut self: Pin<&mut Self>, waker: &LocalWaker) -> Poll<io::Result<()>> {
-        convert(self.inner().poll_ready(waker))
-    }
-
-    fn poll_flush(mut self: Pin<&mut Self>, waker: &LocalWaker) -> Poll<io::Result<()>> {
-        convert(self.inner().poll_flush(waker))
-    }
-
-    fn poll_close(mut self: Pin<&mut Self>, waker: &LocalWaker) -> Poll<io::Result<()>> {
-        convert(self.inner().poll_close(waker))
-    }
-}
-
-fn convert<E: Into<Box<Error + Send + Sync>>>(poll: Poll<Result<(), E>>) -> Poll<io::Result<()>> {
-    match poll {
-        Poll::Pending => Poll::Pending,
-        Poll::Ready(Ok(())) => Poll::Ready(Ok(())),
-        Poll::Ready(Err(e)) => Poll::Ready(Err(io::Error::new(io::ErrorKind::Other, e))),
-    }
-}
-
-impl<Item, SinkItem> rpc::Transport for Transport<TcpStream, Item, SinkItem>
-where
-    Item: for<'de> Deserialize<'de>,
-    SinkItem: Serialize,
-{
-    type Item = Item;
-    type SinkItem = SinkItem;
-
-    fn peer_addr(&self) -> io::Result<SocketAddr> {
-        self.inner.get_ref().get_ref().peer_addr()
-    }
-
-    fn local_addr(&self) -> io::Result<SocketAddr> {
-        self.inner.get_ref().get_ref().local_addr()
-    }
-}
-
-/// Returns a new bincode transport that reads from and writes to `io`.
-pub fn new<Item, SinkItem>(io: TcpStream) -> Transport<TcpStream, Item, SinkItem>
-where
-    Item: for<'de> Deserialize<'de>,
-    SinkItem: Serialize,
-{
-    Transport::from(io)
-}
-
-impl<S, Item, SinkItem> From<S> for Transport<S, Item, SinkItem> {
-    fn from(inner: S) -> Self {
-        Transport {
-            inner: Compat::new(AsyncBincodeStream::from(inner).for_async()),
-        }
-    }
-}
-
-/// Connects to `addr`, wrapping the connection in a bincode transport.
-pub async fn connect<Item, SinkItem>(
-    addr: &SocketAddr,
-) -> io::Result<Transport<TcpStream, Item, SinkItem>>
-where
-    Item: for<'de> Deserialize<'de>,
-    SinkItem: Serialize,
-{
-    Ok(new(await!(TcpStream::connect(addr).compat())?))
-}
-
-/// Listens on `addr`, wrapping accepted connections in bincode transports.
-pub fn listen<Item, SinkItem>(addr: &SocketAddr) -> io::Result<Incoming<Item, SinkItem>>
-where
-    Item: for<'de> Deserialize<'de>,
-    SinkItem: Serialize,
-{
-    let listener = TcpListener::bind(addr)?;
-    let local_addr = listener.local_addr()?;
-    let incoming = listener.incoming().compat();
-    Ok(Incoming {
-        incoming,
-        local_addr,
-        ghost: PhantomData,
-    })
-}
-
-/// A [`TcpListener`] that wraps connections in bincode transports.
-#[derive(Debug)]
-pub struct Incoming<Item, SinkItem> {
-    incoming: Compat01As03<tokio_tcp::Incoming>,
-    local_addr: SocketAddr,
-    ghost: PhantomData<(Item, SinkItem)>,
-}
-
-impl<Item, SinkItem> Incoming<Item, SinkItem> {
-    unsafe_pinned!(incoming: Compat01As03<tokio_tcp::Incoming>);
-
-    /// Returns the address being listened on.
-    pub fn local_addr(&self) -> SocketAddr {
-        self.local_addr
-    }
-}
-
-impl<Item, SinkItem> Stream for Incoming<Item, SinkItem>
-where
-    Item: for<'a> Deserialize<'a>,
-    SinkItem: Serialize,
-{
-    type Item = io::Result<Transport<TcpStream, Item, SinkItem>>;
-
-    fn poll_next(mut self: Pin<&mut Self>, waker: &LocalWaker) -> Poll<Option<Self::Item>> {
-        let next = ready!(self.incoming().poll_next(waker)?);
-        Poll::Ready(next.map(|conn| Ok(new(conn))))
-    }
-}

bincode-transport/tests/bench.rs

@@ -1,110 +0,0 @@
-// Copyright 2018 Google LLC
-//
-// Use of this source code is governed by an MIT-style
-// license that can be found in the LICENSE file or at
-// https://opensource.org/licenses/MIT.
-
-//! Tests client/server control flow.
-
-#![feature(
-    test,
-    integer_atomics,
-    futures_api,
-    generators,
-    await_macro,
-    async_await
-)]
-
-extern crate test;
-
-use self::test::stats::Stats;
-use futures::{compat::TokioDefaultSpawner, prelude::*};
-use rpc::{
-    client, context,
-    server::{Handler, Server},
-};
-use std::{
-    io,
-    time::{Duration, Instant},
-};
-
-async fn bench() -> io::Result<()> {
-    let listener = tarpc_bincode_transport::listen(&"0.0.0.0:0".parse().unwrap())?;
-    let addr = listener.local_addr();
-
-    tokio_executor::spawn(
-        Server::<u32, u32>::default()
-            .incoming(listener)
-            .take(1)
-            .respond_with(|_ctx, request| futures::future::ready(Ok(request)))
-            .unit_error()
-            .boxed()
-            .compat(),
-    );
-
-    let conn = await!(tarpc_bincode_transport::connect(&addr))?;
-    let client = &mut await!(client::new::<u32, u32, _>(client::Config::default(), conn))?;
-
-    let total = 10_000usize;
-    let mut successful = 0u32;
-    let mut unsuccessful = 0u32;
-    let mut durations = vec![];
-    for _ in 1..=total {
-        let now = Instant::now();
-        let response = await!(client.call(context::current(), 0u32));
-        let elapsed = now.elapsed();
-
-        match response {
-            Ok(_) => successful += 1,
-            Err(_) => unsuccessful += 1,
-        };
-        durations.push(elapsed);
-    }
-
-    let durations_nanos = durations
-        .iter()
-        .map(|duration| duration.as_secs() as f64 * 1E9 + duration.subsec_nanos() as f64)
-        .collect::<Vec<_>>();
-
-    let (lower, median, upper) = durations_nanos.quartiles();
-
-    println!("Of {} runs:", durations_nanos.len());
-    println!("\tSuccessful: {}", successful);
-    println!("\tUnsuccessful: {}", unsuccessful);
-    println!(
-        "\tMean: {:?}",
-        Duration::from_nanos(durations_nanos.mean() as u64)
-    );
-    println!("\tMedian: {:?}", Duration::from_nanos(median as u64));
-    println!(
-        "\tStd Dev: {:?}",
-        Duration::from_nanos(durations_nanos.std_dev() as u64)
-    );
-    println!(
-        "\tMin: {:?}",
-        Duration::from_nanos(durations_nanos.min() as u64)
-    );
-    println!(
-        "\tMax: {:?}",
-        Duration::from_nanos(durations_nanos.max() as u64)
-    );
-    println!(
-        "\tQuartiles: ({:?}, {:?}, {:?})",
-        Duration::from_nanos(lower as u64),
-        Duration::from_nanos(median as u64),
-        Duration::from_nanos(upper as u64)
-    );
-
-    Ok(())
-}
-
-#[test]
-fn bench_small_packet() -> io::Result<()> {
-    env_logger::init();
-    rpc::init(TokioDefaultSpawner);
-
-    tokio::run(bench().map_err(|e| panic!(e.to_string())).boxed().compat());
-    println!("done");
-
-    Ok(())
-}

bincode-transport/tests/cancel.rs

@@ -1,143 +0,0 @@
-// Copyright 2018 Google LLC
-//
-// Use of this source code is governed by an MIT-style
-// license that can be found in the LICENSE file or at
-// https://opensource.org/licenses/MIT.
-
-//! Tests client/server control flow.
-
-#![feature(generators, await_macro, async_await, futures_api)]
-
-use futures::{
-    compat::{Future01CompatExt, TokioDefaultSpawner},
-    prelude::*,
-    stream,
-};
-use log::{info, trace};
-use rand::distributions::{Distribution, Normal};
-use rpc::{client, context, server::Server};
-use std::{
-    io,
-    time::{Duration, Instant, SystemTime},
-};
-use tokio::timer::Delay;
-
-pub trait AsDuration {
-    /// Delay of 0 if self is in the past
-    fn as_duration(&self) -> Duration;
-}
-
-impl AsDuration for SystemTime {
-    fn as_duration(&self) -> Duration {
-        self.duration_since(SystemTime::now()).unwrap_or_default()
-    }
-}
-
-async fn run() -> io::Result<()> {
-    let listener = tarpc_bincode_transport::listen(&"0.0.0.0:0".parse().unwrap())?;
-    let addr = listener.local_addr();
-    let server = Server::<String, String>::default()
-        .incoming(listener)
-        .take(1)
-        .for_each(async move |channel| {
-            let channel = if let Ok(channel) = channel {
-                channel
-            } else {
-                return;
-            };
-            let client_addr = *channel.client_addr();
-            let handler = channel.respond_with(move |ctx, request| {
-                // Sleep for a time sampled from a normal distribution with:
-                // - mean: 1/2 the deadline.
-                // - std dev: 1/2 the deadline.
-                let deadline: Duration = ctx.deadline.as_duration();
-                let deadline_millis = deadline.as_secs() * 1000 + deadline.subsec_millis() as u64;
-                let distribution =
-                    Normal::new(deadline_millis as f64 / 2., deadline_millis as f64 / 2.);
-                let delay_millis = distribution.sample(&mut rand::thread_rng()).max(0.);
-                let delay = Duration::from_millis(delay_millis as u64);
-
-                trace!(
-                    "[{}/{}] Responding to request in {:?}.",
-                    ctx.trace_id(),
-                    client_addr,
-                    delay,
-                );
-
-                let wait = Delay::new(Instant::now() + delay).compat();
-                async move {
-                    await!(wait).unwrap();
-                    Ok(request)
-                }
-            });
-            tokio_executor::spawn(handler.unit_error().boxed().compat());
-        });
-
-    tokio_executor::spawn(server.unit_error().boxed().compat());
-
-    let conn = await!(tarpc_bincode_transport::connect(&addr))?;
-    let client = await!(client::new::<String, String, _>(
-        client::Config::default(),
-        conn
-    ))?;
-
-    // Proxy service
-    let listener = tarpc_bincode_transport::listen(&"0.0.0.0:0".parse().unwrap())?;
-    let addr = listener.local_addr();
-    let proxy_server = Server::<String, String>::default()
-        .incoming(listener)
-        .take(1)
-        .for_each(move |channel| {
-            let client = client.clone();
-            async move {
-                let channel = if let Ok(channel) = channel {
-                    channel
-                } else {
-                    return;
-                };
-                let client_addr = *channel.client_addr();
-                let handler = channel.respond_with(move |ctx, request| {
-                    trace!("[{}/{}] Proxying request.", ctx.trace_id(), client_addr);
-                    let mut client = client.clone();
-                    async move { await!(client.call(ctx, request)) }
-                });
-                tokio_executor::spawn(handler.unit_error().boxed().compat());
-            }
-        });
-
-    tokio_executor::spawn(proxy_server.unit_error().boxed().compat());
-
-    let mut config = client::Config::default();
-    config.max_in_flight_requests = 10;
-    config.pending_request_buffer = 10;
-
-    let client = await!(client::new::<String, String, _>(
-        config,
-        await!(tarpc_bincode_transport::connect(&addr))?
-    ))?;
-
-    // Make 3 speculative requests, returning only the quickest.
-    let mut clients: Vec<_> = (1..=3u32).map(|_| client.clone()).collect();
-    let mut requests = vec![];
-    for client in &mut clients {
-        let mut ctx = context::current();
-        ctx.deadline = SystemTime::now() + Duration::from_millis(200);
-        let trace_id = *ctx.trace_id();
-        let response = client.call(ctx, "ping".into());
-        requests.push(response.map(move |r| (trace_id, r)));
-    }
-    let (fastest_response, _) = await!(stream::futures_unordered(requests).into_future());
-    let (trace_id, resp) = fastest_response.unwrap();
-    info!("[{}] fastest_response = {:?}", trace_id, resp);
-
-    Ok::<_, io::Error>(())
-}
-
-#[test]
-fn cancel_slower() -> io::Result<()> {
-    env_logger::init();
-    rpc::init(TokioDefaultSpawner);
-
-    tokio::run(run().boxed().map_err(|e| panic!(e)).compat());
-    Ok(())
-}

bincode-transport/tests/pushback.rs

@@ -1,119 +0,0 @@
-// Copyright 2018 Google LLC
-//
-// Use of this source code is governed by an MIT-style
-// license that can be found in the LICENSE file or at
-// https://opensource.org/licenses/MIT.
-
-//! Tests client/server control flow.
-
-#![feature(generators, await_macro, async_await, futures_api)]
-
-use futures::{
-    compat::{Future01CompatExt, TokioDefaultSpawner},
-    prelude::*,
-};
-use log::{error, info, trace};
-use rand::distributions::{Distribution, Normal};
-use rpc::{client, context, server::Server};
-use std::{
-    io,
-    time::{Duration, Instant, SystemTime},
-};
-use tokio::timer::Delay;
-
-pub trait AsDuration {
-    /// Delay of 0 if self is in the past
-    fn as_duration(&self) -> Duration;
-}
-
-impl AsDuration for SystemTime {
-    fn as_duration(&self) -> Duration {
-        self.duration_since(SystemTime::now()).unwrap_or_default()
-    }
-}
-
-async fn run() -> io::Result<()> {
-    let listener = tarpc_bincode_transport::listen(&"0.0.0.0:0".parse().unwrap())?;
-    let addr = listener.local_addr();
-    let server = Server::<String, String>::default()
-        .incoming(listener)
-        .take(1)
-        .for_each(async move |channel| {
-            let channel = if let Ok(channel) = channel {
-                channel
-            } else {
-                return;
-            };
-            let client_addr = *channel.client_addr();
-            let handler = channel.respond_with(move |ctx, request| {
-                // Sleep for a time sampled from a normal distribution with:
-                // - mean: 1/2 the deadline.
-                // - std dev: 1/2 the deadline.
-                let deadline: Duration = ctx.deadline.as_duration();
-                let deadline_millis = deadline.as_secs() * 1000 + deadline.subsec_millis() as u64;
-                let distribution =
-                    Normal::new(deadline_millis as f64 / 2., deadline_millis as f64 / 2.);
-                let delay_millis = distribution.sample(&mut rand::thread_rng()).max(0.);
-                let delay = Duration::from_millis(delay_millis as u64);
-
-                trace!(
-                    "[{}/{}] Responding to request in {:?}.",
-                    ctx.trace_id(),
-                    client_addr,
-                    delay,
-                );
-
-                let sleep = Delay::new(Instant::now() + delay).compat();
-                async {
-                    await!(sleep).unwrap();
-                    Ok(request)
-                }
-            });
-            tokio_executor::spawn(handler.unit_error().boxed().compat());
-        });
-
-    tokio_executor::spawn(server.unit_error().boxed().compat());
-
-    let mut config = client::Config::default();
-    config.max_in_flight_requests = 10;
-    config.pending_request_buffer = 10;
-
-    let conn = await!(tarpc_bincode_transport::connect(&addr))?;
-    let client = await!(client::new::<String, String, _>(config, conn))?;
-
-    let clients = (1..=100u32).map(|_| client.clone()).collect::<Vec<_>>();
-    for mut client in clients {
-        let ctx = context::current();
-        tokio_executor::spawn(
-            async move {
-                let trace_id = *ctx.trace_id();
-                let response = client.call(ctx, "ping".into());
-                match await!(response) {
-                    Ok(response) => info!("[{}] response: {}", trace_id, response),
-                    Err(e) => error!("[{}] request error: {:?}: {}", trace_id, e.kind(), e),
-                }
-            }
-                .unit_error()
-                .boxed()
-                .compat(),
-        );
-    }
-
-    Ok(())
-}
-
-#[test]
-fn ping_pong() -> io::Result<()> {
-    env_logger::init();
-    rpc::init(TokioDefaultSpawner);
-
-    tokio::run(
-        run()
-            .map_ok(|_| println!("done"))
-            .map_err(|e| panic!(e.to_string()))
-            .boxed()
-            .compat(),
-    );
-
-    Ok(())
-}

example-service/Cargo.toml

@@ -1,8 +1,6 @@
-cargo-features = ["rename-dependency"]
-
 [package]
 name = "tarpc-example-service"
-version = "0.2.0"
+version = "0.6.0"
 authors = ["Tim Kuehn <tikue@google.com>"]
 edition = "2018"
 license = "MIT"
@@ -15,13 +13,13 @@ readme = "../README.md"
 description = "An example server built on tarpc."
 
 [dependencies]
-bincode-transport = { package = "tarpc-bincode-transport", version = "0.3", path = "../bincode-transport" }
 clap = "2.0"
-futures-preview = { version = "0.3.0-alpha.9", features = ["compat", "tokio-compat"] }
+futures = "0.3"
 serde = { version = "1.0" }
-tarpc = { version = "0.14", path = "../tarpc", features = ["serde1"] }
-tokio = "0.1"
-tokio-executor = "0.1"
+tarpc = { version = "0.20", path = "../tarpc", features = ["full"] }
+tokio = { version = "0.2", features = ["full"] }
+tokio-serde = { version = "0.6", features = ["json"] }
+env_logger = "0.6"
 
 [lib]
 name = "service"

example-service/src/client.rs

@@ -4,38 +4,13 @@
 // license that can be found in the LICENSE file or at
 // https://opensource.org/licenses/MIT.
 
-#![feature(
-    futures_api,
-    pin,
-    arbitrary_self_types,
-    await_macro,
-    async_await
-)]
-
 use clap::{App, Arg};
-use futures::{compat::TokioDefaultSpawner, prelude::*};
 use std::{io, net::SocketAddr};
 use tarpc::{client, context};
+use tokio_serde::formats::Json;
 
-async fn run(server_addr: SocketAddr, name: String) -> io::Result<()> {
-    let transport = await!(bincode_transport::connect(&server_addr))?;
-
-    // new_stub is generated by the service! macro. Like Server, it takes a config and any
-    // Transport as input, and returns a Client, also generated by the macro.
-    // by the service mcro.
-    let mut client = await!(service::new_stub(client::Config::default(), transport))?;
-
-    // The client has an RPC method for each RPC defined in service!. It takes the same args
-    // as defined, with the addition of a Context, which is always the first arg. The Context
-    // specifies a deadline and trace information which can be helpful in debugging requests.
-    let hello = await!(client.hello(context::current(), name))?;
-
-    println!("{}", hello);
-
-    Ok(())
-}
-
-fn main() {
+#[tokio::main]
+async fn main() -> io::Result<()> {
     let flags = App::new("Hello Client")
         .version("0.1")
         .author("Tim <tikue@google.com>")
@@ -59,21 +34,25 @@ fn main() {
         )
         .get_matches();
 
-    tarpc::init(TokioDefaultSpawner);
-
     let server_addr = flags.value_of("server_addr").unwrap();
     let server_addr = server_addr
-        .parse()
+        .parse::<SocketAddr>()
         .unwrap_or_else(|e| panic!(r#"--server_addr value "{}" invalid: {}"#, server_addr, e));
 
-    let name = flags.value_of("name").unwrap();
+    let name = flags.value_of("name").unwrap().into();
 
-    tarpc::init(TokioDefaultSpawner);
+    let transport = tarpc::serde_transport::tcp::connect(server_addr, Json::default()).await?;
 
-    tokio::run(
-        run(server_addr, name.into())
-            .map_err(|e| eprintln!("Oh no: {}", e))
-            .boxed()
-            .compat(),
-    );
+    // WorldClient is generated by the service attribute. It has a constructor `new` that takes a
+    // config and any Transport as input.
+    let mut client = service::WorldClient::new(client::Config::default(), transport).spawn()?;
+
+    // The client has an RPC method for each RPC defined in the annotated trait. It takes the same
+    // args as defined, with the addition of a Context, which is always the first arg. The Context
+    // specifies a deadline and trace information which can be helpful in debugging requests.
+    let hello = client.hello(context::current(), name).await?;
+
+    println!("{}", hello);
+
+    Ok(())
 }

example-service/src/lib.rs

@@ -4,18 +4,10 @@
 // license that can be found in the LICENSE file or at
 // https://opensource.org/licenses/MIT.
 
-#![feature(
-    futures_api,
-    pin,
-    arbitrary_self_types,
-    await_macro,
-    async_await,
-    proc_macro_hygiene
-)]
-
-// This is the service definition. It looks a lot like a trait definition.
-// It defines one RPC, hello, which takes one arg, name, and returns a String.
-tarpc::service! {
+/// This is the service definition. It looks a lot like a trait definition.
+/// It defines one RPC, hello, which takes one arg, name, and returns a String.
+#[tarpc::service]
+pub trait World {
     /// Returns a greeting for name.
-    rpc hello(name: String) -> String;
+    async fn hello(name: String) -> String;
 }

example-service/src/server.rs

@@ -4,61 +4,45 @@
 // license that can be found in the LICENSE file or at
 // https://opensource.org/licenses/MIT.
 
-#![feature(
-    futures_api,
-    pin,
-    arbitrary_self_types,
-    await_macro,
-    async_await
-)]
-
 use clap::{App, Arg};
 use futures::{
-    compat::TokioDefaultSpawner,
     future::{self, Ready},
     prelude::*,
 };
-use std::{io, net::SocketAddr};
+use service::World;
+use std::{
+    io,
+    net::{IpAddr, SocketAddr},
+};
 use tarpc::{
     context,
-    server::{Handler, Server},
+    server::{self, Channel, Handler},
 };
+use tokio_serde::formats::Json;
 
-// This is the type that implements the generated Service trait. It is the business logic
+// This is the type that implements the generated World trait. It is the business logic
 // and is used to start the server.
 #[derive(Clone)]
-struct HelloServer;
+struct HelloServer(SocketAddr);
 
-impl service::Service for HelloServer {
+impl World for HelloServer {
     // Each defined rpc generates two items in the trait, a fn that serves the RPC, and
     // an associated type representing the future output by the fn.
 
     type HelloFut = Ready<String>;
 
     fn hello(self, _: context::Context, name: String) -> Self::HelloFut {
-        future::ready(format!("Hello, {}!", name))
+        future::ready(format!(
+            "Hello, {}! You are connected from {:?}.",
+            name, self.0
+        ))
     }
 }
 
-async fn run(server_addr: SocketAddr) -> io::Result<()> {
-    // bincode_transport is provided by the associated crate bincode-transport. It makes it easy
-    // to start up a serde-powered bincode serialization strategy over TCP.
-    let transport = bincode_transport::listen(&server_addr)?;
+#[tokio::main]
+async fn main() -> io::Result<()> {
+    env_logger::init();
 
-    // The server is configured with the defaults.
-    let server = Server::default()
-        // Server can listen on any type that implements the Transport trait.
-        .incoming(transport)
-        // serve is generated by the service! macro. It takes as input any type implementing
-        // the generated Service trait.
-        .respond_with(service::serve(HelloServer));
-
-    await!(server);
-
-    Ok(())
-}
-
-fn main() {
     let flags = App::new("Hello Server")
         .version("0.1")
         .author("Tim <tikue@google.com>")
@@ -79,12 +63,27 @@ fn main() {
         .parse()
         .unwrap_or_else(|e| panic!(r#"--port value "{}" invalid: {}"#, port, e));
 
-    tarpc::init(TokioDefaultSpawner);
+    let server_addr = (IpAddr::from([0, 0, 0, 0]), port);
 
-    tokio::run(
-        run(([0, 0, 0, 0], port).into())
-            .map_err(|e| eprintln!("Oh no: {}", e))
-            .boxed()
-            .compat(),
-    );
+    // JSON transport is provided by the json_transport tarpc module. It makes it easy
+    // to start up a serde-powered json serialization strategy over TCP.
+    tarpc::serde_transport::tcp::listen(&server_addr, Json::default)
+        .await?
+        // Ignore accept errors.
+        .filter_map(|r| future::ready(r.ok()))
+        .map(server::BaseChannel::with_defaults)
+        // Limit channels to 1 per IP.
+        .max_channels_per_key(1, |t| t.as_ref().peer_addr().unwrap().ip())
+        // serve is generated by the service attribute. It takes as input any type implementing
+        // the generated World trait.
+        .map(|channel| {
+            let server = HelloServer(channel.as_ref().as_ref().peer_addr().unwrap());
+            channel.respond_with(server.serve()).execute()
+        })
+        // Max 10 channels.
+        .buffer_unordered(10)
+        .for_each(|_| async {})
+        .await;
+
+    Ok(())
 }

hooks/pre-commit

@@ -96,7 +96,7 @@ do
         diff="$diff$(cargo fmt -- --skip-children --write-mode=diff $file)"
 	fi
 done
-if grep --quiet "^Diff at line" <<< "$diff"; then
+if grep --quiet "^[-+]" <<< "$diff"; then
     FMTRESULT=1
 fi
 

hooks/pre-push

@@ -91,7 +91,11 @@ if [ "$?" == 0 ]; then
 
     try_run "Building ... " cargo build --color=always
     try_run "Testing ... " cargo test --color=always
-    try_run "Doc Test ... " cargo clean && cargo build --tests && rustdoc --test README.md --edition 2018 -L target/debug/deps -Z unstable-options
+    try_run "Testing with all features enabled ... " cargo test --all-features --color=always
+    for EXAMPLE in $(cargo run --example 2>&1 | grep '    ' | awk '{print $1}')
+    do
+        try_run "Running example \"$EXAMPLE\" ... " cargo run --example $EXAMPLE
+    done
 
 fi
 

plugins/Cargo.toml

@@ -1,7 +1,8 @@
 [package]
 name = "tarpc-plugins"
-version = "0.5.0"
+version = "0.7.0"
 authors = ["Adam Wright <adam.austin.wright@gmail.com>", "Tim Kuehn <timothy.j.kuehn@gmail.com>"]
+edition = "2018"
 license = "MIT"
 documentation = "https://docs.rs/tarpc-plugins"
 homepage = "https://github.com/google/tarpc"
@@ -11,14 +12,21 @@ categories = ["asynchronous", "network-programming"]
 readme = "../README.md"
 description = "Proc macros for tarpc."
 
+[features]
+serde1 = []
+
 [badges]
 travis-ci = { repository = "google/tarpc" }
 
 [dependencies]
-itertools = "0.7"
-syn = { version = "0.15", features = ["full", "extra-traits"] }
-quote = "0.6"
-proc-macro2 = "0.4"
+syn = { version = "1.0.11", features = ["full"] }
+quote = "1.0.2"
+proc-macro2 = "1.0.6"
 
 [lib]
 proc-macro = true
+
+[dev-dependencies]
+futures = "0.3"
+serde = { version = "1.0", features = ["derive"] }
+tarpc = { path = "../tarpc" }

plugins/src/lib.rs

@@ -4,87 +4,600 @@
 // license that can be found in the LICENSE file or at
 // https://opensource.org/licenses/MIT.
 
-extern crate itertools;
+#![recursion_limit = "512"]
+
 extern crate proc_macro;
 extern crate proc_macro2;
 extern crate quote;
 extern crate syn;
 
 use proc_macro::TokenStream;
+use quote::{format_ident, quote};
+use syn::{
+    braced, parenthesized,
+    parse::{Parse, ParseStream},
+    parse_macro_input, parse_quote,
+    punctuated::Punctuated,
+    token::Comma,
+    Attribute, FnArg, Ident, Lit, LitBool, MetaNameValue, Pat, PatType, ReturnType, Token, Type,
+    Visibility,
+};
 
-use itertools::Itertools;
-use proc_macro2::Span;
-use quote::ToTokens;
-use std::str::FromStr;
-use syn::{parse, Ident, TraitItemType, TypePath};
+struct Service {
+    attrs: Vec<Attribute>,
+    vis: Visibility,
+    ident: Ident,
+    rpcs: Vec<RpcMethod>,
+}
 
-#[proc_macro]
-pub fn snake_to_camel(input: TokenStream) -> TokenStream {
-    let i = input.clone();
-    let mut assoc_type = parse::<TraitItemType>(input)
-        .unwrap_or_else(|_| panic!("Could not parse trait item from:\n{}", i));
+struct RpcMethod {
+    attrs: Vec<Attribute>,
+    ident: Ident,
+    args: Vec<PatType>,
+    output: ReturnType,
+}
 
-    let old_ident = convert(&mut assoc_type.ident);
+impl Parse for Service {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        let attrs = input.call(Attribute::parse_outer)?;
+        let vis = input.parse()?;
+        input.parse::<Token![trait]>()?;
+        let ident = input.parse()?;
+        let content;
+        braced!(content in input);
+        let mut rpcs = Vec::<RpcMethod>::new();
+        while !content.is_empty() {
+            rpcs.push(content.parse()?);
+        }
+        for rpc in &rpcs {
+            if rpc.ident == "new" {
+                return Err(input.error(format!(
+                    "method name conflicts with generated fn `{}Client::new`",
+                    ident
+                )));
+            }
+            if rpc.ident == "serve" {
+                return Err(input.error(format!(
+                    "method name conflicts with generated fn `{}::serve`",
+                    ident
+                )));
+            }
+        }
+        Ok(Self {
+            attrs,
+            vis,
+            ident,
+            rpcs,
+        })
+    }
+}
 
-    for mut attr in &mut assoc_type.attrs {
-        if let Some(pair) = attr.path.segments.first() {
-            if pair.value().ident == "doc" {
-                attr.tts = proc_macro2::TokenStream::from_str(
-                    &attr.tts.to_string().replace("{}", &old_ident),
-                )
-                .unwrap();
+impl Parse for RpcMethod {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        let attrs = input.call(Attribute::parse_outer)?;
+        input.parse::<Token![async]>()?;
+        input.parse::<Token![fn]>()?;
+        let ident = input.parse()?;
+        let content;
+        parenthesized!(content in input);
+        let args: Punctuated<FnArg, Comma> = content.parse_terminated(FnArg::parse)?;
+        let args = args
+            .into_iter()
+            .map(|arg| match arg {
+                FnArg::Typed(captured) => match *captured.pat {
+                    Pat::Ident(_) => Ok(captured),
+                    _ => Err(input.error("patterns aren't allowed in RPC args")),
+                },
+                FnArg::Receiver(_) => Err(input.error("method args cannot start with self")),
+            })
+            .collect::<Result<_, _>>()?;
+        let output = input.parse()?;
+        input.parse::<Token![;]>()?;
+
+        Ok(Self {
+            attrs,
+            ident,
+            args,
+            output,
+        })
+    }
+}
+
+// If `derive_serde` meta item is not present, defaults to cfg!(feature = "serde1").
+// `derive_serde` can only be true when serde1 is enabled.
+struct DeriveSerde(bool);
+
+impl Parse for DeriveSerde {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        if input.is_empty() {
+            return Ok(Self(cfg!(feature = "serde1")));
+        }
+        match input.parse::<MetaNameValue>()? {
+            MetaNameValue {
+                ref path, ref lit, ..
+            } if path.segments.len() == 1
+                && path.segments.first().unwrap().ident == "derive_serde" =>
+            {
+                match lit {
+                    Lit::Bool(LitBool { value: true, .. }) if cfg!(feature = "serde1") => {
+                        Ok(Self(true))
+                    }
+                    Lit::Bool(LitBool { value: true, .. }) => {
+                        Err(input
+                            .error("To enable serde, first enable the `serde1` feature of tarpc"))
+                    }
+                    Lit::Bool(LitBool { value: false, .. }) => Ok(Self(false)),
+                    _ => Err(input.error("`derive_serde` expects a value of type `bool`")),
+                }
+            }
+            _ => {
+                Err(input
+                    .error("tarpc::service only supports one meta item, `derive_serde = {bool}`"))
             }
         }
     }
-
-    assoc_type.into_token_stream().into()
 }
 
-#[proc_macro]
-pub fn ty_snake_to_camel(input: TokenStream) -> TokenStream {
-    let mut path = parse::<TypePath>(input).unwrap();
+/// Generates:
+/// - service trait
+/// - serve fn
+/// - client stub struct
+/// - new_stub client factory fn
+/// - Request and Response enums
+/// - ResponseFut Future
+#[proc_macro_attribute]
+pub fn service(attr: TokenStream, input: TokenStream) -> TokenStream {
+    let derive_serde = parse_macro_input!(attr as DeriveSerde);
+    let unit_type: &Type = &parse_quote!(());
+    let Service {
+        ref attrs,
+        ref vis,
+        ref ident,
+        ref rpcs,
+    } = parse_macro_input!(input as Service);
 
-    // Only capitalize the final segment
-    convert(&mut path.path.segments.last_mut().unwrap().into_value().ident);
+    let camel_case_fn_names: &[String] = &rpcs
+        .iter()
+        .map(|rpc| snake_to_camel(&rpc.ident.to_string()))
+        .collect::<Vec<_>>();
+    let args: &[&[PatType]] = &rpcs.iter().map(|rpc| &*rpc.args).collect::<Vec<_>>();
+    let response_fut_name = &format!("{}ResponseFut", ident);
+    let derive_serialize = quote!(#[derive(serde::Serialize, serde::Deserialize)]);
 
-    path.into_token_stream().into()
+    let gen_args = &GenArgs {
+        attrs,
+        vis,
+        rpcs,
+        args,
+        response_fut_name,
+        service_ident: ident,
+        server_ident: &format_ident!("Serve{}", ident),
+        response_fut_ident: &Ident::new(&response_fut_name, ident.span()),
+        client_ident: &format_ident!("{}Client", ident),
+        request_ident: &format_ident!("{}Request", ident),
+        response_ident: &format_ident!("{}Response", ident),
+        method_attrs: &rpcs.iter().map(|rpc| &*rpc.attrs).collect::<Vec<_>>(),
+        method_names: &rpcs.iter().map(|rpc| &rpc.ident).collect::<Vec<_>>(),
+        return_types: &rpcs
+            .iter()
+            .map(|rpc| match rpc.output {
+                ReturnType::Type(_, ref ty) => ty,
+                ReturnType::Default => unit_type,
+            })
+            .collect::<Vec<_>>(),
+        arg_vars: &args
+            .iter()
+            .map(|args| args.iter().map(|arg| &*arg.pat).collect())
+            .collect::<Vec<_>>(),
+        camel_case_idents: &rpcs
+            .iter()
+            .zip(camel_case_fn_names.iter())
+            .map(|(rpc, name)| Ident::new(name, rpc.ident.span()))
+            .collect::<Vec<_>>(),
+        future_idents: &camel_case_fn_names
+            .iter()
+            .map(|name| format_ident!("{}Fut", name))
+            .collect::<Vec<_>>(),
+        derive_serialize: if derive_serde.0 {
+            Some(&derive_serialize)
+        } else {
+            None
+        },
+    };
+
+    let tokens = vec![
+        trait_service(gen_args),
+        struct_server(gen_args),
+        impl_serve_for_server(gen_args),
+        enum_request(gen_args),
+        enum_response(gen_args),
+        enum_response_future(gen_args),
+        impl_debug_for_response_future(gen_args),
+        impl_future_for_response_future(gen_args),
+        struct_client(gen_args),
+        impl_from_for_client(gen_args),
+        impl_client_new(gen_args),
+        impl_client_rpc_methods(gen_args),
+    ];
+
+    tokens
+        .into_iter()
+        .collect::<proc_macro2::TokenStream>()
+        .into()
 }
 
-/// Converts an ident in-place to CamelCase and returns the previous ident.
-fn convert(ident: &mut Ident) -> String {
-    let ident_str = ident.to_string();
-    let mut camel_ty = String::new();
+// Things needed to generate the service items: trait, serve impl, request/response enums, and
+// the client stub.
+struct GenArgs<'a> {
+    attrs: &'a [Attribute],
+    rpcs: &'a [RpcMethod],
+    service_ident: &'a Ident,
+    server_ident: &'a Ident,
+    response_fut_ident: &'a Ident,
+    response_fut_name: &'a str,
+    client_ident: &'a Ident,
+    request_ident: &'a Ident,
+    response_ident: &'a Ident,
+    method_attrs: &'a [&'a [Attribute]],
+    vis: &'a Visibility,
+    method_names: &'a [&'a Ident],
+    args: &'a [&'a [PatType]],
+    return_types: &'a [&'a Type],
+    arg_vars: &'a [Vec<&'a Pat>],
+    camel_case_idents: &'a [Ident],
+    future_idents: &'a [Ident],
+    derive_serialize: Option<&'a proc_macro2::TokenStream>,
+}
 
-    {
-        // Find the first non-underscore and add it capitalized.
-        let mut chars = ident_str.chars();
+fn trait_service(
+    &GenArgs {
+        attrs,
+        rpcs,
+        vis,
+        future_idents,
+        return_types,
+        service_ident,
+        server_ident,
+        ..
+    }: &GenArgs,
+) -> proc_macro2::TokenStream {
+    let types_and_fns = rpcs
+        .iter()
+        .zip(future_idents.iter())
+        .zip(return_types.iter())
+        .map(
+            |(
+                (
+                    RpcMethod {
+                        attrs, ident, args, ..
+                    },
+                    future_type,
+                ),
+                output,
+            )| {
+                let ty_doc = format!("The response future returned by {}.", ident);
+                quote! {
+                    #[doc = #ty_doc]
+                    type #future_type: std::future::Future<Output = #output>;
 
-        // Find the first non-underscore char, uppercase it, and append it.
-        // Guaranteed to succeed because all idents must have at least one non-underscore char.
-        camel_ty.extend(chars.find(|&c| c != '_').unwrap().to_uppercase());
+                    #( #attrs )*
+                    fn #ident(self, context: tarpc::context::Context, #( #args ),*) -> Self::#future_type;
+                }
+            },
+        );
 
-        // When we find an underscore, we remove it and capitalize the next char. To do this,
-        // we need to ensure the next char is not another underscore.
-        let mut chars = chars.coalesce(|c1, c2| {
-            if c1 == '_' && c2 == '_' {
-                Ok(c1)
-            } else {
-                Err((c1, c2))
+    quote! {
+        #( #attrs )*
+        #vis trait #service_ident: Clone {
+            #( #types_and_fns )*
+
+            /// Returns a serving function to use with tarpc::server::Server.
+            fn serve(self) -> #server_ident<Self> {
+                #server_ident { service: self }
             }
-        });
+        }
+    }
+}
 
-        while let Some(c) = chars.next() {
-            if c != '_' {
-                camel_ty.push(c);
-            } else if let Some(c) = chars.next() {
+fn struct_server(
+    &GenArgs {
+        vis, server_ident, ..
+    }: &GenArgs,
+) -> proc_macro2::TokenStream {
+    quote! {
+        #[derive(Clone)]
+        #vis struct #server_ident<S> {
+            service: S,
+        }
+    }
+}
+
+fn impl_serve_for_server(
+    &GenArgs {
+        request_ident,
+        server_ident,
+        service_ident,
+        response_ident,
+        response_fut_ident,
+        camel_case_idents,
+        arg_vars,
+        method_names,
+        ..
+    }: &GenArgs,
+) -> proc_macro2::TokenStream {
+    quote! {
+        impl<S> tarpc::server::Serve<#request_ident> for #server_ident<S>
+            where S: #service_ident
+        {
+            type Resp = #response_ident;
+            type Fut = #response_fut_ident<S>;
+
+            fn serve(self, ctx: tarpc::context::Context, req: #request_ident) -> Self::Fut {
+                match req {
+                    #(
+                        #request_ident::#camel_case_idents{ #( #arg_vars ),* } => {
+                            #response_fut_ident::#camel_case_idents(
+                                #service_ident::#method_names(
+                                    self.service, ctx, #( #arg_vars ),*))
+                        }
+                    )*
+                }
+            }
+        }
+    }
+}
+
+fn enum_request(
+    &GenArgs {
+        derive_serialize,
+        vis,
+        request_ident,
+        camel_case_idents,
+        args,
+        ..
+    }: &GenArgs,
+) -> proc_macro2::TokenStream {
+    quote! {
+        /// The request sent over the wire from the client to the server.
+        #[derive(Debug)]
+        #derive_serialize
+        #vis enum #request_ident {
+            #( #camel_case_idents{ #( #args ),* } ),*
+        }
+    }
+}
+
+fn enum_response(
+    &GenArgs {
+        derive_serialize,
+        vis,
+        response_ident,
+        camel_case_idents,
+        return_types,
+        ..
+    }: &GenArgs,
+) -> proc_macro2::TokenStream {
+    quote! {
+        /// The response sent over the wire from the server to the client.
+        #[derive(Debug)]
+        #derive_serialize
+        #vis enum #response_ident {
+            #( #camel_case_idents(#return_types) ),*
+        }
+    }
+}
+
+fn enum_response_future(
+    &GenArgs {
+        vis,
+        service_ident,
+        response_fut_ident,
+        camel_case_idents,
+        future_idents,
+        ..
+    }: &GenArgs,
+) -> proc_macro2::TokenStream {
+    quote! {
+        /// A future resolving to a server response.
+        #vis enum #response_fut_ident<S: #service_ident> {
+            #( #camel_case_idents(<S as #service_ident>::#future_idents) ),*
+        }
+    }
+}
+
+fn impl_debug_for_response_future(
+    &GenArgs {
+        service_ident,
+        response_fut_ident,
+        response_fut_name,
+        ..
+    }: &GenArgs,
+) -> proc_macro2::TokenStream {
+    quote! {
+        impl<S: #service_ident> std::fmt::Debug for #response_fut_ident<S> {
+            fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
+                fmt.debug_struct(#response_fut_name).finish()
+            }
+        }
+    }
+}
+
+fn impl_future_for_response_future(
+    &GenArgs {
+        service_ident,
+        response_fut_ident,
+        response_ident,
+        camel_case_idents,
+        ..
+    }: &GenArgs,
+) -> proc_macro2::TokenStream {
+    quote! {
+        impl<S: #service_ident> std::future::Future for #response_fut_ident<S> {
+            type Output = #response_ident;
+
+            fn poll(self: std::pin::Pin<&mut Self>, cx: &mut std::task::Context<'_>)
+                -> std::task::Poll<#response_ident>
+            {
+                unsafe {
+                    match std::pin::Pin::get_unchecked_mut(self) {
+                        #(
+                            #response_fut_ident::#camel_case_idents(resp) =>
+                                std::pin::Pin::new_unchecked(resp)
+                                    .poll(cx)
+                                    .map(#response_ident::#camel_case_idents),
+                        )*
+                    }
+                }
+            }
+        }
+    }
+}
+
+fn struct_client(
+    &GenArgs {
+        vis,
+        client_ident,
+        request_ident,
+        response_ident,
+        ..
+    }: &GenArgs,
+) -> proc_macro2::TokenStream {
+    quote! {
+        #[allow(unused)]
+        #[derive(Clone, Debug)]
+        /// The client stub that makes RPC calls to the server. Exposes a Future interface.
+        #vis struct #client_ident<C = tarpc::client::Channel<#request_ident, #response_ident>>(C);
+    }
+}
+
+fn impl_from_for_client(
+    &GenArgs {
+        client_ident,
+        request_ident,
+        response_ident,
+        ..
+    }: &GenArgs,
+) -> proc_macro2::TokenStream {
+    quote! {
+        impl<C> From<C> for #client_ident<C>
+            where for <'a> C: tarpc::Client<'a, #request_ident, Response = #response_ident>
+        {
+            fn from(client: C) -> Self {
+                #client_ident(client)
+            }
+        }
+    }
+}
+
+fn impl_client_new(
+    &GenArgs {
+        client_ident,
+        vis,
+        request_ident,
+        response_ident,
+        ..
+    }: &GenArgs,
+) -> proc_macro2::TokenStream {
+    quote! {
+        impl #client_ident {
+            /// Returns a new client stub that sends requests over the given transport.
+            #vis fn new<T>(config: tarpc::client::Config, transport: T)
+                -> tarpc::client::NewClient<
+                    Self,
+                    tarpc::client::channel::RequestDispatch<#request_ident, #response_ident, T>>
+            where
+                T: tarpc::Transport<tarpc::ClientMessage<#request_ident>, tarpc::Response<#response_ident>>
+            {
+                let new_client = tarpc::client::new(config, transport);
+                tarpc::client::NewClient {
+                    client: #client_ident(new_client.client),
+                    dispatch: new_client.dispatch,
+                }
+            }
+
+        }
+    }
+}
+
+fn impl_client_rpc_methods(
+    &GenArgs {
+        client_ident,
+        request_ident,
+        response_ident,
+        method_attrs,
+        vis,
+        method_names,
+        args,
+        return_types,
+        arg_vars,
+        camel_case_idents,
+        ..
+    }: &GenArgs,
+) -> proc_macro2::TokenStream {
+    quote! {
+        impl<C> #client_ident<C>
+            where for<'a> C: tarpc::Client<'a, #request_ident, Response = #response_ident>
+        {
+            #(
+                #[allow(unused)]
+                #( #method_attrs )*
+                #vis fn #method_names(&mut self, ctx: tarpc::context::Context, #( #args ),*)
+                    -> impl std::future::Future<Output = std::io::Result<#return_types>> + '_ {
+                    let request = #request_ident::#camel_case_idents { #( #arg_vars ),* };
+                    let resp = tarpc::Client::call(&mut self.0, ctx, request);
+                    async move {
+                        match resp.await? {
+                            #response_ident::#camel_case_idents(msg) => std::result::Result::Ok(msg),
+                            _ => unreachable!(),
+                        }
+                    }
+                }
+            )*
+        }
+    }
+}
+
+fn snake_to_camel(ident_str: &str) -> String {
+    let chars = ident_str.chars();
+    let mut camel_ty = String::with_capacity(ident_str.len());
+
+    let mut last_char_was_underscore = true;
+    for c in chars {
+        match c {
+            '_' => last_char_was_underscore = true,
+            c if last_char_was_underscore => {
                 camel_ty.extend(c.to_uppercase());
+                last_char_was_underscore = false;
             }
+            c => camel_ty.extend(c.to_lowercase()),
         }
     }
 
-    // The Fut suffix is hardcoded right now; this macro isn't really meant to be general-purpose.
-    camel_ty.push_str("Fut");
-
-    *ident = Ident::new(&camel_ty, Span::call_site());
-    ident_str
+    camel_ty.shrink_to_fit();
+    camel_ty
+}
+
+#[test]
+fn snake_to_camel_basic() {
+    assert_eq!(snake_to_camel("abc_def"), "AbcDef");
+}
+
+#[test]
+fn snake_to_camel_underscore_suffix() {
+    assert_eq!(snake_to_camel("abc_def_"), "AbcDef");
+}
+
+#[test]
+fn snake_to_camel_underscore_prefix() {
+    assert_eq!(snake_to_camel("_abc_def"), "AbcDef");
+}
+
+#[test]
+fn snake_to_camel_underscore_consecutive() {
+    assert_eq!(snake_to_camel("abc__def"), "AbcDef");
+}
+
+#[test]
+fn snake_to_camel_capital_in_middle() {
+    assert_eq!(snake_to_camel("aBc_dEf"), "AbcDef");
 }

plugins/tests/service.rs

@@ -0,0 +1,53 @@
+use tarpc::context;
+
+#[test]
+fn att_service_trait() {
+    use futures::future::{ready, Ready};
+
+    #[tarpc::service]
+    trait Foo {
+        async fn two_part(s: String, i: i32) -> (String, i32);
+        async fn bar(s: String) -> String;
+        async fn baz();
+    }
+
+    impl Foo for () {
+        type TwoPartFut = Ready<(String, i32)>;
+        fn two_part(self, _: context::Context, s: String, i: i32) -> Self::TwoPartFut {
+            ready((s, i))
+        }
+
+        type BarFut = Ready<String>;
+        fn bar(self, _: context::Context, s: String) -> Self::BarFut {
+            ready(s)
+        }
+
+        type BazFut = Ready<()>;
+        fn baz(self, _: context::Context) -> Self::BazFut {
+            ready(())
+        }
+    }
+}
+
+#[test]
+fn syntax() {
+    #[tarpc::service]
+    trait Syntax {
+        #[deny(warnings)]
+        #[allow(non_snake_case)]
+        async fn TestCamelCaseDoesntConflict();
+        async fn hello() -> String;
+        #[doc = "attr"]
+        async fn attr(s: String) -> String;
+        async fn no_args_no_return();
+        async fn no_args() -> ();
+        async fn one_arg(one: String) -> i32;
+        async fn two_args_no_return(one: String, two: u64);
+        async fn two_args(one: String, two: u64) -> String;
+        async fn no_args_ret_error() -> i32;
+        async fn one_arg_ret_error(one: String) -> String;
+        async fn no_arg_implicit_return_error();
+        #[doc = "attr"]
+        async fn one_arg_implicit_return_error(one: String);
+    }
+}

rpc/Cargo.toml

@@ -1,38 +0,0 @@
-cargo-features = ["rename-dependency"]
-
-[package]
-name = "tarpc-lib"
-version = "0.2.0"
-authors = ["Tim Kuehn <tikue@google.com>"]
-edition = '2018'
-license = "MIT"
-documentation = "https://docs.rs/tarpc-lib"
-homepage = "https://github.com/google/tarpc"
-repository = "https://github.com/google/tarpc"
-keywords = ["rpc", "network", "server", "api", "microservices"]
-categories = ["asynchronous", "network-programming"]
-readme = "../README.md"
-description = "An RPC framework for Rust with a focus on ease of use."
-
-[features]
-default = []
-serde1 = ["trace/serde", "serde", "serde/derive"]
-
-[dependencies]
-fnv = "1.0"
-humantime = "1.0"
-log = "0.4"
-pin-utils = "0.1.0-alpha.3"
-rand = "0.5"
-tokio-timer = "0.2"
-trace = { package = "tarpc-trace", version = "0.1", path = "../trace" }
-serde = { optional = true, version = "1.0" }
-
-[target.'cfg(not(test))'.dependencies]
-futures-preview = { version = "0.3.0-alpha.9", features = ["compat"] }
-
-[dev-dependencies]
-futures-preview = { version = "0.3.0-alpha.9", features = ["compat", "tokio-compat"] }
-futures-test-preview = { version = "0.3.0-alpha.9" }
-env_logger = "0.5"
-tokio = "0.1"

rpc/rustfmt.toml

@@ -1 +0,0 @@
-edition = "2018"

rpc/src/server/filter.rs

@@ -1,260 +0,0 @@
-// Copyright 2018 Google LLC
-//
-// Use of this source code is governed by an MIT-style
-// license that can be found in the LICENSE file or at
-// https://opensource.org/licenses/MIT.
-
-use crate::{
-    server::{Channel, Config},
-    util::Compact,
-    ClientMessage, Response, Transport,
-};
-use fnv::FnvHashMap;
-use futures::{
-    channel::mpsc,
-    prelude::*,
-    ready,
-    stream::Fuse,
-    task::{LocalWaker, Poll},
-};
-use log::{debug, error, info, trace, warn};
-use pin_utils::unsafe_pinned;
-use std::{
-    collections::hash_map::Entry,
-    io,
-    marker::PhantomData,
-    net::{IpAddr, SocketAddr},
-    ops::Try,
-    option::NoneError,
-    pin::Pin,
-};
-
-/// Drops connections under configurable conditions:
-///
-/// 1. If the max number of connections is reached.
-/// 2. If the max number of connections for a single IP is reached.
-#[derive(Debug)]
-pub struct ConnectionFilter<S, Req, Resp> {
-    listener: Fuse<S>,
-    closed_connections: mpsc::UnboundedSender<SocketAddr>,
-    closed_connections_rx: mpsc::UnboundedReceiver<SocketAddr>,
-    config: Config,
-    connections_per_ip: FnvHashMap<IpAddr, usize>,
-    open_connections: usize,
-    ghost: PhantomData<(Req, Resp)>,
-}
-
-enum NewConnection<Req, Resp, C> {
-    Filtered,
-    Accepted(Channel<Req, Resp, C>),
-}
-
-impl<Req, Resp, C> Try for NewConnection<Req, Resp, C> {
-    type Ok = Channel<Req, Resp, C>;
-    type Error = NoneError;
-
-    fn into_result(self) -> Result<Channel<Req, Resp, C>, NoneError> {
-        match self {
-            NewConnection::Filtered => Err(NoneError),
-            NewConnection::Accepted(channel) => Ok(channel),
-        }
-    }
-
-    fn from_error(_: NoneError) -> Self {
-        NewConnection::Filtered
-    }
-
-    fn from_ok(channel: Channel<Req, Resp, C>) -> Self {
-        NewConnection::Accepted(channel)
-    }
-}
-
-impl<S, Req, Resp> ConnectionFilter<S, Req, Resp> {
-    unsafe_pinned!(open_connections: usize);
-    unsafe_pinned!(config: Config);
-    unsafe_pinned!(connections_per_ip: FnvHashMap<IpAddr, usize>);
-    unsafe_pinned!(closed_connections_rx: mpsc::UnboundedReceiver<SocketAddr>);
-    unsafe_pinned!(listener: Fuse<S>);
-
-    /// Sheds new connections to stay under configured limits.
-    pub fn filter<C>(listener: S, config: Config) -> Self
-    where
-        S: Stream<Item = Result<C, io::Error>>,
-        C: Transport<Item = ClientMessage<Req>, SinkItem = Response<Resp>> + Send,
-    {
-        let (closed_connections, closed_connections_rx) = mpsc::unbounded();
-
-        ConnectionFilter {
-            listener: listener.fuse(),
-            closed_connections,
-            closed_connections_rx,
-            config,
-            connections_per_ip: FnvHashMap::default(),
-            open_connections: 0,
-            ghost: PhantomData,
-        }
-    }
-
-    fn handle_new_connection<C>(self: &mut Pin<&mut Self>, stream: C) -> NewConnection<Req, Resp, C>
-    where
-        C: Transport<Item = ClientMessage<Req>, SinkItem = Response<Resp>> + Send,
-    {
-        let peer = match stream.peer_addr() {
-            Ok(peer) => peer,
-            Err(e) => {
-                warn!("Could not get peer_addr of new connection: {}", e);
-                return NewConnection::Filtered;
-            }
-        };
-
-        let open_connections = *self.open_connections();
-        if open_connections >= self.config().max_connections {
-            warn!(
-                "[{}] Shedding connection because the maximum open connections \
-                 limit is reached ({}/{}).",
-                peer,
-                open_connections,
-                self.config().max_connections
-            );
-            return NewConnection::Filtered;
-        }
-
-        let config = self.config.clone();
-        let open_connections_for_ip = self.increment_connections_for_ip(&peer)?;
-        *self.open_connections() += 1;
-
-        debug!(
-            "[{}] Opening channel ({}/{} connections for IP, {} total).",
-            peer,
-            open_connections_for_ip,
-            config.max_connections_per_ip,
-            self.open_connections(),
-        );
-
-        NewConnection::Accepted(Channel {
-            client_addr: peer,
-            closed_connections: self.closed_connections.clone(),
-            transport: stream.fuse(),
-            config,
-            ghost: PhantomData,
-        })
-    }
-
-    fn handle_closed_connection(self: &mut Pin<&mut Self>, addr: &SocketAddr) {
-        *self.open_connections() -= 1;
-        debug!(
-            "[{}] Closing channel. {} open connections remaining.",
-            addr, self.open_connections
-        );
-        self.decrement_connections_for_ip(&addr);
-        self.connections_per_ip().compact(0.1);
-    }
-
-    fn increment_connections_for_ip(self: &mut Pin<&mut Self>, peer: &SocketAddr) -> Option<usize> {
-        let max_connections_per_ip = self.config().max_connections_per_ip;
-        let mut occupied;
-        let mut connections_per_ip = self.connections_per_ip();
-        let occupied = match connections_per_ip.entry(peer.ip()) {
-            Entry::Vacant(vacant) => vacant.insert(0),
-            Entry::Occupied(o) => {
-                if *o.get() < max_connections_per_ip {
-                    // Store the reference outside the block to extend the lifetime.
-                    occupied = o;
-                    occupied.get_mut()
-                } else {
-                    info!(
-                        "[{}] Opened max connections from IP ({}/{}).",
-                        peer,
-                        o.get(),
-                        max_connections_per_ip
-                    );
-                    return None;
-                }
-            }
-        };
-        *occupied += 1;
-        Some(*occupied)
-    }
-
-    fn decrement_connections_for_ip(self: &mut Pin<&mut Self>, addr: &SocketAddr) {
-        let should_compact = match self.connections_per_ip().entry(addr.ip()) {
-            Entry::Vacant(_) => {
-                error!("[{}] Got vacant entry when closing connection.", addr);
-                return;
-            }
-            Entry::Occupied(mut occupied) => {
-                *occupied.get_mut() -= 1;
-                if *occupied.get() == 0 {
-                    occupied.remove();
-                    true
-                } else {
-                    false
-                }
-            }
-        };
-        if should_compact {
-            self.connections_per_ip().compact(0.1);
-        }
-    }
-
-    fn poll_listener<C>(
-        self: &mut Pin<&mut Self>,
-        cx: &LocalWaker,
-    ) -> Poll<Option<io::Result<NewConnection<Req, Resp, C>>>>
-    where
-        S: Stream<Item = Result<C, io::Error>>,
-        C: Transport<Item = ClientMessage<Req>, SinkItem = Response<Resp>> + Send,
-    {
-        match ready!(self.listener().poll_next_unpin(cx)?) {
-            Some(codec) => Poll::Ready(Some(Ok(self.handle_new_connection(codec)))),
-            None => Poll::Ready(None),
-        }
-    }
-
-    fn poll_closed_connections(self: &mut Pin<&mut Self>, cx: &LocalWaker) -> Poll<io::Result<()>> {
-        match ready!(self.closed_connections_rx().poll_next_unpin(cx)) {
-            Some(addr) => {
-                self.handle_closed_connection(&addr);
-                Poll::Ready(Ok(()))
-            }
-            None => unreachable!("Holding a copy of closed_connections and didn't close it."),
-        }
-    }
-}
-
-impl<S, Req, Resp, T> Stream for ConnectionFilter<S, Req, Resp>
-where
-    S: Stream<Item = Result<T, io::Error>>,
-    T: Transport<Item = ClientMessage<Req>, SinkItem = Response<Resp>> + Send,
-{
-    type Item = io::Result<Channel<Req, Resp, T>>;
-
-    fn poll_next(
-        mut self: Pin<&mut Self>,
-        cx: &LocalWaker,
-    ) -> Poll<Option<io::Result<Channel<Req, Resp, T>>>> {
-        loop {
-            match (self.poll_listener(cx)?, self.poll_closed_connections(cx)?) {
-                (Poll::Ready(Some(NewConnection::Accepted(channel))), _) => {
-                    return Poll::Ready(Some(Ok(channel)))
-                }
-                (Poll::Ready(Some(NewConnection::Filtered)), _) | (_, Poll::Ready(())) => {
-                    trace!("Filtered a connection; {} open.", self.open_connections());
-                    continue;
-                }
-                (Poll::Pending, Poll::Pending) => return Poll::Pending,
-                (Poll::Ready(None), Poll::Pending) => {
-                    if *self.open_connections() > 0 {
-                        trace!(
-                            "Listener closed; {} open connections.",
-                            self.open_connections()
-                        );
-                        return Poll::Pending;
-                    }
-                    trace!("Shutting down listener: all connections closed, and no more coming.");
-                    return Poll::Ready(None);
-                }
-            }
-        }
-    }
-}

rpc/src/server/mod.rs

@@ -1,609 +0,0 @@
-// Copyright 2018 Google LLC
-//
-// Use of this source code is governed by an MIT-style
-// license that can be found in the LICENSE file or at
-// https://opensource.org/licenses/MIT.
-
-//! Provides a server that concurrently handles many connections sending multiplexed requests.
-
-use crate::{
-    context::Context, util::deadline_compat, util::AsDuration, util::Compact, ClientMessage,
-    ClientMessageKind, Request, Response, ServerError, Transport,
-};
-use fnv::FnvHashMap;
-use futures::{
-    channel::mpsc,
-    future::{abortable, AbortHandle},
-    prelude::*,
-    ready,
-    stream::Fuse,
-    task::{LocalWaker, Poll},
-    try_ready,
-};
-use humantime::format_rfc3339;
-use log::{debug, error, info, trace, warn};
-use pin_utils::{unsafe_pinned, unsafe_unpinned};
-use std::{
-    error::Error as StdError,
-    io,
-    marker::PhantomData,
-    net::SocketAddr,
-    pin::Pin,
-    time::{Instant, SystemTime},
-};
-use tokio_timer::timeout;
-use trace::{self, TraceId};
-
-mod filter;
-
-/// Manages clients, serving multiplexed requests over each connection.
-#[derive(Debug)]
-pub struct Server<Req, Resp> {
-    config: Config,
-    ghost: PhantomData<(Req, Resp)>,
-}
-
-impl<Req, Resp> Default for Server<Req, Resp> {
-    fn default() -> Self {
-        new(Config::default())
-    }
-}
-
-/// Settings that control the behavior of the server.
-#[non_exhaustive]
-#[derive(Clone, Debug)]
-pub struct Config {
-    /// The maximum number of clients that can be connected to the server at once. When at the
-    /// limit, existing connections are honored and new connections are rejected.
-    pub max_connections: usize,
-    /// The maximum number of clients per IP address that can be connected to the server at once.
-    /// When an IP is at the limit, existing connections are honored and new connections on that IP
-    /// address are rejected.
-    pub max_connections_per_ip: usize,
-    /// The maximum number of requests that can be in flight for each client. When a client is at
-    /// the in-flight request limit, existing requests are fulfilled and new requests are rejected.
-    /// Rejected requests are sent a response error.
-    pub max_in_flight_requests_per_connection: usize,
-    /// The number of responses per client that can be buffered server-side before being sent.
-    /// `pending_response_buffer` controls the buffer size of the channel that a server's
-    /// response tasks use to send responses to the client handler task.
-    pub pending_response_buffer: usize,
-}
-
-impl Default for Config {
-    fn default() -> Self {
-        Config {
-            max_connections: 1_000_000,
-            max_connections_per_ip: 1_000,
-            max_in_flight_requests_per_connection: 1_000,
-            pending_response_buffer: 100,
-        }
-    }
-}
-
-/// Returns a new server with configuration specified `config`.
-pub fn new<Req, Resp>(config: Config) -> Server<Req, Resp> {
-    Server {
-        config,
-        ghost: PhantomData,
-    }
-}
-
-impl<Req, Resp> Server<Req, Resp> {
-    /// Returns the config for this server.
-    pub fn config(&self) -> &Config {
-        &self.config
-    }
-
-    /// Returns a stream of the incoming connections to the server.
-    pub fn incoming<S, T>(
-        self,
-        listener: S,
-    ) -> impl Stream<Item = io::Result<Channel<Req, Resp, T>>>
-    where
-        Req: Send,
-        Resp: Send,
-        S: Stream<Item = io::Result<T>>,
-        T: Transport<Item = ClientMessage<Req>, SinkItem = Response<Resp>> + Send,
-    {
-        self::filter::ConnectionFilter::filter(listener, self.config.clone())
-    }
-}
-
-/// The future driving the server.
-#[derive(Debug)]
-pub struct Running<S, F> {
-    incoming: S,
-    request_handler: F,
-}
-
-impl<S, F> Running<S, F> {
-    unsafe_pinned!(incoming: S);
-    unsafe_unpinned!(request_handler: F);
-}
-
-impl<S, T, Req, Resp, F, Fut> Future for Running<S, F>
-where
-    S: Sized + Stream<Item = io::Result<Channel<Req, Resp, T>>>,
-    Req: Send + 'static,
-    Resp: Send + 'static,
-    T: Transport<Item = ClientMessage<Req>, SinkItem = Response<Resp>> + Send + 'static,
-    F: FnOnce(Context, Req) -> Fut + Send + 'static + Clone,
-    Fut: Future<Output = io::Result<Resp>> + Send + 'static,
-{
-    type Output = ();
-
-    fn poll(mut self: Pin<&mut Self>, cx: &LocalWaker) -> Poll<()> {
-        while let Some(channel) = ready!(self.incoming().poll_next(cx)) {
-            match channel {
-                Ok(channel) => {
-                    let peer = channel.client_addr;
-                    if let Err(e) =
-                        crate::spawn(channel.respond_with(self.request_handler().clone()))
-                    {
-                        warn!("[{}] Failed to spawn connection handler: {:?}", peer, e);
-                    }
-                }
-                Err(e) => {
-                    warn!("Incoming connection error: {}", e);
-                }
-            }
-        }
-        info!("Server shutting down.");
-        return Poll::Ready(());
-    }
-}
-
-/// A utility trait enabling a stream to fluently chain a request handler.
-pub trait Handler<T, Req, Resp>
-where
-    Self: Sized + Stream<Item = io::Result<Channel<Req, Resp, T>>>,
-    Req: Send,
-    Resp: Send,
-    T: Transport<Item = ClientMessage<Req>, SinkItem = Response<Resp>> + Send,
-{
-    /// Responds to all requests with `request_handler`.
-    fn respond_with<F, Fut>(self, request_handler: F) -> Running<Self, F>
-    where
-        F: FnOnce(Context, Req) -> Fut + Send + 'static + Clone,
-        Fut: Future<Output = io::Result<Resp>> + Send + 'static,
-    {
-        Running {
-            incoming: self,
-            request_handler,
-        }
-    }
-}
-
-impl<T, Req, Resp, S> Handler<T, Req, Resp> for S
-where
-    S: Sized + Stream<Item = io::Result<Channel<Req, Resp, T>>>,
-    Req: Send,
-    Resp: Send,
-    T: Transport<Item = ClientMessage<Req>, SinkItem = Response<Resp>> + Send,
-{}
-
-/// Responds to all requests with `request_handler`.
-/// The server end of an open connection with a client.
-#[derive(Debug)]
-pub struct Channel<Req, Resp, T> {
-    /// Writes responses to the wire and reads requests off the wire.
-    transport: Fuse<T>,
-    /// Signals the connection is closed when `Channel` is dropped.
-    closed_connections: mpsc::UnboundedSender<SocketAddr>,
-    /// Channel limits to prevent unlimited resource usage.
-    config: Config,
-    /// The address of the server connected to.
-    client_addr: SocketAddr,
-    /// Types the request and response.
-    ghost: PhantomData<(Req, Resp)>,
-}
-
-impl<Req, Resp, T> Drop for Channel<Req, Resp, T> {
-    fn drop(&mut self) {
-        trace!("[{}] Closing channel.", self.client_addr);
-
-        // Even in a bounded channel, each connection would have a guaranteed slot, so using
-        // an unbounded sender is actually no different. And, the bound is on the maximum number
-        // of open connections.
-        if self
-            .closed_connections
-            .unbounded_send(self.client_addr)
-            .is_err()
-        {
-            warn!(
-                "[{}] Failed to send closed connection message.",
-                self.client_addr
-            );
-        }
-    }
-}
-
-impl<Req, Resp, T> Channel<Req, Resp, T> {
-    unsafe_pinned!(transport: Fuse<T>);
-}
-
-impl<Req, Resp, T> Channel<Req, Resp, T>
-where
-    T: Transport<Item = ClientMessage<Req>, SinkItem = Response<Resp>> + Send,
-    Req: Send,
-    Resp: Send,
-{
-    pub(crate) fn start_send(
-        self: &mut Pin<&mut Self>,
-        response: Response<Resp>,
-    ) -> io::Result<()> {
-        self.transport().start_send(response)
-    }
-
-    pub(crate) fn poll_ready(self: &mut Pin<&mut Self>, cx: &LocalWaker) -> Poll<io::Result<()>> {
-        self.transport().poll_ready(cx)
-    }
-
-    pub(crate) fn poll_flush(self: &mut Pin<&mut Self>, cx: &LocalWaker) -> Poll<io::Result<()>> {
-        self.transport().poll_flush(cx)
-    }
-
-    pub(crate) fn poll_next(
-        self: &mut Pin<&mut Self>,
-        cx: &LocalWaker,
-    ) -> Poll<Option<io::Result<ClientMessage<Req>>>> {
-        self.transport().poll_next(cx)
-    }
-
-    /// Returns the address of the client connected to the channel.
-    pub fn client_addr(&self) -> &SocketAddr {
-        &self.client_addr
-    }
-
-    /// Respond to requests coming over the channel with `f`. Returns a future that drives the
-    /// responses and resolves when the connection is closed.
-    pub fn respond_with<F, Fut>(self, f: F) -> impl Future<Output = ()>
-    where
-        F: FnOnce(Context, Req) -> Fut + Send + 'static + Clone,
-        Fut: Future<Output = io::Result<Resp>> + Send + 'static,
-        Req: 'static,
-        Resp: 'static,
-    {
-        let (responses_tx, responses) = mpsc::channel(self.config.pending_response_buffer);
-        let responses = responses.fuse();
-        let peer = self.client_addr;
-
-        ClientHandler {
-            channel: self,
-            f,
-            pending_responses: responses,
-            responses_tx,
-            in_flight_requests: FnvHashMap::default(),
-        }
-        .unwrap_or_else(move |e| {
-            info!("[{}] ClientHandler errored out: {}", peer, e);
-        })
-    }
-}
-
-#[derive(Debug)]
-struct ClientHandler<Req, Resp, T, F> {
-    channel: Channel<Req, Resp, T>,
-    /// Responses waiting to be written to the wire.
-    pending_responses: Fuse<mpsc::Receiver<(Context, Response<Resp>)>>,
-    /// Handed out to request handlers to fan in responses.
-    responses_tx: mpsc::Sender<(Context, Response<Resp>)>,
-    /// Number of requests currently being responded to.
-    in_flight_requests: FnvHashMap<u64, AbortHandle>,
-    /// Request handler.
-    f: F,
-}
-
-impl<Req, Resp, T, F> ClientHandler<Req, Resp, T, F> {
-    unsafe_pinned!(channel: Channel<Req, Resp, T>);
-    unsafe_pinned!(in_flight_requests: FnvHashMap<u64, AbortHandle>);
-    unsafe_pinned!(pending_responses: Fuse<mpsc::Receiver<(Context, Response<Resp>)>>);
-    unsafe_pinned!(responses_tx: mpsc::Sender<(Context, Response<Resp>)>);
-    // For this to be safe, field f must be private, and code in this module must never
-    // construct PinMut<F>.
-    unsafe_unpinned!(f: F);
-}
-
-impl<Req, Resp, T, F, Fut> ClientHandler<Req, Resp, T, F>
-where
-    Req: Send + 'static,
-    Resp: Send + 'static,
-    T: Transport<Item = ClientMessage<Req>, SinkItem = Response<Resp>> + Send,
-    F: FnOnce(Context, Req) -> Fut + Send + 'static + Clone,
-    Fut: Future<Output = io::Result<Resp>> + Send + 'static,
-{
-    /// If at max in-flight requests, check that there's room to immediately write a throttled
-    /// response.
-    fn poll_ready_if_throttling(
-        self: &mut Pin<&mut Self>,
-        cx: &LocalWaker,
-    ) -> Poll<io::Result<()>> {
-        if self.in_flight_requests.len()
-            >= self.channel.config.max_in_flight_requests_per_connection
-        {
-            let peer = self.channel().client_addr;
-
-            while let Poll::Pending = self.channel().poll_ready(cx)? {
-                info!(
-                    "[{}] In-flight requests at max ({}), and transport is not ready.",
-                    peer,
-                    self.in_flight_requests().len(),
-                );
-                try_ready!(self.channel().poll_flush(cx));
-            }
-        }
-        Poll::Ready(Ok(()))
-    }
-
-    fn pump_read(self: &mut Pin<&mut Self>, cx: &LocalWaker) -> Poll<Option<io::Result<()>>> {
-        ready!(self.poll_ready_if_throttling(cx)?);
-
-        Poll::Ready(match ready!(self.channel().poll_next(cx)?) {
-            Some(message) => {
-                match message.message {
-                    ClientMessageKind::Request(request) => {
-                        self.handle_request(message.trace_context, request)?;
-                    }
-                    ClientMessageKind::Cancel { request_id } => {
-                        self.cancel_request(&message.trace_context, request_id);
-                    }
-                }
-                Some(Ok(()))
-            }
-            None => {
-                trace!("[{}] Read half closed", self.channel.client_addr);
-                None
-            }
-        })
-    }
-
-    fn pump_write(
-        self: &mut Pin<&mut Self>,
-        cx: &LocalWaker,
-        read_half_closed: bool,
-    ) -> Poll<Option<io::Result<()>>> {
-        match self.poll_next_response(cx)? {
-            Poll::Ready(Some((_, response))) => {
-                self.channel().start_send(response)?;
-                Poll::Ready(Some(Ok(())))
-            }
-            Poll::Ready(None) => {
-                // Shutdown can't be done before we finish pumping out remaining responses.
-                ready!(self.channel().poll_flush(cx)?);
-                Poll::Ready(None)
-            }
-            Poll::Pending => {
-                // No more requests to process, so flush any requests buffered in the transport.
-                ready!(self.channel().poll_flush(cx)?);
-
-                // Being here means there are no staged requests and all written responses are
-                // fully flushed. So, if the read half is closed and there are no in-flight
-                // requests, then we can close the write half.
-                if read_half_closed && self.in_flight_requests().is_empty() {
-                    Poll::Ready(None)
-                } else {
-                    Poll::Pending
-                }
-            }
-        }
-    }
-
-    fn poll_next_response(
-        self: &mut Pin<&mut Self>,
-        cx: &LocalWaker,
-    ) -> Poll<Option<io::Result<(Context, Response<Resp>)>>> {
-        // Ensure there's room to write a response.
-        while let Poll::Pending = self.channel().poll_ready(cx)? {
-            ready!(self.channel().poll_flush(cx)?);
-        }
-
-        let peer = self.channel().client_addr;
-
-        match ready!(self.pending_responses().poll_next(cx)) {
-            Some((ctx, response)) => {
-                if let Some(_) = self.in_flight_requests().remove(&response.request_id) {
-                    self.in_flight_requests().compact(0.1);
-                }
-                trace!(
-                    "[{}/{}] Staging response. In-flight requests = {}.",
-                    ctx.trace_id(),
-                    peer,
-                    self.in_flight_requests().len(),
-                );
-                return Poll::Ready(Some(Ok((ctx, response))));
-            }
-            None => {
-                // This branch likely won't happen, since the ClientHandler is holding a Sender.
-                trace!("[{}] No new responses.", peer);
-                Poll::Ready(None)
-            }
-        }
-    }
-
-    fn handle_request(
-        self: &mut Pin<&mut Self>,
-        trace_context: trace::Context,
-        request: Request<Req>,
-    ) -> io::Result<()> {
-        let request_id = request.id;
-        let peer = self.channel().client_addr;
-        let ctx = Context {
-            deadline: request.deadline,
-            trace_context,
-        };
-        let request = request.message;
-
-        if self.in_flight_requests().len()
-            >= self.channel().config.max_in_flight_requests_per_connection
-        {
-            debug!(
-                "[{}/{}] Client has reached in-flight request limit ({}/{}).",
-                ctx.trace_id(),
-                peer,
-                self.in_flight_requests().len(),
-                self.channel().config.max_in_flight_requests_per_connection
-            );
-
-            self.channel().start_send(Response {
-                request_id,
-                message: Err(ServerError {
-                    kind: io::ErrorKind::WouldBlock,
-                    detail: Some("Server throttled the request.".into()),
-                }),
-            })?;
-            return Ok(());
-        }
-
-        let deadline = ctx.deadline;
-        let timeout = deadline.as_duration();
-        trace!(
-            "[{}/{}] Received request with deadline {} (timeout {:?}).",
-            ctx.trace_id(),
-            peer,
-            format_rfc3339(deadline),
-            timeout,
-        );
-        let mut response_tx = self.responses_tx().clone();
-
-        let trace_id = *ctx.trace_id();
-        let response = self.f().clone()(ctx.clone(), request);
-        let response = deadline_compat::Deadline::new(response, Instant::now() + timeout).then(
-            async move |result| {
-                let response = Response {
-                    request_id,
-                    message: match result {
-                        Ok(message) => Ok(message),
-                        Err(e) => Err(make_server_error(e, trace_id, peer, deadline)),
-                    },
-                };
-                trace!("[{}/{}] Sending response.", trace_id, peer);
-                await!(response_tx.send((ctx, response)).unwrap_or_else(|_| ()));
-            },
-        );
-        let (abortable_response, abort_handle) = abortable(response);
-        crate::spawn(abortable_response.map(|_| ())).map_err(|e| {
-            io::Error::new(
-                io::ErrorKind::Other,
-                format!(
-                    "Could not spawn response task. Is shutdown: {}",
-                    e.is_shutdown()
-                ),
-            )
-        })?;
-        self.in_flight_requests().insert(request_id, abort_handle);
-        Ok(())
-    }
-
-    fn cancel_request(self: &mut Pin<&mut Self>, trace_context: &trace::Context, request_id: u64) {
-        // It's possible the request was already completed, so it's fine
-        // if this is None.
-        if let Some(cancel_handle) = self.in_flight_requests().remove(&request_id) {
-            self.in_flight_requests().compact(0.1);
-
-            cancel_handle.abort();
-            let remaining = self.in_flight_requests().len();
-            trace!(
-                "[{}/{}] Request canceled. In-flight requests = {}",
-                trace_context.trace_id,
-                self.channel.client_addr,
-                remaining,
-            );
-        } else {
-            trace!(
-                "[{}/{}] Received cancellation, but response handler \
-                 is already complete.",
-                trace_context.trace_id,
-                self.channel.client_addr
-            );
-        }
-    }
-}
-
-impl<Req, Resp, T, F, Fut> Future for ClientHandler<Req, Resp, T, F>
-where
-    Req: Send + 'static,
-    Resp: Send + 'static,
-    T: Transport<Item = ClientMessage<Req>, SinkItem = Response<Resp>> + Send,
-    F: FnOnce(Context, Req) -> Fut + Send + 'static + Clone,
-    Fut: Future<Output = io::Result<Resp>> + Send + 'static,
-{
-    type Output = io::Result<()>;
-
-    fn poll(mut self: Pin<&mut Self>, cx: &LocalWaker) -> Poll<io::Result<()>> {
-        trace!("[{}] ClientHandler::poll", self.channel.client_addr);
-        loop {
-            let read = self.pump_read(cx)?;
-            match (read, self.pump_write(cx, read == Poll::Ready(None))?) {
-                (Poll::Ready(None), Poll::Ready(None)) => {
-                    info!("[{}] Client disconnected.", self.channel.client_addr);
-                    return Poll::Ready(Ok(()));
-                }
-                (read @ Poll::Ready(Some(())), write) | (read, write @ Poll::Ready(Some(()))) => {
-                    trace!(
-                        "[{}] read: {:?}, write: {:?}.",
-                        self.channel.client_addr,
-                        read,
-                        write
-                    )
-                }
-                (read, write) => {
-                    trace!(
-                        "[{}] read: {:?}, write: {:?} (not ready).",
-                        self.channel.client_addr,
-                        read,
-                        write,
-                    );
-                    return Poll::Pending;
-                }
-            }
-        }
-    }
-}
-
-fn make_server_error(
-    e: timeout::Error<io::Error>,
-    trace_id: TraceId,
-    peer: SocketAddr,
-    deadline: SystemTime,
-) -> ServerError {
-    if e.is_elapsed() {
-        debug!(
-            "[{}/{}] Response did not complete before deadline of {}s.",
-            trace_id,
-            peer,
-            format_rfc3339(deadline)
-        );
-        // No point in responding, since the client will have dropped the request.
-        ServerError {
-            kind: io::ErrorKind::TimedOut,
-            detail: Some(format!(
-                "Response did not complete before deadline of {}s.",
-                format_rfc3339(deadline)
-            )),
-        }
-    } else if e.is_timer() {
-        error!(
-            "[{}/{}] Response failed because of an issue with a timer: {}",
-            trace_id, peer, e
-        );
-
-        ServerError {
-            kind: io::ErrorKind::Other,
-            detail: Some(format!("{}", e)),
-        }
-    } else if e.is_inner() {
-        let e = e.into_inner().unwrap();
-        ServerError {
-            kind: e.kind(),
-            detail: Some(e.description().into()),
-        }
-    } else {
-        error!("[{}/{}] Unexpected response failure: {}", trace_id, peer, e);
-
-        ServerError {
-            kind: io::ErrorKind::Other,
-            detail: Some(format!("Server unexpectedly failed to respond: {}", e)),
-        }
-    }
-}

rpc/src/transport/channel.rs

@@ -1,158 +0,0 @@
-// Copyright 2018 Google LLC
-//
-// Use of this source code is governed by an MIT-style
-// license that can be found in the LICENSE file or at
-// https://opensource.org/licenses/MIT.
-
-//! Transports backed by in-memory channels.
-
-use crate::Transport;
-use futures::{channel::mpsc, task::LocalWaker, Poll, Sink, Stream};
-use pin_utils::unsafe_pinned;
-use std::pin::Pin;
-use std::{
-    io,
-    net::{IpAddr, Ipv4Addr, SocketAddr},
-};
-
-/// Returns two unbounded channel peers. Each [`Stream`] yields items sent through the other's
-/// [`Sink`].
-pub fn unbounded<SinkItem, Item>() -> (
-    UnboundedChannel<SinkItem, Item>,
-    UnboundedChannel<Item, SinkItem>,
-) {
-    let (tx1, rx2) = mpsc::unbounded();
-    let (tx2, rx1) = mpsc::unbounded();
-    (
-        UnboundedChannel { tx: tx1, rx: rx1 },
-        UnboundedChannel { tx: tx2, rx: rx2 },
-    )
-}
-
-/// A bi-directional channel backed by an [`UnboundedSender`](mpsc::UnboundedSender)
-/// and [`UnboundedReceiver`](mpsc::UnboundedReceiver).
-#[derive(Debug)]
-pub struct UnboundedChannel<Item, SinkItem> {
-    rx: mpsc::UnboundedReceiver<Item>,
-    tx: mpsc::UnboundedSender<SinkItem>,
-}
-
-impl<Item, SinkItem> UnboundedChannel<Item, SinkItem> {
-    unsafe_pinned!(rx: mpsc::UnboundedReceiver<Item>);
-    unsafe_pinned!(tx: mpsc::UnboundedSender<SinkItem>);
-}
-
-impl<Item, SinkItem> Stream for UnboundedChannel<Item, SinkItem> {
-    type Item = Result<Item, io::Error>;
-
-    fn poll_next(mut self: Pin<&mut Self>, cx: &LocalWaker) -> Poll<Option<io::Result<Item>>> {
-        self.rx().poll_next(cx).map(|option| option.map(Ok))
-    }
-}
-
-impl<Item, SinkItem> Sink for UnboundedChannel<Item, SinkItem> {
-    type SinkItem = SinkItem;
-    type SinkError = io::Error;
-
-    fn poll_ready(mut self: Pin<&mut Self>, cx: &LocalWaker) -> Poll<io::Result<()>> {
-        self.tx()
-            .poll_ready(cx)
-            .map_err(|_| io::Error::from(io::ErrorKind::NotConnected))
-    }
-
-    fn start_send(mut self: Pin<&mut Self>, item: SinkItem) -> io::Result<()> {
-        self.tx()
-            .start_send(item)
-            .map_err(|_| io::Error::from(io::ErrorKind::NotConnected))
-    }
-
-    fn poll_flush(mut self: Pin<&mut Self>, cx: &LocalWaker) -> Poll<Result<(), Self::SinkError>> {
-        self.tx()
-            .poll_flush(cx)
-            .map_err(|_| io::Error::from(io::ErrorKind::NotConnected))
-    }
-
-    fn poll_close(mut self: Pin<&mut Self>, cx: &LocalWaker) -> Poll<io::Result<()>> {
-        self.tx()
-            .poll_close(cx)
-            .map_err(|_| io::Error::from(io::ErrorKind::NotConnected))
-    }
-}
-
-impl<Item, SinkItem> Transport for UnboundedChannel<Item, SinkItem> {
-    type Item = Item;
-    type SinkItem = SinkItem;
-
-    fn peer_addr(&self) -> io::Result<SocketAddr> {
-        Ok(SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), 0))
-    }
-
-    fn local_addr(&self) -> io::Result<SocketAddr> {
-        Ok(SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), 0))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::{
-        client, context,
-        server::{Handler, Server},
-        transport,
-    };
-    use futures::{compat::TokioDefaultSpawner, prelude::*, stream};
-    use log::trace;
-    use std::io;
-
-    #[test]
-    fn integration() {
-        let _ = env_logger::try_init();
-        crate::init(TokioDefaultSpawner);
-
-        let (client_channel, server_channel) = transport::channel::unbounded();
-        let server = Server::<String, u64>::default()
-            .incoming(stream::once(future::ready(Ok(server_channel))))
-            .respond_with(|_ctx, request| {
-                future::ready(request.parse::<u64>().map_err(|_| {
-                    io::Error::new(
-                        io::ErrorKind::InvalidInput,
-                        format!("{:?} is not an int", request),
-                    )
-                }))
-            });
-
-        let responses = async {
-            let mut client = await!(client::new(client::Config::default(), client_channel))?;
-
-            let response1 = await!(client.call(context::current(), "123".into()));
-            let response2 = await!(client.call(context::current(), "abc".into()));
-
-            Ok::<_, io::Error>((response1, response2))
-        };
-
-        let (response1, response2) =
-            run_future(server.join(responses.unwrap_or_else(|e| panic!(e)))).1;
-
-        trace!("response1: {:?}, response2: {:?}", response1, response2);
-
-        assert!(response1.is_ok());
-        assert_eq!(response1.ok().unwrap(), 123);
-
-        assert!(response2.is_err());
-        assert_eq!(response2.err().unwrap().kind(), io::ErrorKind::InvalidInput);
-    }
-
-    fn run_future<F>(f: F) -> F::Output
-    where
-        F: Future + Send + 'static,
-        F::Output: Send + 'static,
-    {
-        let (tx, rx) = futures::channel::oneshot::channel();
-        tokio::run(
-            f.map(|result| tx.send(result).unwrap_or_else(|_| unreachable!()))
-                .boxed()
-                .unit_error()
-                .compat(),
-        );
-        futures::executor::block_on(rx).unwrap()
-    }
-}

rpc/src/transport/mod.rs

@@ -1,121 +0,0 @@
-// Copyright 2018 Google LLC
-//
-// Use of this source code is governed by an MIT-style
-// license that can be found in the LICENSE file or at
-// https://opensource.org/licenses/MIT.
-
-//! Provides a [`Transport`] trait as well as implementations.
-//!
-//! The rpc crate is transport- and protocol-agnostic. Any transport that impls [`Transport`]
-//! can be plugged in, using whatever protocol it wants.
-
-use futures::prelude::*;
-use std::{
-    io,
-    net::SocketAddr,
-    pin::Pin,
-    task::{LocalWaker, Poll},
-};
-
-pub mod channel;
-
-/// A bidirectional stream ([`Sink`] + [`Stream`]) of messages.
-pub trait Transport
-where
-    Self: Stream<Item = io::Result<<Self as Transport>::Item>>,
-    Self: Sink<SinkItem = <Self as Transport>::SinkItem, SinkError = io::Error>,
-{
-    /// The type read off the transport.
-    type Item;
-    /// The type written to the transport.
-    type SinkItem;
-
-    /// The address of the remote peer this transport is in communication with.
-    fn peer_addr(&self) -> io::Result<SocketAddr>;
-    /// The address of the local half of this transport.
-    fn local_addr(&self) -> io::Result<SocketAddr>;
-}
-
-/// Returns a new Transport backed by the given Stream + Sink and connecting addresses.
-pub fn new<S, Item>(
-    inner: S,
-    peer_addr: SocketAddr,
-    local_addr: SocketAddr,
-) -> impl Transport<Item = Item, SinkItem = S::SinkItem>
-where
-    S: Stream<Item = io::Result<Item>>,
-    S: Sink<SinkError = io::Error>,
-{
-    TransportShim {
-        inner,
-        peer_addr,
-        local_addr,
-    }
-}
-
-/// A transport created by adding peers to a Stream + Sink.
-#[derive(Debug)]
-struct TransportShim<S> {
-    peer_addr: SocketAddr,
-    local_addr: SocketAddr,
-    inner: S,
-}
-
-impl<S> TransportShim<S> {
-    pin_utils::unsafe_pinned!(inner: S);
-}
-
-impl<S> Stream for TransportShim<S>
-where
-    S: Stream,
-{
-    type Item = S::Item;
-
-    fn poll_next(mut self: Pin<&mut Self>, waker: &LocalWaker) -> Poll<Option<S::Item>> {
-        self.inner().poll_next(waker)
-    }
-}
-
-impl<S> Sink for TransportShim<S>
-where
-    S: Sink,
-{
-    type SinkItem = S::SinkItem;
-    type SinkError = S::SinkError;
-
-    fn start_send(mut self: Pin<&mut Self>, item: S::SinkItem) -> Result<(), S::SinkError> {
-        self.inner().start_send(item)
-    }
-
-    fn poll_ready(mut self: Pin<&mut Self>, waker: &LocalWaker) -> Poll<Result<(), S::SinkError>> {
-        self.inner().poll_ready(waker)
-    }
-
-    fn poll_flush(mut self: Pin<&mut Self>, waker: &LocalWaker) -> Poll<Result<(), S::SinkError>> {
-        self.inner().poll_flush(waker)
-    }
-
-    fn poll_close(mut self: Pin<&mut Self>, waker: &LocalWaker) -> Poll<Result<(), S::SinkError>> {
-        self.inner().poll_close(waker)
-    }
-}
-
-impl<S, Item> Transport for TransportShim<S>
-where
-    S: Stream + Sink,
-    Self: Stream<Item = io::Result<Item>>,
-    Self: Sink<SinkItem = S::SinkItem, SinkError = io::Error>,
-{
-    type Item = Item;
-    type SinkItem = S::SinkItem;
-
-    /// The address of the remote peer this transport is in communication with.
-    fn peer_addr(&self) -> io::Result<SocketAddr> {
-        Ok(self.peer_addr)
-    }
-
-    /// The address of the local half of this transport.
-    fn local_addr(&self) -> io::Result<SocketAddr> {
-        Ok(self.local_addr)
-    }
-}

rpc/src/util/deadline_compat.rs

@@ -1,69 +0,0 @@
-// Copyright 2018 Google LLC
-//
-// Use of this source code is governed by an MIT-style
-// license that can be found in the LICENSE file or at
-// https://opensource.org/licenses/MIT.
-
-use futures::{
-    compat::{Compat01As03, Future01CompatExt},
-    prelude::*,
-    ready,
-    task::{LocalWaker, Poll},
-};
-use pin_utils::unsafe_pinned;
-use std::pin::Pin;
-use std::time::Instant;
-use tokio_timer::{timeout, Delay};
-
-#[must_use = "futures do nothing unless polled"]
-#[derive(Debug)]
-pub struct Deadline<T> {
-    future: T,
-    delay: Compat01As03<Delay>,
-}
-
-impl<T> Deadline<T> {
-    unsafe_pinned!(future: T);
-    unsafe_pinned!(delay: Compat01As03<Delay>);
-
-    /// Create a new `Deadline` that completes when `future` completes or when
-    /// `deadline` is reached.
-    pub fn new(future: T, deadline: Instant) -> Deadline<T> {
-        Deadline::new_with_delay(future, Delay::new(deadline))
-    }
-
-    pub(crate) fn new_with_delay(future: T, delay: Delay) -> Deadline<T> {
-        Deadline {
-            future,
-            delay: delay.compat(),
-        }
-    }
-
-    /// Gets a mutable reference to the underlying future in this deadline.
-    pub fn get_mut(&mut self) -> &mut T {
-        &mut self.future
-    }
-}
-impl<T> Future for Deadline<T>
-where
-    T: TryFuture,
-{
-    type Output = Result<T::Ok, timeout::Error<T::Error>>;
-
-    fn poll(mut self: Pin<&mut Self>, waker: &LocalWaker) -> Poll<Self::Output> {
-        // First, try polling the future
-        match self.future().try_poll(waker) {
-            Poll::Ready(Ok(v)) => return Poll::Ready(Ok(v)),
-            Poll::Pending => {}
-            Poll::Ready(Err(e)) => return Poll::Ready(Err(timeout::Error::inner(e))),
-        }
-
-        let delay = self.delay().poll_unpin(waker);
-
-        // Now check the timer
-        match ready!(delay) {
-            Ok(_) => Poll::Ready(Err(timeout::Error::elapsed())),
-            Err(e) => Poll::Ready(Err(timeout::Error::timer(e))),
-        }
-    }
-}

tarpc/Cargo.toml

@@ -1,8 +1,6 @@
-cargo-features = ["rename-dependency"]
-
 [package]
 name = "tarpc"
-version = "0.14.0"
+version = "0.20.0"
 authors = ["Adam Wright <adam.austin.wright@gmail.com>", "Tim Kuehn <timothy.j.kuehn@gmail.com>"]
 edition = "2018"
 license = "MIT"
@@ -15,28 +13,52 @@ readme = "../README.md"
 description = "An RPC framework for Rust with a focus on ease of use."
 
 [features]
-serde1 = ["rpc/serde1", "serde", "serde/derive"]
+default = []
+
+serde1 = ["tarpc-plugins/serde1", "serde", "serde/derive"]
+tokio1 = []
+serde-transport = ["tokio-serde", "tokio-util/codec"]
+tcp = ["tokio/net", "tokio/stream"]
+
+full = ["serde1", "tokio1", "serde-transport", "tcp"]
 
 [badges]
 travis-ci = { repository = "google/tarpc" }
 
 [dependencies]
+fnv = "1.0"
+futures = "0.3"
+humantime = "1.0"
 log = "0.4"
-serde = { optional = true, version = "1.0" }
-tarpc-plugins = { path = "../plugins", version = "0.5.0" }
-rpc = { package = "tarpc-lib", path = "../rpc", version = "0.2" }
-
-[target.'cfg(not(test))'.dependencies]
-futures-preview = "0.3.0-alpha.9"
+pin-project = "0.4"
+raii-counter = "0.2"
+rand = "0.7"
+tokio = { version = "0.2", features = ["time"] }
+serde = { optional = true, version = "1.0", features = ["derive"] }
+tokio-util = { optional = true, version = "0.2" }
+tarpc-plugins = { path = "../plugins", version = "0.7" }
+tokio-serde = { optional = true, version = "0.6" }
 
 [dev-dependencies]
-bincode = "1.0"
-bytes = { version = "0.4", features = ["serde"] }
+assert_matches = "1.0"
+bytes = { version = "0.5", features = ["serde"] }
+env_logger = "0.6"
+futures = "0.3"
 humantime = "1.0"
-futures-preview = { version = "0.3.0-alpha.9", features = ["compat", "tokio-compat"] }
-bincode-transport = { package = "tarpc-bincode-transport", version = "0.3", path = "../bincode-transport" }
-env_logger = "0.5"
-tokio = "0.1"
-tokio-executor = "0.1"
-tokio-tcp = "0.1"
-pin-utils = "0.1.0-alpha.3"
+log = "0.4"
+pin-utils = "0.1.0-alpha"
+tokio = { version = "0.2", features = ["full"] }
+tokio-serde = { version = "0.6", features = ["json"] }
+
+[[example]]
+name = "server_calling_server"
+required-features = ["full"]
+
+[[example]]
+name = "readme"
+required-features = ["full"]
+
+[[example]]
+name = "pubsub"
+required-features = ["full"]
+

tarpc/README.md

@@ -0,0 +1 @@
+../README.md

tarpc/examples/pubsub.rs

@@ -4,46 +4,42 @@
 // license that can be found in the LICENSE file or at
 // https://opensource.org/licenses/MIT.
 
-#![feature(
-    arbitrary_self_types,
-    pin,
-    futures_api,
-    await_macro,
-    async_await,
-    existential_type,
-    proc_macro_hygiene
-)]
-
 use futures::{
     future::{self, Ready},
     prelude::*,
     Future,
 };
-use rpc::{
-    client, context,
-    server::{self, Handler, Server},
-};
+use publisher::Publisher as _;
 use std::{
     collections::HashMap,
     io,
     net::SocketAddr,
+    pin::Pin,
     sync::{Arc, Mutex},
-    thread,
     time::Duration,
 };
+use subscriber::Subscriber as _;
+use tarpc::{
+    client, context,
+    server::{self, Handler},
+};
+use tokio_serde::formats::Json;
 
 pub mod subscriber {
-    tarpc::service! {
-        rpc receive(message: String);
+    #[tarpc::service]
+    pub trait Subscriber {
+        async fn receive(message: String);
     }
 }
 
 pub mod publisher {
     use std::net::SocketAddr;
-    tarpc::service! {
-        rpc broadcast(message: String);
-        rpc subscribe(id: u32, address: SocketAddr) -> Result<(), String>;
-        rpc unsubscribe(id: u32);
+
+    #[tarpc::service]
+    pub trait Publisher {
+        async fn broadcast(message: String);
+        async fn subscribe(id: u32, address: SocketAddr) -> Result<(), String>;
+        async fn unsubscribe(id: u32);
     }
 }
 
@@ -52,27 +48,26 @@ struct Subscriber {
     id: u32,
 }
 
-impl subscriber::Service for Subscriber {
+impl subscriber::Subscriber for Subscriber {
     type ReceiveFut = Ready<()>;
 
     fn receive(self, _: context::Context, message: String) -> Self::ReceiveFut {
-        println!("{} received message: {}", self.id, message);
+        eprintln!("{} received message: {}", self.id, message);
         future::ready(())
     }
 }
 
 impl Subscriber {
     async fn listen(id: u32, config: server::Config) -> io::Result<SocketAddr> {
-        let incoming = bincode_transport::listen(&"0.0.0.0:0".parse().unwrap())?;
-        let addr = incoming.local_addr();
-        tokio_executor::spawn(
+        let incoming = tarpc::serde_transport::tcp::listen("localhost:0", Json::default)
+            .await?
+            .filter_map(|r| future::ready(r.ok()));
+        let addr = incoming.get_ref().local_addr();
+        tokio::spawn(
             server::new(config)
                 .incoming(incoming)
                 .take(1)
-                .respond_with(subscriber::serve(Subscriber { id }))
-                .unit_error()
-                .boxed()
-                .compat(),
+                .respond_with(Subscriber { id }.serve()),
         );
         Ok(addr)
     }
@@ -80,7 +75,7 @@ impl Subscriber {
 
 #[derive(Clone, Debug)]
 struct Publisher {
-    clients: Arc<Mutex<HashMap<u32, subscriber::Client>>>,
+    clients: Arc<Mutex<HashMap<u32, subscriber::SubscriberClient>>>,
 }
 
 impl Publisher {
@@ -91,95 +86,110 @@ impl Publisher {
     }
 }
 
-impl publisher::Service for Publisher {
-    existential type BroadcastFut: Future<Output = ()>;
+impl publisher::Publisher for Publisher {
+    type BroadcastFut = Pin<Box<dyn Future<Output = ()> + Send>>;
 
     fn broadcast(self, _: context::Context, message: String) -> Self::BroadcastFut {
-        async fn broadcast(clients: Arc<Mutex<HashMap<u32, subscriber::Client>>>, message: String) {
+        async fn broadcast(
+            clients: Arc<Mutex<HashMap<u32, subscriber::SubscriberClient>>>,
+            message: String,
+        ) {
             let mut clients = clients.lock().unwrap().clone();
             for client in clients.values_mut() {
                 // Ignore failing subscribers. In a real pubsub,
                 // you'd want to continually retry until subscribers
                 // ack.
-                let _ = await!(client.receive(context::current(), message.clone()));
+                let _ = client.receive(context::current(), message.clone()).await;
             }
         }
 
-        broadcast(self.clients.clone(), message)
+        broadcast(self.clients.clone(), message).boxed()
     }
 
-    existential type SubscribeFut: Future<Output = Result<(), String>>;
+    type SubscribeFut = Pin<Box<dyn Future<Output = Result<(), String>> + Send>>;
 
     fn subscribe(self, _: context::Context, id: u32, addr: SocketAddr) -> Self::SubscribeFut {
         async fn subscribe(
-            clients: Arc<Mutex<HashMap<u32, subscriber::Client>>>,
+            clients: Arc<Mutex<HashMap<u32, subscriber::SubscriberClient>>>,
             id: u32,
             addr: SocketAddr,
         ) -> io::Result<()> {
-            let conn = await!(bincode_transport::connect(&addr))?;
-            let subscriber = await!(subscriber::new_stub(client::Config::default(), conn))?;
-            println!("Subscribing {}.", id);
+            let conn = tarpc::serde_transport::tcp::connect(addr, Json::default()).await?;
+            let subscriber =
+                subscriber::SubscriberClient::new(client::Config::default(), conn).spawn()?;
+            eprintln!("Subscribing {}.", id);
             clients.lock().unwrap().insert(id, subscriber);
             Ok(())
         }
 
-        subscribe(Arc::clone(&self.clients), id, addr).map_err(|e| e.to_string())
+        subscribe(Arc::clone(&self.clients), id, addr)
+            .map_err(|e| e.to_string())
+            .boxed()
     }
 
-    existential type UnsubscribeFut: Future<Output = ()>;
+    type UnsubscribeFut = Pin<Box<dyn Future<Output = ()> + Send>>;
 
     fn unsubscribe(self, _: context::Context, id: u32) -> Self::UnsubscribeFut {
-        println!("Unsubscribing {}", id);
+        eprintln!("Unsubscribing {}", id);
         let mut clients = self.clients.lock().unwrap();
-        if let None = clients.remove(&id) {
+        if clients.remove(&id).is_none() {
             eprintln!(
                 "Client {} not found. Existings clients: {:?}",
                 id, &*clients
             );
         }
-        future::ready(())
+        future::ready(()).boxed()
     }
 }
 
-async fn run() -> io::Result<()> {
+#[tokio::main]
+async fn main() -> io::Result<()> {
     env_logger::init();
-    let transport = bincode_transport::listen(&"0.0.0.0:0".parse().unwrap())?;
-    let publisher_addr = transport.local_addr();
-    tokio_executor::spawn(
-        Server::default()
-            .incoming(transport)
+
+    let transport = tarpc::serde_transport::tcp::listen("localhost:0", Json::default)
+        .await?
+        .filter_map(|r| future::ready(r.ok()));
+    let publisher_addr = transport.get_ref().local_addr();
+    tokio::spawn(
+        transport
             .take(1)
-            .respond_with(publisher::serve(Publisher::new()))
-            .unit_error()
-            .boxed()
-            .compat(),
+            .map(server::BaseChannel::with_defaults)
+            .respond_with(Publisher::new().serve()),
     );
 
-    let subscriber1 = await!(Subscriber::listen(0, server::Config::default()))?;
-    let subscriber2 = await!(Subscriber::listen(1, server::Config::default()))?;
+    let subscriber1 = Subscriber::listen(0, server::Config::default()).await?;
+    let subscriber2 = Subscriber::listen(1, server::Config::default()).await?;
 
-    let publisher_conn = bincode_transport::connect(&publisher_addr);
-    let publisher_conn = await!(publisher_conn)?;
-    let mut publisher = await!(publisher::new_stub(
-        client::Config::default(),
-        publisher_conn
-    ))?;
+    let publisher_conn = tarpc::serde_transport::tcp::connect(publisher_addr, Json::default());
+    let publisher_conn = publisher_conn.await?;
+    let mut publisher =
+        publisher::PublisherClient::new(client::Config::default(), publisher_conn).spawn()?;
 
-    if let Err(e) = await!(publisher.subscribe(context::current(), 0, subscriber1))? {
+    if let Err(e) = publisher
+        .subscribe(context::current(), 0, subscriber1)
+        .await?
+    {
         eprintln!("Couldn't subscribe subscriber 0: {}", e);
     }
-    if let Err(e) = await!(publisher.subscribe(context::current(), 1, subscriber2))? {
+    if let Err(e) = publisher
+        .subscribe(context::current(), 1, subscriber2)
+        .await?
+    {
         eprintln!("Couldn't subscribe subscriber 1: {}", e);
     }
 
     println!("Broadcasting...");
-    await!(publisher.broadcast(context::current(), "hello to all".to_string()))?;
-    await!(publisher.unsubscribe(context::current(), 1))?;
-    await!(publisher.broadcast(context::current(), "hi again".to_string()))?;
+    publisher
+        .broadcast(context::current(), "hello to all".to_string())
+        .await?;
+    publisher.unsubscribe(context::current(), 1).await?;
+    publisher
+        .broadcast(context::current(), "hi again".to_string())
+        .await?;
+    drop(publisher);
+
+    tokio::time::delay_for(Duration::from_millis(100)).await;
+    println!("Done.");
+
     Ok(())
 }
-
-fn main() {
-    tokio::run(run().boxed().map_err(|e| panic!(e)).boxed().compat());
-    thread::sleep(Duration::from_millis(100));
-}

tarpc/examples/readme.rs

@@ -4,39 +4,30 @@
 // license that can be found in the LICENSE file or at
 // https://opensource.org/licenses/MIT.
 
-#![feature(
-    futures_api,
-    pin,
-    arbitrary_self_types,
-    await_macro,
-    async_await,
-    proc_macro_hygiene
-)]
-
 use futures::{
-    compat::TokioDefaultSpawner,
     future::{self, Ready},
     prelude::*,
 };
-use rpc::{
-    client, context,
-    server::{Handler, Server},
-};
 use std::io;
+use tarpc::{
+    client, context,
+    server::{BaseChannel, Channel},
+};
+use tokio_serde::formats::Json;
 
-// This is the service definition. It looks a lot like a trait definition.
-// It defines one RPC, hello, which takes one arg, name, and returns a String.
-
-tarpc::service! {
-    rpc hello(name: String) -> String;
+/// This is the service definition. It looks a lot like a trait definition.
+/// It defines one RPC, hello, which takes one arg, name, and returns a String.
+#[tarpc::service]
+pub trait World {
+    async fn hello(name: String) -> String;
 }
 
-// This is the type that implements the generated Service trait. It is the business logic
-// and is used to start the server.
+/// This is the type that implements the generated World trait. It is the business logic
+/// and is used to start the server.
 #[derive(Clone)]
 struct HelloServer;
 
-impl Service for HelloServer {
+impl World for HelloServer {
     // Each defined rpc generates two items in the trait, a fn that serves the RPC, and
     // an associated type representing the future output by the fn.
 
@@ -47,48 +38,42 @@ impl Service for HelloServer {
     }
 }
 
-async fn run() -> io::Result<()> {
-    // bincode_transport is provided by the associated crate bincode-transport. It makes it easy
-    // to start up a serde-powered bincode serialization strategy over TCP.
-    let transport = bincode_transport::listen(&"0.0.0.0:0".parse().unwrap())?;
+#[tokio::main]
+async fn main() -> io::Result<()> {
+    // tarpc_json_transport is provided by the associated crate json_transport. It makes it
+    // easy to start up a serde-powered JSON serialization strategy over TCP.
+    let mut transport = tarpc::serde_transport::tcp::listen("localhost:0", Json::default).await?;
     let addr = transport.local_addr();
 
-    // The server is configured with the defaults.
-    let server = Server::default()
-        // Server can listen on any type that implements the Transport trait.
-        .incoming(transport)
-        // Close the stream after the client connects
-        .take(1)
-        // serve is generated by the tarpc::service! macro. It takes as input any type implementing
-        // the generated Service trait.
-        .respond_with(serve(HelloServer));
+    let server = async move {
+        // For this example, we're just going to wait for one connection.
+        let client = transport.next().await.unwrap().unwrap();
 
-    tokio_executor::spawn(server.unit_error().boxed().compat());
+        // `Channel` is a trait representing a server-side connection. It is a trait to allow
+        // for some channels to be instrumented: for example, to track the number of open connections.
+        // BaseChannel is the most basic channel, simply wrapping a transport with no added
+        // functionality.
+        BaseChannel::with_defaults(client)
+            // serve_world is generated by the tarpc::service attribute. It takes as input any type
+            // implementing the generated World trait.
+            .respond_with(HelloServer.serve())
+            .execute()
+            .await;
+    };
+    tokio::spawn(server);
 
-    let transport = await!(bincode_transport::connect(&addr))?;
+    let transport = tarpc::serde_transport::tcp::connect(addr, Json::default()).await?;
 
-    // new_stub is generated by the tarpc::service! macro. Like Server, it takes a config and any
-    // Transport as input, and returns a Client, also generated by the macro.
-    // by the service mcro.
-    let mut client = await!(new_stub(client::Config::default(), transport))?;
+    // WorldClient is generated by the tarpc::service attribute. It has a constructor `new` that
+    // takes a config and any Transport as input.
+    let mut client = WorldClient::new(client::Config::default(), transport).spawn()?;
 
-    // The client has an RPC method for each RPC defined in tarpc::service!. It takes the same args
-    // as defined, with the addition of a Context, which is always the first arg. The Context
+    // The client has an RPC method for each RPC defined in the annotated trait. It takes the same
+    // args as defined, with the addition of a Context, which is always the first arg. The Context
     // specifies a deadline and trace information which can be helpful in debugging requests.
-    let hello = await!(client.hello(context::current(), "Stim".to_string()))?;
+    let hello = client.hello(context::current(), "Stim".to_string()).await?;
 
-    println!("{}", hello);
+    eprintln!("{}", hello);
 
     Ok(())
 }
-
-fn main() {
-    tarpc::init(TokioDefaultSpawner);
-
-    tokio::run(
-        run()
-            .map_err(|e| eprintln!("Oh no: {}", e))
-            .boxed()
-            .compat(),
-    );
-}

tarpc/examples/server_calling_server.rs

@@ -4,39 +4,31 @@
 // license that can be found in the LICENSE file or at
 // https://opensource.org/licenses/MIT.
 
-#![feature(
-    existential_type,
-    arbitrary_self_types,
-    pin,
-    futures_api,
-    await_macro,
-    async_await,
-    proc_macro_hygiene
-)]
-
-use crate::{add::Service as AddService, double::Service as DoubleService};
+use crate::{add::Add as AddService, double::Double as DoubleService};
 use futures::{
-    compat::TokioDefaultSpawner,
     future::{self, Ready},
     prelude::*,
 };
-use rpc::{
+use std::{io, pin::Pin};
+use tarpc::{
     client, context,
     server::{Handler, Server},
 };
-use std::io;
+use tokio_serde::formats::Json;
 
 pub mod add {
-    tarpc::service! {
+    #[tarpc::service]
+    pub trait Add {
         /// Add two ints together.
-        rpc add(x: i32, y: i32) -> i32;
+        async fn add(x: i32, y: i32) -> i32;
     }
 }
 
 pub mod double {
-    tarpc::service! {
+    #[tarpc::service]
+    pub trait Double {
         /// 2 * x
-        rpc double(x: i32) -> Result<i32, String>;
+        async fn double(x: i32) -> Result<i32, String>;
     }
 }
 
@@ -53,56 +45,57 @@ impl AddService for AddServer {
 
 #[derive(Clone)]
 struct DoubleServer {
-    add_client: add::Client,
+    add_client: add::AddClient,
 }
 
 impl DoubleService for DoubleServer {
-    existential type DoubleFut: Future<Output = Result<i32, String>> + Send;
+    type DoubleFut = Pin<Box<dyn Future<Output = Result<i32, String>> + Send>>;
 
     fn double(self, _: context::Context, x: i32) -> Self::DoubleFut {
-        async fn double(mut client: add::Client, x: i32) -> Result<i32, String> {
-            let result = await!(client.add(context::current(), x, x));
-            result.map_err(|e| e.to_string())
+        async fn double(mut client: add::AddClient, x: i32) -> Result<i32, String> {
+            client
+                .add(context::current(), x, x)
+                .await
+                .map_err(|e| e.to_string())
         }
 
-        double(self.add_client.clone(), x)
+        double(self.add_client.clone(), x).boxed()
     }
 }
 
-async fn run() -> io::Result<()> {
-    let add_listener = bincode_transport::listen(&"0.0.0.0:0".parse().unwrap())?;
-    let addr = add_listener.local_addr();
+#[tokio::main]
+async fn main() -> io::Result<()> {
+    env_logger::init();
+
+    let add_listener = tarpc::serde_transport::tcp::listen("localhost:0", Json::default)
+        .await?
+        .filter_map(|r| future::ready(r.ok()));
+    let addr = add_listener.get_ref().local_addr();
     let add_server = Server::default()
         .incoming(add_listener)
         .take(1)
-        .respond_with(add::serve(AddServer));
-    tokio_executor::spawn(add_server.unit_error().boxed().compat());
+        .respond_with(AddServer.serve());
+    tokio::spawn(add_server);
 
-    let to_add_server = await!(bincode_transport::connect(&addr))?;
-    let add_client = await!(add::new_stub(client::Config::default(), to_add_server))?;
+    let to_add_server = tarpc::serde_transport::tcp::connect(addr, Json::default()).await?;
+    let add_client = add::AddClient::new(client::Config::default(), to_add_server).spawn()?;
 
-    let double_listener = bincode_transport::listen(&"0.0.0.0:0".parse().unwrap())?;
-    let addr = double_listener.local_addr();
-    let double_server = rpc::Server::default()
+    let double_listener = tarpc::serde_transport::tcp::listen("localhost:0", Json::default)
+        .await?
+        .filter_map(|r| future::ready(r.ok()));
+    let addr = double_listener.get_ref().local_addr();
+    let double_server = tarpc::Server::default()
         .incoming(double_listener)
         .take(1)
-        .respond_with(double::serve(DoubleServer { add_client }));
-    tokio_executor::spawn(double_server.unit_error().boxed().compat());
+        .respond_with(DoubleServer { add_client }.serve());
+    tokio::spawn(double_server);
 
-    let to_double_server = await!(bincode_transport::connect(&addr))?;
-    let mut double_client = await!(double::new_stub(
-        client::Config::default(),
-        to_double_server
-    ))?;
+    let to_double_server = tarpc::serde_transport::tcp::connect(addr, Json::default()).await?;
+    let mut double_client =
+        double::DoubleClient::new(client::Config::default(), to_double_server).spawn()?;
 
     for i in 1..=5 {
-        println!("{:?}", await!(double_client.double(context::current(), i))?);
+        eprintln!("{:?}", double_client.double(context::current(), i).await?);
     }
     Ok(())
 }
-
-fn main() {
-    env_logger::init();
-    tarpc::init(TokioDefaultSpawner);
-    tokio::run(run().map_err(|e| panic!(e)).boxed().compat());
-}

tarpc/examples/service_registry.rs

@@ -1,411 +0,0 @@
-#![feature(
-    pin,
-    async_await,
-    await_macro,
-    futures_api,
-    arbitrary_self_types,
-    proc_macro_hygiene,
-    impl_trait_in_bindings
-)]
-
-mod registry {
-    use bytes::Bytes;
-    use futures::{
-        future::{ready, Ready},
-        prelude::*,
-    };
-    use serde::{Deserialize, Serialize};
-    use std::{
-        io,
-        pin::Pin,
-        sync::Arc,
-        task::{LocalWaker, Poll},
-    };
-    use tarpc::{
-        client::{self, Client},
-        context,
-    };
-
-    /// A request to a named service.
-    #[derive(Serialize, Deserialize)]
-    pub struct ServiceRequest {
-        service_name: String,
-        request: Bytes,
-    }
-
-    /// A response from a named service.
-    #[derive(Serialize, Deserialize)]
-    pub struct ServiceResponse {
-        response: Bytes,
-    }
-
-    /// A list of registered services.
-    pub struct Registry<Services> {
-        registrations: Services,
-    }
-
-    impl Default for Registry<Nil> {
-        fn default() -> Self {
-            Registry { registrations: Nil }
-        }
-    }
-
-    impl<Services: MaybeServe + Sync> Registry<Services> {
-        /// Returns a function that serves requests for the registered services.
-        pub fn serve(
-            self,
-        ) -> impl FnOnce(context::Context, ServiceRequest)
-            -> Either<Services::Future, Ready<io::Result<ServiceResponse>>>
-                         + Clone {
-            let registrations = Arc::new(self.registrations);
-            move |cx, req: ServiceRequest| match registrations.serve(cx, &req) {
-                Some(serve) => Either::Left(serve),
-                None => Either::Right(ready(Err(io::Error::new(
-                    io::ErrorKind::NotFound,
-                    format!("Service '{}' not registered", req.service_name),
-                )))),
-            }
-        }
-
-        /// Registers `serve` with the given `name` using the given serialization scheme.
-        pub fn register<S, Req, Resp, RespFut, Ser, De>(
-            self,
-            name: String,
-            serve: S,
-            deserialize: De,
-            serialize: Ser,
-        ) -> Registry<Registration<impl Serve + Send + 'static, Services>>
-        where
-            Req: Send,
-            S: FnOnce(context::Context, Req) -> RespFut + Send + 'static + Clone,
-            RespFut: Future<Output = io::Result<Resp>> + Send + 'static,
-            De: FnOnce(Bytes) -> io::Result<Req> + Send + 'static + Clone,
-            Ser: FnOnce(Resp) -> io::Result<Bytes> + Send + 'static + Clone,
-        {
-            let registrations = Registration {
-                name: name,
-                serve: move |cx, req: Bytes| {
-                    async move {
-                        let req = deserialize.clone()(req)?;
-                        let response = await!(serve.clone()(cx, req))?;
-                        let response = serialize.clone()(response)?;
-                        Ok(ServiceResponse { response })
-                    }
-                },
-                rest: self.registrations,
-            };
-            Registry { registrations }
-        }
-    }
-
-    /// Creates a client that sends requests to a service
-    /// named `service_name`, over the given channel, using
-    /// the specified serialization scheme.
-    pub fn new_client<Req, Resp, Ser, De>(
-        service_name: String,
-        channel: &client::Channel<ServiceRequest, ServiceResponse>,
-        mut serialize: Ser,
-        mut deserialize: De,
-    ) -> client::MapResponse<
-        client::WithRequest<
-            client::Channel<ServiceRequest, ServiceResponse>,
-            impl FnMut(Req) -> ServiceRequest,
-        >,
-        impl FnMut(ServiceResponse) -> Resp,
-    >
-    where
-        Req: Send + 'static,
-        Resp: Send + 'static,
-        De: FnMut(Bytes) -> io::Result<Resp> + Clone + Send + 'static,
-        Ser: FnMut(Req) -> io::Result<Bytes> + Clone + Send + 'static,
-    {
-        channel
-            .clone()
-            .with_request(move |req| {
-                ServiceRequest {
-                    service_name: service_name.clone(),
-                    // TODO: shouldn't need to unwrap here. Maybe with_request should allow for
-                    // returning Result.
-                    request: serialize(req).unwrap(),
-                }
-            })
-            // TODO: same thing. Maybe this should be more like and_then rather than map.
-            .map_response(move |resp| deserialize(resp.response).unwrap())
-    }
-
-    /// Serves a request.
-    ///
-    /// This trait is mostly an implementation detail that isn't used outside of the registry
-    /// internals.
-    pub trait Serve: Clone + Send + 'static {
-        type Response: Future<Output = io::Result<ServiceResponse>> + Send + 'static;
-        fn serve(self, cx: context::Context, request: Bytes) -> Self::Response;
-    }
-
-    /// Serves a request if the request is for a registered service.
-    ///
-    /// This trait is mostly an implementation detail that isn't used outside of the registry
-    /// internals.
-    pub trait MaybeServe: Send + 'static {
-        type Future: Future<Output = io::Result<ServiceResponse>> + Send + 'static;
-
-        fn serve(&self, cx: context::Context, request: &ServiceRequest) -> Option<Self::Future>;
-    }
-
-    /// A registry starting with service S, followed by Rest.
-    ///
-    /// This type is mostly an implementation detail that is not used directly
-    /// outside of the registry internals.
-    pub struct Registration<S, Rest> {
-        /// The registered service's name. Must be unique across all registered services.
-        name: String,
-        /// The registered service.
-        serve: S,
-        /// Any remaining registered services.
-        rest: Rest,
-    }
-
-    /// An empty registry.
-    ///
-    /// This type is mostly an implementation detail that is not used directly
-    /// outside of the registry internals.
-    pub struct Nil;
-
-    impl MaybeServe for Nil {
-        type Future = futures::future::Ready<io::Result<ServiceResponse>>;
-
-        fn serve(&self, _: context::Context, _: &ServiceRequest) -> Option<Self::Future> {
-            None
-        }
-    }
-
-    impl<S, Rest> MaybeServe for Registration<S, Rest>
-    where
-        S: Serve,
-        Rest: MaybeServe,
-    {
-        type Future = Either<S::Response, Rest::Future>;
-
-        fn serve(&self, cx: context::Context, request: &ServiceRequest) -> Option<Self::Future> {
-            if self.name == request.service_name {
-                Some(Either::Left(
-                    self.serve.clone().serve(cx, request.request.clone()),
-                ))
-            } else {
-                self.rest.serve(cx, request).map(Either::Right)
-            }
-        }
-    }
-
-    /// Wraps either of two future types that both resolve to the same output type.
-    #[derive(Debug)]
-    #[must_use = "futures do nothing unless polled"]
-    pub enum Either<Left, Right> {
-        Left(Left),
-        Right(Right),
-    }
-
-    impl<Output, Left, Right> Future for Either<Left, Right>
-    where
-        Left: Future<Output = Output>,
-        Right: Future<Output = Output>,
-    {
-        type Output = Output;
-
-        fn poll(self: Pin<&mut Self>, waker: &LocalWaker) -> Poll<Output> {
-            unsafe {
-                match Pin::get_mut_unchecked(self) {
-                    Either::Left(car) => Pin::new_unchecked(car).poll(waker),
-                    Either::Right(cdr) => Pin::new_unchecked(cdr).poll(waker),
-                }
-            }
-        }
-    }
-
-    impl<Resp, F> Serve for F
-    where
-        F: FnOnce(context::Context, Bytes) -> Resp + Clone + Send + 'static,
-        Resp: Future<Output = io::Result<ServiceResponse>> + Send + 'static,
-    {
-        type Response = Resp;
-
-        fn serve(self, cx: context::Context, request: Bytes) -> Resp {
-            self(cx, request)
-        }
-    }
-}
-
-// Example
-use bytes::Bytes;
-use futures::{
-    future::{ready, Ready},
-    prelude::*,
-};
-use serde::{Deserialize, Serialize};
-use std::{
-    collections::HashMap,
-    io,
-    sync::{Arc, RwLock},
-};
-use tarpc::{client, context, server::Handler};
-
-fn deserialize<Req>(req: Bytes) -> io::Result<Req>
-where
-    Req: for<'a> Deserialize<'a> + Send,
-{
-    bincode::deserialize(req.as_ref()).map_err(|e| io::Error::new(io::ErrorKind::Other, e))
-}
-
-fn serialize<Resp>(resp: Resp) -> io::Result<Bytes>
-where
-    Resp: Serialize,
-{
-    Ok(bincode::serialize(&resp)
-        .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?
-        .into())
-}
-
-mod write_service {
-    tarpc::service! {
-        rpc write(key: String, value: String);
-    }
-}
-
-mod read_service {
-    tarpc::service! {
-        rpc read(key: String) -> Option<String>;
-    }
-}
-
-#[derive(Debug, Default, Clone)]
-struct Server {
-    data: Arc<RwLock<HashMap<String, String>>>,
-}
-
-impl write_service::Service for Server {
-    type WriteFut = Ready<()>;
-
-    fn write(self, _: context::Context, key: String, value: String) -> Self::WriteFut {
-        self.data.write().unwrap().insert(key, value);
-        ready(())
-    }
-}
-
-impl read_service::Service for Server {
-    type ReadFut = Ready<Option<String>>;
-
-    fn read(self, _: context::Context, key: String) -> Self::ReadFut {
-        ready(self.data.read().unwrap().get(&key).cloned())
-    }
-}
-
-trait DefaultSpawn {
-    fn spawn(self);
-}
-
-impl<F> DefaultSpawn for F
-where
-    F: Future<Output = ()> + Send + 'static,
-{
-    fn spawn(self) {
-        tokio_executor::spawn(self.unit_error().boxed().compat())
-    }
-}
-
-struct BincodeRegistry<Services> {
-    registry: registry::Registry<Services>,
-}
-
-impl Default for BincodeRegistry<registry::Nil> {
-    fn default() -> Self {
-        BincodeRegistry {
-            registry: registry::Registry::default(),
-        }
-    }
-}
-
-impl<Services: registry::MaybeServe + Sync> BincodeRegistry<Services> {
-    fn serve(
-        self,
-    ) -> impl FnOnce(
-        context::Context, registry::ServiceRequest
-    ) -> registry::Either<
-        Services::Future,
-        Ready<io::Result<registry::ServiceResponse>>,
-    > + Clone {
-        self.registry.serve()
-    }
-
-    fn register<S, Req, Resp, RespFut>(
-        self,
-        name: String,
-        serve: S,
-    ) -> BincodeRegistry<registry::Registration<impl registry::Serve + Send + 'static, Services>>
-    where
-        Req: for<'a> Deserialize<'a> + Send + 'static,
-        Resp: Serialize + 'static,
-        S: FnOnce(context::Context, Req) -> RespFut + Send + 'static + Clone,
-        RespFut: Future<Output = io::Result<Resp>> + Send + 'static,
-    {
-        let registry = self.registry.register(name, serve, deserialize, serialize);
-        BincodeRegistry { registry }
-    }
-}
-
-pub fn new_client<Req, Resp>(
-    service_name: String,
-    channel: &client::Channel<registry::ServiceRequest, registry::ServiceResponse>,
-) -> client::MapResponse<
-    client::WithRequest<
-        client::Channel<registry::ServiceRequest, registry::ServiceResponse>,
-        impl FnMut(Req) -> registry::ServiceRequest,
-    >,
-    impl FnMut(registry::ServiceResponse) -> Resp,
->
-where
-    Req: Serialize + Send + 'static,
-    Resp: for<'a> Deserialize<'a> + Send + 'static,
-{
-    registry::new_client(service_name, channel, serialize, deserialize)
-}
-
-async fn run() -> io::Result<()> {
-    let server = Server::default();
-    let registry = BincodeRegistry::default()
-        .register(
-            "WriteService".to_string(),
-            write_service::serve(server.clone()),
-        )
-        .register(
-            "ReadService".to_string(),
-            read_service::serve(server.clone()),
-        );
-
-    let listener = bincode_transport::listen(&"0.0.0.0:0".parse().unwrap())?;
-    let server_addr = listener.local_addr();
-    let server = tarpc::Server::default()
-        .incoming(listener)
-        .take(1)
-        .respond_with(registry.serve());
-    tokio_executor::spawn(server.unit_error().boxed().compat());
-
-    let transport = await!(bincode_transport::connect(&server_addr))?;
-    let channel = await!(client::new(client::Config::default(), transport))?;
-
-    let write_client = new_client("WriteService".to_string(), &channel);
-    let mut write_client = write_service::Client::from(write_client);
-
-    let read_client = new_client("ReadService".to_string(), &channel);
-    let mut read_client = read_service::Client::from(read_client);
-
-    await!(write_client.write(context::current(), "key".to_string(), "val".to_string()))?;
-    let val = await!(read_client.read(context::current(), "key".to_string()))?;
-    println!("{:?}", val);
-
-    Ok(())
-}
-
-fn main() {
-    tarpc::init(futures::compat::TokioDefaultSpawner);
-    tokio::run(run().boxed().map_err(|e| panic!(e)).boxed().compat());
-}

tarpc/src/lib.rs

@@ -4,10 +4,6 @@
 // license that can be found in the LICENSE file or at
 // https://opensource.org/licenses/MIT.
 
-//! ## tarpc: Tim & Adam's RPC lib
-//! [![Travis-CI Status](https://travis-ci.org/google/tarpc.png?branch=master)](https://travis-ci.org/google/tarpc)
-//! [![Coverage Status](https://coveralls.io/repos/github/google/tarpc/badge.svg?branch=master)](https://coveralls.io/github/google/tarpc?branch=master)
-//! [![Software License](https://img.shields.io/badge/license-MIT-brightgreen.svg)](LICENSE)
 //! [![Latest Version](https://img.shields.io/crates/v/tarpc.svg)](https://crates.io/crates/tarpc)
 //! [![Join the chat at https://gitter.im/tarpc/Lobby](https://badges.gitter.im/tarpc/Lobby.svg)](https://gitter.im/tarpc/Lobby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 //!
@@ -32,34 +28,55 @@
 //!
 //! tarpc differentiates itself from other RPC frameworks by defining the schema in code,
 //! rather than in a separate language such as .proto. This means there's no separate compilation
-//! process, and no cognitive context switching between different languages. Additionally, it
-//! works with the community-backed library serde: any serde-serializable type can be used as
-//! arguments to tarpc fns.
+//! process, and no context switching between different languages.
+//!
+//! Some other features of tarpc:
+//! - Pluggable transport: any type impling `Stream<Item = Request> + Sink<Response>` can be
+//!   used as a transport to connect the client and server.
+//! - `Send + 'static` optional: if the transport doesn't require it, neither does tarpc!
+//! - Cascading cancellation: dropping a request will send a cancellation message to the server.
+//!   The server will cease any unfinished work on the request, subsequently cancelling any of its
+//!   own requests, repeating for the entire chain of transitive dependencies.
+//! - Configurable deadlines and deadline propagation: request deadlines default to 10s if
+//!   unspecified. The server will automatically cease work when the deadline has passed. Any
+//!   requests sent by the server that use the request context will propagate the request deadline.
+//!   For example, if a server is handling a request with a 10s deadline, does 2s of work, then
+//!   sends a request to another server, that server will see an 8s deadline.
+//! - Serde serialization: enabling the `serde1` Cargo feature will make service requests and
+//!   responses `Serialize + Deserialize`. It's entirely optional, though: in-memory transports can
+//!   be used, as well, so the price of serialization doesn't have to be paid when it's not needed.
 //!
 //! ## Usage
 //! Add to your `Cargo.toml` dependencies:
 //!
 //! ```toml
-//! tarpc = "0.14.0"
+//! tarpc = "0.20.0"
 //! ```
 //!
-//! The `service!` macro expands to a collection of items that form an
-//! rpc service. In the above example, the macro is called within the
-//! `hello_service` module. This module will contain a `Client` stub and `Service` trait.  There is
-//! These generated types make it easy and ergonomic to write servers without dealing with serialization
-//! directly. Simply implement one of the generated traits, and you're off to the
-//! races!
+//! The `tarpc::service` attribute expands to a collection of items that form an rpc service.
+//! These generated types make it easy and ergonomic to write servers with less boilerplate.
+//! Simply implement the generated service trait, and you're off to the races!
 //!
 //! ## Example
 //!
-//! Here's a small service.
+//! For this example, in addition to tarpc, also add two other dependencies to
+//! your `Cargo.toml`:
+//!
+//! ```toml
+//! futures = "0.3"
+//! tokio = "0.2"
+//! ```
+//!
+//! In the following example, we use an in-process channel for communication between
+//! client and server. In real code, you will likely communicate over the network.
+//! For a more real-world example, see [example-service](example-service).
+//!
+//! First, let's set up the dependencies and service definition.
 //!
 //! ```rust
-//! #![feature(futures_api, pin, arbitrary_self_types, await_macro, async_await, proc_macro_hygiene)]
-//!
+//! # extern crate futures;
 //!
 //! use futures::{
-//!     compat::TokioDefaultSpawner,
 //!     future::{self, Ready},
 //!     prelude::*,
 //! };
@@ -71,17 +88,40 @@
 //!
 //! // This is the service definition. It looks a lot like a trait definition.
 //! // It defines one RPC, hello, which takes one arg, name, and returns a String.
-//! tarpc::service! {
+//! #[tarpc::service]
+//! trait World {
 //!     /// Returns a greeting for name.
-//!     rpc hello(name: String) -> String;
+//!     async fn hello(name: String) -> String;
 //! }
+//! ```
 //!
-//! // This is the type that implements the generated Service trait. It is the business logic
+//! This service definition generates a trait called `World`. Next we need to
+//! implement it for our Server struct.
+//!
+//! ```rust
+//! # extern crate futures;
+//! # use futures::{
+//! #     future::{self, Ready},
+//! #     prelude::*,
+//! # };
+//! # use tarpc::{
+//! #     client, context,
+//! #     server::{self, Handler},
+//! # };
+//! # use std::io;
+//! # // This is the service definition. It looks a lot like a trait definition.
+//! # // It defines one RPC, hello, which takes one arg, name, and returns a String.
+//! # #[tarpc::service]
+//! # trait World {
+//! #     /// Returns a greeting for name.
+//! #     async fn hello(name: String) -> String;
+//! # }
+//! // This is the type that implements the generated World trait. It is the business logic
 //! // and is used to start the server.
 //! #[derive(Clone)]
 //! struct HelloServer;
 //!
-//! impl Service for HelloServer {
+//! impl World for HelloServer {
 //!     // Each defined rpc generates two items in the trait, a fn that serves the RPC, and
 //!     // an associated type representing the future output by the fn.
 //!
@@ -91,79 +131,106 @@
 //!         future::ready(format!("Hello, {}!", name))
 //!     }
 //! }
+//! ```
 //!
-//! async fn run() -> io::Result<()> {
-//!     // bincode_transport is provided by the associated crate bincode-transport. It makes it easy
-//!     // to start up a serde-powered bincode serialization strategy over TCP.
-//!     let transport = bincode_transport::listen(&"0.0.0.0:0".parse().unwrap())?;
-//!     let addr = transport.local_addr();
+//! Lastly let's write our `main` that will start the server. While this example uses an
+//! [in-process channel](rpc::transport::channel), tarpc also ships a generic [`serde_transport`]
+//! behind the `serde-transport` feature, with additional [TCP](serde_transport::tcp) functionality
+//! available behind the `tcp` feature.
+//!
+//! ```rust
+//! # extern crate futures;
+//! # use futures::{
+//! #     future::{self, Ready},
+//! #     prelude::*,
+//! # };
+//! # use tarpc::{
+//! #     client, context,
+//! #     server::{self, Handler},
+//! # };
+//! # use std::io;
+//! # // This is the service definition. It looks a lot like a trait definition.
+//! # // It defines one RPC, hello, which takes one arg, name, and returns a String.
+//! # #[tarpc::service]
+//! # trait World {
+//! #     /// Returns a greeting for name.
+//! #     async fn hello(name: String) -> String;
+//! # }
+//! # // This is the type that implements the generated World trait. It is the business logic
+//! # // and is used to start the server.
+//! # #[derive(Clone)]
+//! # struct HelloServer;
+//! # impl World for HelloServer {
+//! #     // Each defined rpc generates two items in the trait, a fn that serves the RPC, and
+//! #     // an associated type representing the future output by the fn.
+//! #     type HelloFut = Ready<String>;
+//! #     fn hello(self, _: context::Context, name: String) -> Self::HelloFut {
+//! #         future::ready(format!("Hello, {}!", name))
+//! #     }
+//! # }
+//! #[tokio::main]
+//! async fn main() -> io::Result<()> {
+//!     let (client_transport, server_transport) = tarpc::transport::channel::unbounded();
 //!
-//!     // The server is configured with the defaults.
 //!     let server = server::new(server::Config::default())
-//!         // Server can listen on any type that implements the Transport trait.
-//!         .incoming(transport)
-//!         // Close the stream after the client connects
-//!         .take(1)
-//!         // serve is generated by the service! macro. It takes as input any type implementing
-//!         // the generated Service trait.
-//!         .respond_with(serve(HelloServer));
+//!         // incoming() takes a stream of transports such as would be returned by
+//!         // TcpListener::incoming (but a stream instead of an iterator).
+//!         .incoming(stream::once(future::ready(server_transport)))
+//!         .respond_with(HelloServer.serve());
 //!
-//!     tokio_executor::spawn(server.unit_error().boxed().compat());
+//!     tokio::spawn(server);
 //!
-//!     let transport = await!(bincode_transport::connect(&addr))?;
+//!     // WorldClient is generated by the macro. It has a constructor `new` that takes a config and
+//!     // any Transport as input
+//!     let mut client = WorldClient::new(client::Config::default(), client_transport).spawn()?;
 //!
-//!     // new_stub is generated by the service! macro. Like Server, it takes a config and any
-//!     // Transport as input, and returns a Client, also generated by the macro.
-//!     // by the service mcro.
-//!     let mut client = await!(new_stub(client::Config::default(), transport))?;
-//!
-//!     // The client has an RPC method for each RPC defined in service!. It takes the same args
-//!     // as defined, with the addition of a Context, which is always the first arg. The Context
+//!     // The client has an RPC method for each RPC defined in the annotated trait. It takes the same
+//!     // args as defined, with the addition of a Context, which is always the first arg. The Context
 //!     // specifies a deadline and trace information which can be helpful in debugging requests.
-//!     let hello = await!(client.hello(context::current(), "Stim".to_string()))?;
+//!     let hello = client.hello(context::current(), "Stim".to_string()).await?;
 //!
 //!     println!("{}", hello);
 //!
 //!     Ok(())
 //! }
-//!
-//! fn main() {
-//!     tarpc::init(TokioDefaultSpawner);
-//!     tokio::run(run()
-//!             .map_err(|e| eprintln!("Oh no: {}", e))
-//!             .boxed()
-//!             .compat(),
-//!     );
-//! }
 //! ```
 //!
 //! ## Service Documentation
 //!
 //! Use `cargo doc` as you normally would to see the documentation created for all
 //! items expanded by a `service!` invocation.
+#![deny(missing_docs)]
+#![allow(clippy::type_complexity)]
 
-#![deny(missing_docs, missing_debug_implementations)]
-#![feature(async_await)]
-#![cfg_attr(
-    test,
-    feature(
-        pin,
-        futures_api,
-        await_macro,
-        proc_macro_hygiene,
-        arbitrary_self_types
-    )
-)]
-
-#[doc(hidden)]
-pub use futures;
+pub mod rpc;
 pub use rpc::*;
-#[cfg(feature = "serde")]
-#[doc(hidden)]
-pub use serde;
-#[doc(hidden)]
-pub use tarpc_plugins::*;
 
-/// Provides the macro used for constructing rpc services and client stubs.
-#[macro_use]
-mod macros;
+#[cfg(feature = "serde-transport")]
+pub mod serde_transport;
+
+pub mod trace;
+
+/// The main macro that creates RPC services.
+///
+/// Rpc methods are specified, mirroring trait syntax:
+///
+/// ```
+/// # fn main() {}
+/// #[tarpc::service]
+/// trait Service {
+/// /// Say hello
+/// async fn hello(name: String) -> String;
+/// }
+/// ```
+///
+/// Attributes can be attached to each rpc. These attributes
+/// will then be attached to the generated service traits'
+/// corresponding `fn`s, as well as to the client stubs' RPCs.
+///
+/// The following items are expanded in the enclosing module:
+///
+/// * `trait Service` -- defines the RPC service.
+///   * `fn serve` -- turns a service impl into a request handler.
+/// * `Client` -- a client stub with a fn for each RPC.
+///   * `fn new_stub` -- creates a new Client stub.
+pub use tarpc_plugins::service;

tarpc/src/macros.rs

@@ -1,377 +0,0 @@
-// Copyright 2018 Google LLC
-//
-// Use of this source code is governed by an MIT-style
-// license that can be found in the LICENSE file or at
-// https://opensource.org/licenses/MIT.
-
-#[cfg(feature = "serde")]
-#[doc(hidden)]
-#[macro_export]
-macro_rules! add_serde_if_enabled {
-    ($(#[$attr:meta])* -- $i:item) => {
-        $(#[$attr])*
-        #[derive($crate::serde::Serialize, $crate::serde::Deserialize)]
-        $i
-    }
-}
-
-#[cfg(not(feature = "serde"))]
-#[doc(hidden)]
-#[macro_export]
-macro_rules! add_serde_if_enabled {
-    ($(#[$attr:meta])* -- $i:item) => {
-        $(#[$attr])*
-        $i
-    }
-}
-
-/// The main macro that creates RPC services.
-///
-/// Rpc methods are specified, mirroring trait syntax:
-///
-/// ```
-/// # #![feature(await_macro, pin, arbitrary_self_types, async_await, futures_api, proc_macro_hygiene)]
-/// # fn main() {}
-/// # tarpc::service! {
-/// /// Say hello
-/// rpc hello(name: String) -> String;
-/// # }
-/// ```
-///
-/// Attributes can be attached to each rpc. These attributes
-/// will then be attached to the generated service traits'
-/// corresponding `fn`s, as well as to the client stubs' RPCs.
-///
-/// The following items are expanded in the enclosing module:
-///
-/// * `trait Service` -- defines the RPC service.
-///   * `fn serve` -- turns a service impl into a request handler.
-/// * `Client` -- a client stub with a fn for each RPC.
-///   * `fn new_stub` -- creates a new Client stub.
-///
-#[macro_export]
-macro_rules! service {
-    () => {
-        compile_error!("Must define at least one RPC method.");
-    };
-// Entry point
-    (
-        $(
-            $(#[$attr:meta])*
-            rpc $fn_name:ident( $( $arg:ident : $in_:ty ),* ) $(-> $out:ty)*;
-        )*
-    ) => {
-        $crate::service! {{
-            $(
-                $(#[$attr])*
-                rpc $fn_name( $( $arg : $in_ ),* ) $(-> $out)*;
-            )*
-        }}
-    };
-// Pattern for when the next rpc has an implicit unit return type.
-    (
-        {
-            $(#[$attr:meta])*
-            rpc $fn_name:ident( $( $arg:ident : $in_:ty ),* );
-
-            $( $unexpanded:tt )*
-        }
-        $( $expanded:tt )*
-    ) => {
-        $crate::service! {
-            { $( $unexpanded )* }
-
-            $( $expanded )*
-
-            $(#[$attr])*
-            rpc $fn_name( $( $arg : $in_ ),* ) -> ();
-        }
-    };
-// Pattern for when the next rpc has an explicit return type.
-    (
-        {
-            $(#[$attr:meta])*
-            rpc $fn_name:ident( $( $arg:ident : $in_:ty ),* ) -> $out:ty;
-
-            $( $unexpanded:tt )*
-        }
-        $( $expanded:tt )*
-    ) => {
-        $crate::service! {
-            { $( $unexpanded )* }
-
-            $( $expanded )*
-
-            $(#[$attr])*
-            rpc $fn_name( $( $arg : $in_ ),* ) -> $out;
-        }
-    };
-// Pattern for when all return types have been expanded
-    (
-        { } // none left to expand
-        $(
-            $(#[$attr:meta])*
-            rpc $fn_name:ident ( $( $arg:ident : $in_:ty ),* ) -> $out:ty;
-        )*
-    ) => {
-        $crate::add_serde_if_enabled! {
-            /// The request sent over the wire from the client to the server.
-            #[derive(Debug)]
-            #[allow(non_camel_case_types, unused)]
-            --
-            pub enum Request {
-                $(
-                    $(#[$attr])*
-                    $fn_name{ $($arg: $in_,)* }
-                ),*
-            }
-        }
-
-        $crate::add_serde_if_enabled! {
-            /// The response sent over the wire from the server to the client.
-            #[derive(Debug)]
-            #[allow(non_camel_case_types, unused)]
-            --
-            pub enum Response {
-                $(
-                    $(#[$attr])*
-                    $fn_name($out)
-                ),*
-            }
-        }
-
-        // TODO: proc_macro can't currently parse $crate, so this needs to be imported for the
-        // usage of snake_to_camel! to work.
-        use $crate::futures::Future as Future__;
-
-        /// Defines the RPC service. The additional trait bounds are required so that services can
-        /// multiplex requests across multiple tasks, potentially on multiple threads.
-        pub trait Service: Clone + Send + 'static {
-            $(
-                $crate::snake_to_camel! {
-                    /// The type of future returned by `{}`.
-                    type $fn_name: Future__<Output = $out> + Send;
-                }
-
-                $(#[$attr])*
-                fn $fn_name(self, ctx: $crate::context::Context, $($arg:$in_),*) -> $crate::ty_snake_to_camel!(Self::$fn_name);
-            )*
-        }
-
-        // TODO: use an existential type instead of this when existential types work.
-        /// A future resolving to a server [`Response`].
-        #[allow(non_camel_case_types)]
-        pub enum ResponseFut<S: Service> {
-            $(
-                $(#[$attr])*
-                $fn_name($crate::ty_snake_to_camel!(<S as Service>::$fn_name)),
-            )*
-        }
-
-        impl<S: Service> ::std::fmt::Debug for ResponseFut<S> {
-            fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-                fmt.debug_struct("Response").finish()
-            }
-        }
-
-        impl<S: Service> ::std::future::Future for ResponseFut<S> {
-            type Output = ::std::io::Result<Response>;
-
-            fn poll(self: ::std::pin::Pin<&mut Self>, waker: &::std::task::LocalWaker)
-                -> ::std::task::Poll<::std::io::Result<Response>>
-            {
-                unsafe {
-                    match ::std::pin::Pin::get_mut_unchecked(self) {
-                        $(
-                            ResponseFut::$fn_name(resp) =>
-                                ::std::pin::Pin::new_unchecked(resp)
-                                    .poll(waker)
-                                    .map(Response::$fn_name)
-                                    .map(Ok),
-                        )*
-                    }
-                }
-            }
-        }
-
-        /// Returns a serving function to use with rpc::server::Server.
-        pub fn serve<S: Service>(service: S)
-            -> impl FnOnce($crate::context::Context, Request) -> ResponseFut<S> + Send + 'static + Clone {
-                move |ctx, req| {
-                    match req {
-                        $(
-                            Request::$fn_name{ $($arg,)* } => {
-                                let resp = Service::$fn_name(service.clone(), ctx, $($arg),*);
-                                ResponseFut::$fn_name(resp)
-                            }
-                        )*
-                    }
-                }
-            }
-
-        #[allow(unused)]
-        #[derive(Clone, Debug)]
-        /// The client stub that makes RPC calls to the server. Exposes a Future interface.
-        pub struct Client<C = $crate::client::Channel<Request, Response>>(C);
-
-        /// Returns a new client stub that sends requests over the given transport.
-        pub async fn new_stub<T>(config: $crate::client::Config, transport: T)
-            -> ::std::io::Result<Client>
-        where
-            T: $crate::Transport<
-                    Item = $crate::Response<Response>,
-                    SinkItem = $crate::ClientMessage<Request>> + Send + 'static,
-        {
-            Ok(Client(await!($crate::client::new(config, transport))?))
-        }
-
-        impl<C> From<C> for Client<C>
-            where for <'a> C: $crate::Client<'a, Request, Response = Response>
-        {
-            fn from(client: C) -> Self {
-                Client(client)
-            }
-        }
-
-        impl<C> Client<C>
-            where for<'a> C: $crate::Client<'a, Request, Response = Response>
-        {
-            $(
-                #[allow(unused)]
-                $(#[$attr])*
-                pub fn $fn_name(&mut self, ctx: $crate::context::Context, $($arg: $in_),*)
-                    -> impl ::std::future::Future<Output = ::std::io::Result<$out>> + '_ {
-                    let request__ = Request::$fn_name { $($arg,)* };
-                    let resp = $crate::Client::call(&mut self.0, ctx, request__);
-                    async move {
-                        match await!(resp)? {
-                            Response::$fn_name(msg__) => ::std::result::Result::Ok(msg__),
-                            _ => unreachable!(),
-                        }
-                    }
-                }
-            )*
-        }
-    }
-}
-
-// allow dead code; we're just testing that the macro expansion compiles
-#[allow(dead_code)]
-#[cfg(test)]
-mod syntax_test {
-    service! {
-        #[deny(warnings)]
-        #[allow(non_snake_case)]
-        rpc TestCamelCaseDoesntConflict();
-        rpc hello() -> String;
-        #[doc="attr"]
-        rpc attr(s: String) -> String;
-        rpc no_args_no_return();
-        rpc no_args() -> ();
-        rpc one_arg(foo: String) -> i32;
-        rpc two_args_no_return(bar: String, baz: u64);
-        rpc two_args(bar: String, baz: u64) -> String;
-        rpc no_args_ret_error() -> i32;
-        rpc one_arg_ret_error(foo: String) -> String;
-        rpc no_arg_implicit_return_error();
-        #[doc="attr"]
-        rpc one_arg_implicit_return_error(foo: String);
-    }
-}
-
-#[cfg(test)]
-mod functional_test {
-    use futures::{
-        compat::TokioDefaultSpawner,
-        future::{ready, Ready},
-        prelude::*,
-    };
-    use rpc::{client, context, server::Handler, transport::channel};
-    use std::io;
-    use tokio::runtime::current_thread;
-
-    service! {
-        rpc add(x: i32, y: i32) -> i32;
-        rpc hey(name: String) -> String;
-    }
-
-    #[derive(Clone)]
-    struct Server;
-
-    impl Service for Server {
-        type AddFut = Ready<i32>;
-
-        fn add(self, _: context::Context, x: i32, y: i32) -> Self::AddFut {
-            ready(x + y)
-        }
-
-        type HeyFut = Ready<String>;
-
-        fn hey(self, _: context::Context, name: String) -> Self::HeyFut {
-            ready(format!("Hey, {}.", name))
-        }
-    }
-
-    #[test]
-    fn sequential() {
-        let _ = env_logger::try_init();
-        rpc::init(TokioDefaultSpawner);
-
-        let test = async {
-            let (tx, rx) = channel::unbounded();
-            tokio_executor::spawn(
-                crate::Server::default()
-                    .incoming(stream::once(ready(Ok(rx))))
-                    .respond_with(serve(Server))
-                    .unit_error()
-                    .boxed()
-                    .compat(),
-            );
-
-            let mut client = await!(new_stub(client::Config::default(), tx))?;
-            assert_eq!(3, await!(client.add(context::current(), 1, 2))?);
-            assert_eq!(
-                "Hey, Tim.",
-                await!(client.hey(context::current(), "Tim".to_string()))?
-            );
-            Ok::<_, io::Error>(())
-        }
-            .map_err(|e| panic!(e.to_string()));
-
-        current_thread::block_on_all(test.boxed().compat()).unwrap();
-    }
-
-    #[test]
-    fn concurrent() {
-        let _ = env_logger::try_init();
-        rpc::init(TokioDefaultSpawner);
-
-        let test = async {
-            let (tx, rx) = channel::unbounded();
-            tokio_executor::spawn(
-                rpc::Server::default()
-                    .incoming(stream::once(ready(Ok(rx))))
-                    .respond_with(serve(Server))
-                    .unit_error()
-                    .boxed()
-                    .compat(),
-            );
-
-            let client = await!(new_stub(client::Config::default(), tx))?;
-            let mut c = client.clone();
-            let req1 = c.add(context::current(), 1, 2);
-            let mut c = client.clone();
-            let req2 = c.add(context::current(), 3, 4);
-            let mut c = client.clone();
-            let req3 = c.hey(context::current(), "Tim".to_string());
-
-            assert_eq!(3, await!(req1)?);
-            assert_eq!(7, await!(req2)?);
-            assert_eq!("Hey, Tim.", await!(req3)?);
-            Ok::<_, io::Error>(())
-        }
-            .map_err(|e| panic!("test failed: {}", e));
-
-        current_thread::block_on_all(test.boxed().compat()).unwrap();
-    }
-}

tarpc/src/rpc/client/mod.rs

@@ -6,17 +6,13 @@
 
 //! Provides a client that connects to a server and sends multiplexed requests.
 
-use crate::{context, ClientMessage, Response, Transport};
+use crate::context;
 use futures::prelude::*;
-use log::warn;
-use std::{
-    io,
-    net::{Ipv4Addr, SocketAddr},
-};
+use std::io;
 
 /// Provides a [`Client`] backed by a transport.
 pub mod channel;
-pub use self::channel::Channel;
+pub use channel::{new, Channel};
 
 /// Sends multiplexed requests to, and receives responses from, a server.
 pub trait Client<'a, Req> {
@@ -107,7 +103,6 @@ where
 }
 
 /// Settings that control the behavior of the client.
-#[non_exhaustive]
 #[derive(Clone, Debug)]
 pub struct Config {
     /// The number of requests that can be in flight at once.
@@ -118,6 +113,8 @@ pub struct Config {
     /// `pending_requests_buffer` controls the size of the channel clients use
     /// to communicate with the request dispatch task.
     pub pending_request_buffer: usize,
+    #[doc(hidden)]
+    _non_exhaustive: (),
 }
 
 impl Default for Config {
@@ -125,27 +122,34 @@ impl Default for Config {
         Config {
             max_in_flight_requests: 1_000,
             pending_request_buffer: 100,
+            _non_exhaustive: (),
         }
     }
 }
 
-/// Creates a new Client by wrapping a [`Transport`] and spawning a dispatch task
-/// that manages the lifecycle of requests.
-///
-/// Must only be called from on an executor.
-pub async fn new<Req, Resp, T>(config: Config, transport: T) -> io::Result<Channel<Req, Resp>>
-where
-    Req: Send + 'static,
-    Resp: Send + 'static,
-    T: Transport<Item = Response<Resp>, SinkItem = ClientMessage<Req>> + Send + 'static,
-{
-    let server_addr = transport.peer_addr().unwrap_or_else(|e| {
-        warn!(
-            "Setting peer to unspecified because peer could not be determined: {}",
-            e
-        );
-        SocketAddr::new(Ipv4Addr::UNSPECIFIED.into(), 0)
-    });
-
-    Ok(await!(channel::spawn(config, transport, server_addr))?)
+/// A channel and dispatch pair. The dispatch drives the sending and receiving of requests
+/// and must be polled continuously or spawned.
+#[derive(Debug)]
+pub struct NewClient<C, D> {
+    /// The new client.
+    pub client: C,
+    /// The client's dispatch.
+    pub dispatch: D,
+}
+
+impl<C, D> NewClient<C, D>
+where
+    D: Future<Output = io::Result<()>> + Send + 'static,
+{
+    /// Helper method to spawn the dispatch on the default executor.
+    #[cfg(feature = "tokio1")]
+    pub fn spawn(self) -> io::Result<C> {
+        use log::error;
+
+        let dispatch = self
+            .dispatch
+            .unwrap_or_else(move |e| error!("Connection broken: {}", e));
+        tokio::spawn(dispatch);
+        Ok(self.client)
+    }
 }

tarpc/src/rpc/context.rs

@@ -7,8 +7,8 @@
 //! Provides a request context that carries a deadline and trace context. This context is sent from
 //! client to server and is used by the server to enforce response deadlines.
 
+use crate::trace::{self, TraceId};
 use std::time::{Duration, SystemTime};
-use trace::{self, TraceId};
 
 /// A request context that carries request-scoped information like deadlines and trace information.
 /// It is sent from client to server and is used by the server to enforce response deadlines.
@@ -16,16 +16,33 @@ use trace::{self, TraceId};
 /// The context should not be stored directly in a server implementation, because the context will
 /// be different for each request in scope.
 #[derive(Clone, Copy, Debug)]
-#[non_exhaustive]
+#[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]
 pub struct Context {
     /// When the client expects the request to be complete by. The server should cancel the request
     /// if it is not complete by this time.
+    #[cfg_attr(
+        feature = "serde1",
+        serde(serialize_with = "crate::util::serde::serialize_epoch_secs")
+    )]
+    #[cfg_attr(
+        feature = "serde1",
+        serde(deserialize_with = "crate::util::serde::deserialize_epoch_secs")
+    )]
+    #[cfg_attr(feature = "serde1", serde(default = "ten_seconds_from_now"))]
     pub deadline: SystemTime,
     /// Uniquely identifies requests originating from the same source.
     /// When a service handles a request by making requests itself, those requests should
     /// include the same `trace_id` as that included on the original request. This way,
     /// users can trace related actions across a distributed system.
     pub trace_context: trace::Context,
+    #[doc(hidden)]
+    #[cfg_attr(feature = "serde1", serde(skip_serializing, default))]
+    pub(crate) _non_exhaustive: (),
+}
+
+#[cfg(feature = "serde1")]
+fn ten_seconds_from_now() -> SystemTime {
+    SystemTime::now() + Duration::from_secs(10)
 }
 
 /// Returns the context for the current request, or a default Context if no request is active.
@@ -34,6 +51,7 @@ pub fn current() -> Context {
     Context {
         deadline: SystemTime::now() + Duration::from_secs(10),
         trace_context: trace::Context::new_root(),
+        _non_exhaustive: (),
     }
 }
 

tarpc/src/rpc/mod.rs

@@ -4,16 +4,6 @@
 // license that can be found in the LICENSE file or at
 // https://opensource.org/licenses/MIT.
 
-#![feature(
-    non_exhaustive,
-    integer_atomics,
-    try_trait,
-    futures_api,
-    pin,
-    arbitrary_self_types,
-    await_macro,
-    async_await,
-)]
 #![deny(missing_docs, missing_debug_implementations)]
 
 //! An RPC framework providing client and server.
@@ -40,37 +30,15 @@ pub mod server;
 pub mod transport;
 pub(crate) mod util;
 
-pub use crate::{client::Client, server::Server, transport::Transport};
+pub use crate::{client::Client, server::Server, trace, transport::sealed::Transport};
 
-use futures::{
-    task::{Spawn, SpawnError, SpawnExt},
-    Future,
-};
-use std::{cell::RefCell, io, sync::Once, time::SystemTime};
+use futures::task::*;
+use std::{io, time::SystemTime};
 
 /// A message from a client to a server.
 #[derive(Debug)]
-#[cfg_attr(
-    feature = "serde1",
-    derive(serde::Serialize, serde::Deserialize)
-)]
-#[non_exhaustive]
-pub struct ClientMessage<T> {
-    /// The trace context associates the message with a specific chain of causally-related actions,
-    /// possibly orchestrated across many distributed systems.
-    pub trace_context: trace::Context,
-    /// The message payload.
-    pub message: ClientMessageKind<T>,
-}
-
-/// Different messages that can be sent from a client to a server.
-#[derive(Debug)]
-#[cfg_attr(
-    feature = "serde1",
-    derive(serde::Serialize, serde::Deserialize)
-)]
-#[non_exhaustive]
-pub enum ClientMessageKind<T> {
+#[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]
+pub enum ClientMessage<T> {
     /// A request initiated by a user. The server responds to a request by invoking a
     /// service-provided request handler.  The handler completes with a [`response`](Response), which
     /// the server sends back to the client.
@@ -83,57 +51,48 @@ pub enum ClientMessageKind<T> {
     /// not be canceled, because the framework layer does not
     /// know about them.
     Cancel {
+        /// The trace context associates the message with a specific chain of causally-related actions,
+        /// possibly orchestrated across many distributed systems.
+        #[cfg_attr(feature = "serde", serde(default))]
+        trace_context: trace::Context,
         /// The ID of the request to cancel.
         request_id: u64,
     },
+    #[doc(hidden)]
+    _NonExhaustive,
 }
 
 /// A request from a client to a server.
-#[derive(Debug)]
-#[cfg_attr(
-    feature = "serde1",
-    derive(serde::Serialize, serde::Deserialize)
-)]
-#[non_exhaustive]
+#[derive(Clone, Copy, Debug)]
+#[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]
 pub struct Request<T> {
+    /// Trace context, deadline, and other cross-cutting concerns.
+    pub context: context::Context,
     /// Uniquely identifies the request across all requests sent over a single channel.
     pub id: u64,
     /// The request body.
     pub message: T,
-    /// When the client expects the request to be complete by. The server will cancel the request
-    /// if it is not complete by this time.
-    #[cfg_attr(
-        feature = "serde1",
-        serde(serialize_with = "util::serde::serialize_epoch_secs")
-    )]
-    #[cfg_attr(
-        feature = "serde1",
-        serde(deserialize_with = "util::serde::deserialize_epoch_secs")
-    )]
-    pub deadline: SystemTime,
+    #[doc(hidden)]
+    #[cfg_attr(feature = "serde1", serde(skip_serializing, default))]
+    _non_exhaustive: (),
 }
 
 /// A response from a server to a client.
-#[derive(Debug, PartialEq, Eq)]
-#[cfg_attr(
-    feature = "serde1",
-    derive(serde::Serialize, serde::Deserialize)
-)]
-#[non_exhaustive]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]
 pub struct Response<T> {
     /// The ID of the request being responded to.
     pub request_id: u64,
     /// The response body, or an error if the request failed.
     pub message: Result<T, ServerError>,
+    #[doc(hidden)]
+    #[cfg_attr(feature = "serde1", serde(skip_serializing, default))]
+    _non_exhaustive: (),
 }
 
 /// An error response from a server to a client.
-#[derive(Debug, PartialEq, Eq)]
-#[cfg_attr(
-    feature = "serde1",
-    derive(serde::Serialize, serde::Deserialize)
-)]
-#[non_exhaustive]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]
 pub struct ServerError {
     #[cfg_attr(
         feature = "serde1",
@@ -147,6 +106,9 @@ pub struct ServerError {
     pub kind: io::ErrorKind,
     /// A message describing more detail about the error that occurred.
     pub detail: Option<String>,
+    #[doc(hidden)]
+    #[cfg_attr(feature = "serde1", serde(skip_serializing, default))]
+    _non_exhaustive: (),
 }
 
 impl From<ServerError> for io::Error {
@@ -158,52 +120,8 @@ impl From<ServerError> for io::Error {
 impl<T> Request<T> {
     /// Returns the deadline for this request.
     pub fn deadline(&self) -> &SystemTime {
-        &self.deadline
+        &self.context.deadline
     }
 }
 
-static INIT: Once = Once::new();
-static mut SEED_SPAWN: Option<Box<dyn CloneSpawn>> = None;
-thread_local! {
-    static SPAWN: RefCell<Box<dyn CloneSpawn>> = {
-        unsafe {
-            // INIT must always be called before accessing SPAWN.
-            // Otherwise, accessing SPAWN can trigger undefined behavior due to race conditions.
-            INIT.call_once(|| {});
-            RefCell::new(SEED_SPAWN.clone().expect("init() must be called."))
-        }
-    };
-}
-
-/// Initializes the RPC library with a mechanism to spawn futures on the user's runtime.
-/// Client stubs and servers both use the initialized spawn.
-///
-/// Init only has an effect the first time it is called. If called previously, successive calls to
-/// init are noops.
-pub fn init(spawn: impl Spawn + Clone + 'static) {
-    unsafe {
-        INIT.call_once(|| {
-            SEED_SPAWN = Some(Box::new(spawn));
-        });
-    }
-}
-
-pub(crate) fn spawn(future: impl Future<Output = ()> + Send + 'static) -> Result<(), SpawnError> {
-    SPAWN.with(|spawn| spawn.borrow_mut().spawn(future))
-}
-
-trait CloneSpawn: Spawn {
-    fn box_clone(&self) -> Box<dyn CloneSpawn>;
-}
-
-impl Clone for Box<dyn CloneSpawn> {
-    fn clone(&self) -> Self {
-        self.box_clone()
-    }
-}
-
-impl<S: Spawn + Clone + 'static> CloneSpawn for S {
-    fn box_clone(&self) -> Box<dyn CloneSpawn> {
-        Box::new(self.clone())
-    }
-}
+pub(crate) type PollIo<T> = Poll<Option<io::Result<T>>>;

tarpc/src/rpc/server/filter.rs

@@ -0,0 +1,500 @@
+// Copyright 2018 Google LLC
+//
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file or at
+// https://opensource.org/licenses/MIT.
+
+use crate::{
+    server::{self, Channel},
+    util::Compact,
+};
+use fnv::FnvHashMap;
+use futures::{channel::mpsc, future::AbortRegistration, prelude::*, ready, stream::Fuse, task::*};
+use log::{debug, info, trace};
+use pin_project::pin_project;
+use raii_counter::{Counter, WeakCounter};
+use std::sync::{Arc, Weak};
+use std::{
+    collections::hash_map::Entry, convert::TryInto, fmt, hash::Hash, marker::Unpin, pin::Pin,
+};
+
+/// A single-threaded filter that drops channels based on per-key limits.
+#[pin_project]
+#[derive(Debug)]
+pub struct ChannelFilter<S, K, F>
+where
+    K: Eq + Hash,
+{
+    #[pin]
+    listener: Fuse<S>,
+    channels_per_key: u32,
+    #[pin]
+    dropped_keys: mpsc::UnboundedReceiver<K>,
+    #[pin]
+    dropped_keys_tx: mpsc::UnboundedSender<K>,
+    key_counts: FnvHashMap<K, TrackerPrototype<K>>,
+    keymaker: F,
+}
+
+/// A channel that is tracked by a ChannelFilter.
+#[pin_project]
+#[derive(Debug)]
+pub struct TrackedChannel<C, K> {
+    #[pin]
+    inner: C,
+    tracker: Tracker<K>,
+}
+
+#[derive(Clone, Debug)]
+struct Tracker<K> {
+    key: Option<Arc<K>>,
+    counter: Counter,
+    dropped_keys: mpsc::UnboundedSender<K>,
+}
+
+impl<K> Drop for Tracker<K> {
+    fn drop(&mut self) {
+        if self.counter.count() <= 1 {
+            // Don't care if the listener is dropped.
+            match Arc::try_unwrap(self.key.take().unwrap()) {
+                Ok(key) => {
+                    let _ = self.dropped_keys.unbounded_send(key);
+                }
+                _ => unreachable!(),
+            }
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+struct TrackerPrototype<K> {
+    key: Weak<K>,
+    counter: WeakCounter,
+    dropped_keys: mpsc::UnboundedSender<K>,
+}
+
+impl<C, K> Stream for TrackedChannel<C, K>
+where
+    C: Stream,
+{
+    type Item = <C as Stream>::Item;
+
+    fn poll_next(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
+        self.channel().poll_next(cx)
+    }
+}
+
+impl<C, I, K> Sink<I> for TrackedChannel<C, K>
+where
+    C: Sink<I>,
+{
+    type Error = C::Error;
+
+    fn poll_ready(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
+        self.channel().poll_ready(cx)
+    }
+
+    fn start_send(self: Pin<&mut Self>, item: I) -> Result<(), Self::Error> {
+        self.channel().start_send(item)
+    }
+
+    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
+        self.channel().poll_flush(cx)
+    }
+
+    fn poll_close(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
+        self.channel().poll_close(cx)
+    }
+}
+
+impl<C, K> AsRef<C> for TrackedChannel<C, K> {
+    fn as_ref(&self) -> &C {
+        &self.inner
+    }
+}
+
+impl<C, K> Channel for TrackedChannel<C, K>
+where
+    C: Channel,
+{
+    type Req = C::Req;
+    type Resp = C::Resp;
+
+    fn config(&self) -> &server::Config {
+        self.inner.config()
+    }
+
+    fn in_flight_requests(self: Pin<&mut Self>) -> usize {
+        self.project().inner.in_flight_requests()
+    }
+
+    fn start_request(self: Pin<&mut Self>, request_id: u64) -> AbortRegistration {
+        self.project().inner.start_request(request_id)
+    }
+}
+
+impl<C, K> TrackedChannel<C, K> {
+    /// Returns the inner channel.
+    pub fn get_ref(&self) -> &C {
+        &self.inner
+    }
+
+    /// Returns the pinned inner channel.
+    fn channel<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut C> {
+        self.project().inner
+    }
+}
+
+impl<S, K, F> ChannelFilter<S, K, F>
+where
+    K: Eq + Hash,
+    S: Stream,
+    F: Fn(&S::Item) -> K,
+{
+    /// Sheds new channels to stay under configured limits.
+    pub(crate) fn new(listener: S, channels_per_key: u32, keymaker: F) -> Self {
+        let (dropped_keys_tx, dropped_keys) = mpsc::unbounded();
+        ChannelFilter {
+            listener: listener.fuse(),
+            channels_per_key,
+            dropped_keys,
+            dropped_keys_tx,
+            key_counts: FnvHashMap::default(),
+            keymaker,
+        }
+    }
+}
+
+impl<S, K, F> ChannelFilter<S, K, F>
+where
+    S: Stream,
+    K: fmt::Display + Eq + Hash + Clone + Unpin,
+    F: Fn(&S::Item) -> K,
+{
+    fn handle_new_channel(
+        mut self: Pin<&mut Self>,
+        stream: S::Item,
+    ) -> Result<TrackedChannel<S::Item, K>, K> {
+        let key = (self.as_mut().keymaker)(&stream);
+        let tracker = self.as_mut().increment_channels_for_key(key.clone())?;
+
+        trace!(
+            "[{}] Opening channel ({}/{}) channels for key.",
+            key,
+            tracker.counter.count(),
+            self.as_mut().project().channels_per_key
+        );
+
+        Ok(TrackedChannel {
+            tracker,
+            inner: stream,
+        })
+    }
+
+    fn increment_channels_for_key(mut self: Pin<&mut Self>, key: K) -> Result<Tracker<K>, K> {
+        let channels_per_key = self.channels_per_key;
+        let dropped_keys = self.dropped_keys_tx.clone();
+        let key_counts = &mut self.as_mut().project().key_counts;
+        match key_counts.entry(key.clone()) {
+            Entry::Vacant(vacant) => {
+                let key = Arc::new(key);
+                let counter = WeakCounter::new();
+
+                vacant.insert(TrackerPrototype {
+                    key: Arc::downgrade(&key),
+                    counter: counter.clone(),
+                    dropped_keys: dropped_keys.clone(),
+                });
+                Ok(Tracker {
+                    key: Some(key),
+                    counter: counter.upgrade(),
+                    dropped_keys,
+                })
+            }
+            Entry::Occupied(o) => {
+                let count = o.get().counter.count();
+                if count >= channels_per_key.try_into().unwrap() {
+                    info!(
+                        "[{}] Opened max channels from key ({}/{}).",
+                        key, count, channels_per_key
+                    );
+                    Err(key)
+                } else {
+                    let TrackerPrototype {
+                        key,
+                        counter,
+                        dropped_keys,
+                    } = o.get().clone();
+                    Ok(Tracker {
+                        counter: counter.upgrade(),
+                        key: Some(key.upgrade().unwrap()),
+                        dropped_keys,
+                    })
+                }
+            }
+        }
+    }
+
+    fn poll_listener(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<TrackedChannel<S::Item, K>, K>>> {
+        match ready!(self.as_mut().project().listener.poll_next_unpin(cx)) {
+            Some(codec) => Poll::Ready(Some(self.handle_new_channel(codec))),
+            None => Poll::Ready(None),
+        }
+    }
+
+    fn poll_closed_channels(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
+        match ready!(self.as_mut().project().dropped_keys.poll_next_unpin(cx)) {
+            Some(key) => {
+                debug!("All channels dropped for key [{}]", key);
+                self.as_mut().project().key_counts.remove(&key);
+                self.as_mut().project().key_counts.compact(0.1);
+                Poll::Ready(())
+            }
+            None => unreachable!("Holding a copy of closed_channels and didn't close it."),
+        }
+    }
+}
+
+impl<S, K, F> Stream for ChannelFilter<S, K, F>
+where
+    S: Stream,
+    K: fmt::Display + Eq + Hash + Clone + Unpin,
+    F: Fn(&S::Item) -> K,
+{
+    type Item = TrackedChannel<S::Item, K>;
+
+    fn poll_next(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<TrackedChannel<S::Item, K>>> {
+        loop {
+            match (
+                self.as_mut().poll_listener(cx),
+                self.as_mut().poll_closed_channels(cx),
+            ) {
+                (Poll::Ready(Some(Ok(channel))), _) => {
+                    return Poll::Ready(Some(channel));
+                }
+                (Poll::Ready(Some(Err(_))), _) => {
+                    continue;
+                }
+                (_, Poll::Ready(())) => continue,
+                (Poll::Pending, Poll::Pending) => return Poll::Pending,
+                (Poll::Ready(None), Poll::Pending) => {
+                    trace!("Shutting down listener.");
+                    return Poll::Ready(None);
+                }
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+fn ctx() -> Context<'static> {
+    use futures::task::*;
+
+    Context::from_waker(&noop_waker_ref())
+}
+
+#[test]
+fn tracker_drop() {
+    use assert_matches::assert_matches;
+    use raii_counter::Counter;
+
+    let (tx, mut rx) = mpsc::unbounded();
+    Tracker {
+        key: Some(Arc::new(1)),
+        counter: Counter::new(),
+        dropped_keys: tx,
+    };
+    assert_matches!(rx.try_next(), Ok(Some(1)));
+}
+
+#[test]
+fn tracked_channel_stream() {
+    use assert_matches::assert_matches;
+    use pin_utils::pin_mut;
+    use raii_counter::Counter;
+
+    let (chan_tx, chan) = mpsc::unbounded();
+    let (dropped_keys, _) = mpsc::unbounded();
+    let channel = TrackedChannel {
+        inner: chan,
+        tracker: Tracker {
+            key: Some(Arc::new(1)),
+            counter: Counter::new(),
+            dropped_keys,
+        },
+    };
+
+    chan_tx.unbounded_send("test").unwrap();
+    pin_mut!(channel);
+    assert_matches!(channel.poll_next(&mut ctx()), Poll::Ready(Some("test")));
+}
+
+#[test]
+fn tracked_channel_sink() {
+    use assert_matches::assert_matches;
+    use pin_utils::pin_mut;
+    use raii_counter::Counter;
+
+    let (chan, mut chan_rx) = mpsc::unbounded();
+    let (dropped_keys, _) = mpsc::unbounded();
+    let channel = TrackedChannel {
+        inner: chan,
+        tracker: Tracker {
+            key: Some(Arc::new(1)),
+            counter: Counter::new(),
+            dropped_keys,
+        },
+    };
+
+    pin_mut!(channel);
+    assert_matches!(channel.as_mut().poll_ready(&mut ctx()), Poll::Ready(Ok(())));
+    assert_matches!(channel.as_mut().start_send("test"), Ok(()));
+    assert_matches!(channel.as_mut().poll_flush(&mut ctx()), Poll::Ready(Ok(())));
+    assert_matches!(chan_rx.try_next(), Ok(Some("test")));
+}
+
+#[test]
+fn channel_filter_increment_channels_for_key() {
+    use assert_matches::assert_matches;
+    use pin_utils::pin_mut;
+
+    struct TestChannel {
+        key: &'static str,
+    }
+    let (_, listener) = mpsc::unbounded();
+    let filter = ChannelFilter::new(listener, 2, |chan: &TestChannel| chan.key);
+    pin_mut!(filter);
+    let tracker1 = filter.as_mut().increment_channels_for_key("key").unwrap();
+    assert_eq!(tracker1.counter.count(), 1);
+    let tracker2 = filter.as_mut().increment_channels_for_key("key").unwrap();
+    assert_eq!(tracker1.counter.count(), 2);
+    assert_matches!(filter.increment_channels_for_key("key"), Err("key"));
+    drop(tracker2);
+    assert_eq!(tracker1.counter.count(), 1);
+}
+
+#[test]
+fn channel_filter_handle_new_channel() {
+    use assert_matches::assert_matches;
+    use pin_utils::pin_mut;
+
+    #[derive(Debug)]
+    struct TestChannel {
+        key: &'static str,
+    }
+    let (_, listener) = mpsc::unbounded();
+    let filter = ChannelFilter::new(listener, 2, |chan: &TestChannel| chan.key);
+    pin_mut!(filter);
+    let channel1 = filter
+        .as_mut()
+        .handle_new_channel(TestChannel { key: "key" })
+        .unwrap();
+    assert_eq!(channel1.tracker.counter.count(), 1);
+
+    let channel2 = filter
+        .as_mut()
+        .handle_new_channel(TestChannel { key: "key" })
+        .unwrap();
+    assert_eq!(channel1.tracker.counter.count(), 2);
+
+    assert_matches!(
+        filter.handle_new_channel(TestChannel { key: "key" }),
+        Err("key")
+    );
+    drop(channel2);
+    assert_eq!(channel1.tracker.counter.count(), 1);
+}
+
+#[test]
+fn channel_filter_poll_listener() {
+    use assert_matches::assert_matches;
+    use pin_utils::pin_mut;
+
+    #[derive(Debug)]
+    struct TestChannel {
+        key: &'static str,
+    }
+    let (new_channels, listener) = mpsc::unbounded();
+    let filter = ChannelFilter::new(listener, 2, |chan: &TestChannel| chan.key);
+    pin_mut!(filter);
+
+    new_channels
+        .unbounded_send(TestChannel { key: "key" })
+        .unwrap();
+    let channel1 =
+        assert_matches!(filter.as_mut().poll_listener(&mut ctx()), Poll::Ready(Some(Ok(c))) => c);
+    assert_eq!(channel1.tracker.counter.count(), 1);
+
+    new_channels
+        .unbounded_send(TestChannel { key: "key" })
+        .unwrap();
+    let _channel2 =
+        assert_matches!(filter.as_mut().poll_listener(&mut ctx()), Poll::Ready(Some(Ok(c))) => c);
+    assert_eq!(channel1.tracker.counter.count(), 2);
+
+    new_channels
+        .unbounded_send(TestChannel { key: "key" })
+        .unwrap();
+    let key =
+        assert_matches!(filter.as_mut().poll_listener(&mut ctx()), Poll::Ready(Some(Err(k))) => k);
+    assert_eq!(key, "key");
+    assert_eq!(channel1.tracker.counter.count(), 2);
+}
+
+#[test]
+fn channel_filter_poll_closed_channels() {
+    use assert_matches::assert_matches;
+    use pin_utils::pin_mut;
+
+    #[derive(Debug)]
+    struct TestChannel {
+        key: &'static str,
+    }
+    let (new_channels, listener) = mpsc::unbounded();
+    let filter = ChannelFilter::new(listener, 2, |chan: &TestChannel| chan.key);
+    pin_mut!(filter);
+
+    new_channels
+        .unbounded_send(TestChannel { key: "key" })
+        .unwrap();
+    let channel =
+        assert_matches!(filter.as_mut().poll_listener(&mut ctx()), Poll::Ready(Some(Ok(c))) => c);
+    assert_eq!(filter.key_counts.len(), 1);
+
+    drop(channel);
+    assert_matches!(
+        filter.as_mut().poll_closed_channels(&mut ctx()),
+        Poll::Ready(())
+    );
+    assert!(filter.key_counts.is_empty());
+}
+
+#[test]
+fn channel_filter_stream() {
+    use assert_matches::assert_matches;
+    use pin_utils::pin_mut;
+
+    #[derive(Debug)]
+    struct TestChannel {
+        key: &'static str,
+    }
+    let (new_channels, listener) = mpsc::unbounded();
+    let filter = ChannelFilter::new(listener, 2, |chan: &TestChannel| chan.key);
+    pin_mut!(filter);
+
+    new_channels
+        .unbounded_send(TestChannel { key: "key" })
+        .unwrap();
+    let channel = assert_matches!(filter.as_mut().poll_next(&mut ctx()), Poll::Ready(Some(c)) => c);
+    assert_eq!(filter.key_counts.len(), 1);
+
+    drop(channel);
+    assert_matches!(filter.as_mut().poll_next(&mut ctx()), Poll::Pending);
+    assert!(filter.key_counts.is_empty());
+}

tarpc/src/rpc/server/mod.rs

@@ -0,0 +1,702 @@
+// Copyright 2018 Google LLC
+//
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file or at
+// https://opensource.org/licenses/MIT.
+
+//! Provides a server that concurrently handles many connections sending multiplexed requests.
+
+use crate::{
+    context, trace, util::Compact, util::TimeUntil, ClientMessage, PollIo, Request, Response,
+    ServerError, Transport,
+};
+use fnv::FnvHashMap;
+use futures::{
+    channel::mpsc,
+    future::{AbortHandle, AbortRegistration, Abortable},
+    prelude::*,
+    ready,
+    stream::Fuse,
+    task::*,
+};
+use humantime::format_rfc3339;
+use log::{debug, trace};
+use pin_project::pin_project;
+use std::{fmt, hash::Hash, io, marker::PhantomData, pin::Pin, time::SystemTime};
+use tokio::time::Timeout;
+
+mod filter;
+#[cfg(test)]
+mod testing;
+mod throttle;
+
+pub use self::{
+    filter::ChannelFilter,
+    throttle::{Throttler, ThrottlerStream},
+};
+
+/// Manages clients, serving multiplexed requests over each connection.
+#[derive(Debug)]
+pub struct Server<Req, Resp> {
+    config: Config,
+    ghost: PhantomData<(Req, Resp)>,
+}
+
+impl<Req, Resp> Default for Server<Req, Resp> {
+    fn default() -> Self {
+        new(Config::default())
+    }
+}
+
+/// Settings that control the behavior of the server.
+#[derive(Clone, Debug)]
+pub struct Config {
+    /// The number of responses per client that can be buffered server-side before being sent.
+    /// `pending_response_buffer` controls the buffer size of the channel that a server's
+    /// response tasks use to send responses to the client handler task.
+    pub pending_response_buffer: usize,
+}
+
+impl Default for Config {
+    fn default() -> Self {
+        Config {
+            pending_response_buffer: 100,
+        }
+    }
+}
+
+impl Config {
+    /// Returns a channel backed by `transport` and configured with `self`.
+    pub fn channel<Req, Resp, T>(self, transport: T) -> BaseChannel<Req, Resp, T>
+    where
+        T: Transport<Response<Resp>, ClientMessage<Req>>,
+    {
+        BaseChannel::new(self, transport)
+    }
+}
+
+/// Returns a new server with configuration specified `config`.
+pub fn new<Req, Resp>(config: Config) -> Server<Req, Resp> {
+    Server {
+        config,
+        ghost: PhantomData,
+    }
+}
+
+impl<Req, Resp> Server<Req, Resp> {
+    /// Returns the config for this server.
+    pub fn config(&self) -> &Config {
+        &self.config
+    }
+
+    /// Returns a stream of server channels.
+    pub fn incoming<S, T>(self, listener: S) -> impl Stream<Item = BaseChannel<Req, Resp, T>>
+    where
+        S: Stream<Item = T>,
+        T: Transport<Response<Resp>, ClientMessage<Req>>,
+    {
+        listener.map(move |t| BaseChannel::new(self.config.clone(), t))
+    }
+}
+
+/// Basically a Fn(Req) -> impl Future<Output = Resp>;
+pub trait Serve<Req>: Sized + Clone {
+    /// Type of response.
+    type Resp;
+
+    /// Type of response future.
+    type Fut: Future<Output = Self::Resp>;
+
+    /// Responds to a single request.
+    fn serve(self, ctx: context::Context, req: Req) -> Self::Fut;
+}
+
+impl<Req, Resp, Fut, F> Serve<Req> for F
+where
+    F: FnOnce(context::Context, Req) -> Fut + Clone,
+    Fut: Future<Output = Resp>,
+{
+    type Resp = Resp;
+    type Fut = Fut;
+
+    fn serve(self, ctx: context::Context, req: Req) -> Self::Fut {
+        self(ctx, req)
+    }
+}
+
+/// A utility trait enabling a stream to fluently chain a request handler.
+pub trait Handler<C>
+where
+    Self: Sized + Stream<Item = C>,
+    C: Channel,
+{
+    /// Enforces channel per-key limits.
+    fn max_channels_per_key<K, KF>(self, n: u32, keymaker: KF) -> filter::ChannelFilter<Self, K, KF>
+    where
+        K: fmt::Display + Eq + Hash + Clone + Unpin,
+        KF: Fn(&C) -> K,
+    {
+        ChannelFilter::new(self, n, keymaker)
+    }
+
+    /// Caps the number of concurrent requests per channel.
+    fn max_concurrent_requests_per_channel(self, n: usize) -> ThrottlerStream<Self> {
+        ThrottlerStream::new(self, n)
+    }
+
+    /// Responds to all requests with `server`.
+    #[cfg(feature = "tokio1")]
+    fn respond_with<S>(self, server: S) -> Running<Self, S>
+    where
+        S: Serve<C::Req, Resp = C::Resp>,
+    {
+        Running {
+            incoming: self,
+            server,
+        }
+    }
+}
+
+impl<S, C> Handler<C> for S
+where
+    S: Sized + Stream<Item = C>,
+    C: Channel,
+{
+}
+
+/// BaseChannel lifts a Transport to a Channel by tracking in-flight requests.
+#[pin_project]
+#[derive(Debug)]
+pub struct BaseChannel<Req, Resp, T> {
+    config: Config,
+    /// Writes responses to the wire and reads requests off the wire.
+    #[pin]
+    transport: Fuse<T>,
+    /// Number of requests currently being responded to.
+    in_flight_requests: FnvHashMap<u64, AbortHandle>,
+    /// Types the request and response.
+    ghost: PhantomData<(Req, Resp)>,
+}
+
+impl<Req, Resp, T> BaseChannel<Req, Resp, T>
+where
+    T: Transport<Response<Resp>, ClientMessage<Req>>,
+{
+    /// Creates a new channel backed by `transport` and configured with `config`.
+    pub fn new(config: Config, transport: T) -> Self {
+        BaseChannel {
+            config,
+            transport: transport.fuse(),
+            in_flight_requests: FnvHashMap::default(),
+            ghost: PhantomData,
+        }
+    }
+
+    /// Creates a new channel backed by `transport` and configured with the defaults.
+    pub fn with_defaults(transport: T) -> Self {
+        Self::new(Config::default(), transport)
+    }
+
+    /// Returns the inner transport.
+    pub fn get_ref(&self) -> &T {
+        self.transport.get_ref()
+    }
+
+    fn cancel_request(mut self: Pin<&mut Self>, trace_context: &trace::Context, request_id: u64) {
+        // It's possible the request was already completed, so it's fine
+        // if this is None.
+        if let Some(cancel_handle) = self
+            .as_mut()
+            .project()
+            .in_flight_requests
+            .remove(&request_id)
+        {
+            self.as_mut().project().in_flight_requests.compact(0.1);
+
+            cancel_handle.abort();
+            let remaining = self.as_mut().project().in_flight_requests.len();
+            trace!(
+                "[{}] Request canceled. In-flight requests = {}",
+                trace_context.trace_id,
+                remaining,
+            );
+        } else {
+            trace!(
+                "[{}] Received cancellation, but response handler \
+                 is already complete.",
+                trace_context.trace_id,
+            );
+        }
+    }
+}
+
+/// The server end of an open connection with a client, streaming in requests from, and sinking
+/// responses to, the client.
+///
+/// Channels are free to somewhat rely on the assumption that all in-flight requests are eventually
+/// either [cancelled](BaseChannel::cancel_request) or [responded to](Sink::start_send). Safety cannot
+/// rely on this assumption, but it is best for `Channel` users to always account for all outstanding
+/// requests.
+pub trait Channel
+where
+    Self: Transport<Response<<Self as Channel>::Resp>, Request<<Self as Channel>::Req>>,
+{
+    /// Type of request item.
+    type Req;
+
+    /// Type of response sink item.
+    type Resp;
+
+    /// Configuration of the channel.
+    fn config(&self) -> &Config;
+
+    /// Returns the number of in-flight requests over this channel.
+    fn in_flight_requests(self: Pin<&mut Self>) -> usize;
+
+    /// Caps the number of concurrent requests.
+    fn max_concurrent_requests(self, n: usize) -> Throttler<Self>
+    where
+        Self: Sized,
+    {
+        Throttler::new(self, n)
+    }
+
+    /// Tells the Channel that request with ID `request_id` is being handled.
+    /// The request will be tracked until a response with the same ID is sent
+    /// to the Channel.
+    fn start_request(self: Pin<&mut Self>, request_id: u64) -> AbortRegistration;
+
+    /// Respond to requests coming over the channel with `f`. Returns a future that drives the
+    /// responses and resolves when the connection is closed.
+    fn respond_with<S>(self, server: S) -> ClientHandler<Self, S>
+    where
+        S: Serve<Self::Req, Resp = Self::Resp>,
+        Self: Sized,
+    {
+        let (responses_tx, responses) = mpsc::channel(self.config().pending_response_buffer);
+        let responses = responses.fuse();
+
+        ClientHandler {
+            channel: self,
+            server,
+            pending_responses: responses,
+            responses_tx,
+        }
+    }
+}
+
+impl<Req, Resp, T> Stream for BaseChannel<Req, Resp, T>
+where
+    T: Transport<Response<Resp>, ClientMessage<Req>>,
+{
+    type Item = io::Result<Request<Req>>;
+
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
+        loop {
+            match ready!(self.as_mut().project().transport.poll_next(cx)?) {
+                Some(message) => match message {
+                    ClientMessage::Request(request) => {
+                        return Poll::Ready(Some(Ok(request)));
+                    }
+                    ClientMessage::Cancel {
+                        trace_context,
+                        request_id,
+                    } => {
+                        self.as_mut().cancel_request(&trace_context, request_id);
+                    }
+                    ClientMessage::_NonExhaustive => unreachable!(),
+                },
+                None => return Poll::Ready(None),
+            }
+        }
+    }
+}
+
+impl<Req, Resp, T> Sink<Response<Resp>> for BaseChannel<Req, Resp, T>
+where
+    T: Transport<Response<Resp>, ClientMessage<Req>>,
+{
+    type Error = io::Error;
+
+    fn poll_ready(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
+        self.project().transport.poll_ready(cx)
+    }
+
+    fn start_send(mut self: Pin<&mut Self>, response: Response<Resp>) -> Result<(), Self::Error> {
+        if self
+            .as_mut()
+            .project()
+            .in_flight_requests
+            .remove(&response.request_id)
+            .is_some()
+        {
+            self.as_mut().project().in_flight_requests.compact(0.1);
+        }
+
+        self.project().transport.start_send(response)
+    }
+
+    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
+        self.project().transport.poll_flush(cx)
+    }
+
+    fn poll_close(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
+        self.project().transport.poll_close(cx)
+    }
+}
+
+impl<Req, Resp, T> AsRef<T> for BaseChannel<Req, Resp, T> {
+    fn as_ref(&self) -> &T {
+        self.transport.get_ref()
+    }
+}
+
+impl<Req, Resp, T> Channel for BaseChannel<Req, Resp, T>
+where
+    T: Transport<Response<Resp>, ClientMessage<Req>>,
+{
+    type Req = Req;
+    type Resp = Resp;
+
+    fn config(&self) -> &Config {
+        &self.config
+    }
+
+    fn in_flight_requests(mut self: Pin<&mut Self>) -> usize {
+        self.as_mut().project().in_flight_requests.len()
+    }
+
+    fn start_request(self: Pin<&mut Self>, request_id: u64) -> AbortRegistration {
+        let (abort_handle, abort_registration) = AbortHandle::new_pair();
+        assert!(self
+            .project()
+            .in_flight_requests
+            .insert(request_id, abort_handle)
+            .is_none());
+        abort_registration
+    }
+}
+
+/// A running handler serving all requests coming over a channel.
+#[pin_project]
+#[derive(Debug)]
+pub struct ClientHandler<C, S>
+where
+    C: Channel,
+{
+    #[pin]
+    channel: C,
+    /// Responses waiting to be written to the wire.
+    #[pin]
+    pending_responses: Fuse<mpsc::Receiver<(context::Context, Response<C::Resp>)>>,
+    /// Handed out to request handlers to fan in responses.
+    #[pin]
+    responses_tx: mpsc::Sender<(context::Context, Response<C::Resp>)>,
+    /// Server
+    server: S,
+}
+
+impl<C, S> ClientHandler<C, S>
+where
+    C: Channel,
+    S: Serve<C::Req, Resp = C::Resp>,
+{
+    fn pump_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> PollIo<RequestHandler<S::Fut, C::Resp>> {
+        match ready!(self.as_mut().project().channel.poll_next(cx)?) {
+            Some(request) => Poll::Ready(Some(Ok(self.handle_request(request)))),
+            None => Poll::Ready(None),
+        }
+    }
+
+    fn pump_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        read_half_closed: bool,
+    ) -> PollIo<()> {
+        match self.as_mut().poll_next_response(cx)? {
+            Poll::Ready(Some((ctx, response))) => {
+                trace!(
+                    "[{}] Staging response. In-flight requests = {}.",
+                    ctx.trace_id(),
+                    self.as_mut().project().channel.in_flight_requests(),
+                );
+                self.as_mut().project().channel.start_send(response)?;
+                Poll::Ready(Some(Ok(())))
+            }
+            Poll::Ready(None) => {
+                // Shutdown can't be done before we finish pumping out remaining responses.
+                ready!(self.as_mut().project().channel.poll_flush(cx)?);
+                Poll::Ready(None)
+            }
+            Poll::Pending => {
+                // No more requests to process, so flush any requests buffered in the transport.
+                ready!(self.as_mut().project().channel.poll_flush(cx)?);
+
+                // Being here means there are no staged requests and all written responses are
+                // fully flushed. So, if the read half is closed and there are no in-flight
+                // requests, then we can close the write half.
+                if read_half_closed && self.as_mut().project().channel.in_flight_requests() == 0 {
+                    Poll::Ready(None)
+                } else {
+                    Poll::Pending
+                }
+            }
+        }
+    }
+
+    fn poll_next_response(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> PollIo<(context::Context, Response<C::Resp>)> {
+        // Ensure there's room to write a response.
+        while let Poll::Pending = self.as_mut().project().channel.poll_ready(cx)? {
+            ready!(self.as_mut().project().channel.poll_flush(cx)?);
+        }
+
+        match ready!(self.as_mut().project().pending_responses.poll_next(cx)) {
+            Some((ctx, response)) => Poll::Ready(Some(Ok((ctx, response)))),
+            None => {
+                // This branch likely won't happen, since the ClientHandler is holding a Sender.
+                Poll::Ready(None)
+            }
+        }
+    }
+
+    fn handle_request(
+        mut self: Pin<&mut Self>,
+        request: Request<C::Req>,
+    ) -> RequestHandler<S::Fut, C::Resp> {
+        let request_id = request.id;
+        let deadline = request.context.deadline;
+        let timeout = deadline.time_until();
+        trace!(
+            "[{}] Received request with deadline {} (timeout {:?}).",
+            request.context.trace_id(),
+            format_rfc3339(deadline),
+            timeout,
+        );
+        let ctx = request.context;
+        let request = request.message;
+
+        let response = self.as_mut().project().server.clone().serve(ctx, request);
+        let response = Resp {
+            state: RespState::PollResp,
+            request_id,
+            ctx,
+            deadline,
+            f: tokio::time::timeout(timeout, response),
+            response: None,
+            response_tx: self.as_mut().project().responses_tx.clone(),
+        };
+        let abort_registration = self.as_mut().project().channel.start_request(request_id);
+        RequestHandler {
+            resp: Abortable::new(response, abort_registration),
+        }
+    }
+}
+
+/// A future fulfilling a single client request.
+#[pin_project]
+#[derive(Debug)]
+pub struct RequestHandler<F, R> {
+    #[pin]
+    resp: Abortable<Resp<F, R>>,
+}
+
+impl<F, R> Future for RequestHandler<F, R>
+where
+    F: Future<Output = R>,
+{
+    type Output = ();
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
+        let _ = ready!(self.project().resp.poll(cx));
+        Poll::Ready(())
+    }
+}
+
+#[pin_project]
+#[derive(Debug)]
+struct Resp<F, R> {
+    state: RespState,
+    request_id: u64,
+    ctx: context::Context,
+    deadline: SystemTime,
+    #[pin]
+    f: Timeout<F>,
+    response: Option<Response<R>>,
+    #[pin]
+    response_tx: mpsc::Sender<(context::Context, Response<R>)>,
+}
+
+#[derive(Debug)]
+#[allow(clippy::enum_variant_names)]
+enum RespState {
+    PollResp,
+    PollReady,
+    PollFlush,
+}
+
+impl<F, R> Future for Resp<F, R>
+where
+    F: Future<Output = R>,
+{
+    type Output = ();
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
+        loop {
+            match self.as_mut().project().state {
+                RespState::PollResp => {
+                    let result = ready!(self.as_mut().project().f.poll(cx));
+                    *self.as_mut().project().response = Some(Response {
+                        request_id: self.request_id,
+                        message: match result {
+                            Ok(message) => Ok(message),
+                            Err(tokio::time::Elapsed { .. }) => {
+                                debug!(
+                                    "[{}] Response did not complete before deadline of {}s.",
+                                    self.ctx.trace_id(),
+                                    format_rfc3339(self.deadline)
+                                );
+                                // No point in responding, since the client will have dropped the
+                                // request.
+                                Err(ServerError {
+                                    kind: io::ErrorKind::TimedOut,
+                                    detail: Some(format!(
+                                        "Response did not complete before deadline of {}s.",
+                                        format_rfc3339(self.deadline)
+                                    )),
+                                    _non_exhaustive: (),
+                                })
+                            }
+                        },
+                        _non_exhaustive: (),
+                    });
+                    *self.as_mut().project().state = RespState::PollReady;
+                }
+                RespState::PollReady => {
+                    let ready = ready!(self.as_mut().project().response_tx.poll_ready(cx));
+                    if ready.is_err() {
+                        return Poll::Ready(());
+                    }
+                    let resp = (self.ctx, self.as_mut().project().response.take().unwrap());
+                    if self
+                        .as_mut()
+                        .project()
+                        .response_tx
+                        .start_send(resp)
+                        .is_err()
+                    {
+                        return Poll::Ready(());
+                    }
+                    *self.as_mut().project().state = RespState::PollFlush;
+                }
+                RespState::PollFlush => {
+                    let ready = ready!(self.as_mut().project().response_tx.poll_flush(cx));
+                    if ready.is_err() {
+                        return Poll::Ready(());
+                    }
+                    return Poll::Ready(());
+                }
+            }
+        }
+    }
+}
+
+impl<C, S> Stream for ClientHandler<C, S>
+where
+    C: Channel,
+    S: Serve<C::Req, Resp = C::Resp>,
+{
+    type Item = io::Result<RequestHandler<S::Fut, C::Resp>>;
+
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        loop {
+            let read = self.as_mut().pump_read(cx)?;
+            let read_closed = if let Poll::Ready(None) = read {
+                true
+            } else {
+                false
+            };
+            match (read, self.as_mut().pump_write(cx, read_closed)?) {
+                (Poll::Ready(None), Poll::Ready(None)) => {
+                    return Poll::Ready(None);
+                }
+                (Poll::Ready(Some(request_handler)), _) => {
+                    return Poll::Ready(Some(Ok(request_handler)));
+                }
+                (_, Poll::Ready(Some(()))) => {}
+                _ => {
+                    return Poll::Pending;
+                }
+            }
+        }
+    }
+}
+
+// Send + 'static execution helper methods.
+
+impl<C, S> ClientHandler<C, S>
+where
+    C: Channel + 'static,
+    C::Req: Send + 'static,
+    C::Resp: Send + 'static,
+    S: Serve<C::Req, Resp = C::Resp> + Send + 'static,
+    S::Fut: Send + 'static,
+{
+    /// Runs the client handler until completion by spawning each
+    /// request handler onto the default executor.
+    #[cfg(feature = "tokio1")]
+    pub fn execute(self) -> impl Future<Output = ()> {
+        use log::info;
+
+        self.try_for_each(|request_handler| {
+            async {
+                tokio::spawn(request_handler);
+                Ok(())
+            }
+        })
+        .unwrap_or_else(|e| info!("ClientHandler errored out: {}", e))
+    }
+}
+
+/// A future that drives the server by spawning channels and request handlers on the default
+/// executor.
+#[pin_project]
+#[derive(Debug)]
+#[cfg(feature = "tokio1")]
+pub struct Running<St, Se> {
+    #[pin]
+    incoming: St,
+    server: Se,
+}
+
+#[cfg(feature = "tokio1")]
+impl<St, C, Se> Future for Running<St, Se>
+where
+    St: Sized + Stream<Item = C>,
+    C: Channel + Send + 'static,
+    C::Req: Send + 'static,
+    C::Resp: Send + 'static,
+    Se: Serve<C::Req, Resp = C::Resp> + Send + 'static + Clone,
+    Se::Fut: Send + 'static,
+{
+    type Output = ();
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
+        use log::info;
+
+        while let Some(channel) = ready!(self.as_mut().project().incoming.poll_next(cx)) {
+            tokio::spawn(
+                channel
+                    .respond_with(self.as_mut().project().server.clone())
+                    .execute(),
+            );
+        }
+        info!("Server shutting down.");
+        Poll::Ready(())
+    }
+}

tarpc/src/rpc/server/testing.rs

@@ -0,0 +1,125 @@
+use crate::server::{Channel, Config};
+use crate::{context, Request, Response};
+use fnv::FnvHashSet;
+use futures::{
+    future::{AbortHandle, AbortRegistration},
+    task::*,
+    Sink, Stream,
+};
+use pin_project::pin_project;
+use std::collections::VecDeque;
+use std::io;
+use std::pin::Pin;
+use std::time::SystemTime;
+
+#[pin_project]
+pub(crate) struct FakeChannel<In, Out> {
+    #[pin]
+    pub stream: VecDeque<In>,
+    #[pin]
+    pub sink: VecDeque<Out>,
+    pub config: Config,
+    pub in_flight_requests: FnvHashSet<u64>,
+}
+
+impl<In, Out> Stream for FakeChannel<In, Out>
+where
+    In: Unpin,
+{
+    type Item = In;
+
+    fn poll_next(self: Pin<&mut Self>, _cx: &mut Context) -> Poll<Option<Self::Item>> {
+        Poll::Ready(self.project().stream.pop_front())
+    }
+}
+
+impl<In, Resp> Sink<Response<Resp>> for FakeChannel<In, Response<Resp>> {
+    type Error = io::Error;
+
+    fn poll_ready(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
+        self.project().sink.poll_ready(cx).map_err(|e| match e {})
+    }
+
+    fn start_send(mut self: Pin<&mut Self>, response: Response<Resp>) -> Result<(), Self::Error> {
+        self.as_mut()
+            .project()
+            .in_flight_requests
+            .remove(&response.request_id);
+        self.project()
+            .sink
+            .start_send(response)
+            .map_err(|e| match e {})
+    }
+
+    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
+        self.project().sink.poll_flush(cx).map_err(|e| match e {})
+    }
+
+    fn poll_close(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
+        self.project().sink.poll_close(cx).map_err(|e| match e {})
+    }
+}
+
+impl<Req, Resp> Channel for FakeChannel<io::Result<Request<Req>>, Response<Resp>>
+where
+    Req: Unpin,
+{
+    type Req = Req;
+    type Resp = Resp;
+
+    fn config(&self) -> &Config {
+        &self.config
+    }
+
+    fn in_flight_requests(self: Pin<&mut Self>) -> usize {
+        self.in_flight_requests.len()
+    }
+
+    fn start_request(self: Pin<&mut Self>, id: u64) -> AbortRegistration {
+        self.project().in_flight_requests.insert(id);
+        AbortHandle::new_pair().1
+    }
+}
+
+impl<Req, Resp> FakeChannel<io::Result<Request<Req>>, Response<Resp>> {
+    pub fn push_req(&mut self, id: u64, message: Req) {
+        self.stream.push_back(Ok(Request {
+            context: context::Context {
+                deadline: SystemTime::UNIX_EPOCH,
+                trace_context: Default::default(),
+                _non_exhaustive: (),
+            },
+            id,
+            message,
+            _non_exhaustive: (),
+        }));
+    }
+}
+
+impl FakeChannel<(), ()> {
+    pub fn default<Req, Resp>() -> FakeChannel<io::Result<Request<Req>>, Response<Resp>> {
+        FakeChannel {
+            stream: Default::default(),
+            sink: Default::default(),
+            config: Default::default(),
+            in_flight_requests: Default::default(),
+        }
+    }
+}
+
+pub trait PollExt {
+    fn is_done(&self) -> bool;
+}
+
+impl<T> PollExt for Poll<Option<T>> {
+    fn is_done(&self) -> bool {
+        match self {
+            Poll::Ready(None) => true,
+            _ => false,
+        }
+    }
+}
+
+pub fn cx() -> Context<'static> {
+    Context::from_waker(&noop_waker_ref())
+}

tarpc/src/rpc/server/throttle.rs

@@ -0,0 +1,326 @@
+use super::{Channel, Config};
+use crate::{Response, ServerError};
+use futures::{future::AbortRegistration, prelude::*, ready, task::*};
+use log::debug;
+use pin_project::pin_project;
+use std::{io, pin::Pin};
+
+/// A [`Channel`] that limits the number of concurrent
+/// requests by throttling.
+#[pin_project]
+#[derive(Debug)]
+pub struct Throttler<C> {
+    max_in_flight_requests: usize,
+    #[pin]
+    inner: C,
+}
+
+impl<C> Throttler<C> {
+    /// Returns the inner channel.
+    pub fn get_ref(&self) -> &C {
+        &self.inner
+    }
+}
+
+impl<C> Throttler<C>
+where
+    C: Channel,
+{
+    /// Returns a new `Throttler` that wraps the given channel and limits concurrent requests to
+    /// `max_in_flight_requests`.
+    pub fn new(inner: C, max_in_flight_requests: usize) -> Self {
+        Throttler {
+            inner,
+            max_in_flight_requests,
+        }
+    }
+}
+
+impl<C> Stream for Throttler<C>
+where
+    C: Channel,
+{
+    type Item = <C as Stream>::Item;
+
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
+        while self.as_mut().in_flight_requests() >= *self.as_mut().project().max_in_flight_requests
+        {
+            ready!(self.as_mut().project().inner.poll_ready(cx)?);
+
+            match ready!(self.as_mut().project().inner.poll_next(cx)?) {
+                Some(request) => {
+                    debug!(
+                        "[{}] Client has reached in-flight request limit ({}/{}).",
+                        request.context.trace_id(),
+                        self.as_mut().in_flight_requests(),
+                        self.as_mut().project().max_in_flight_requests,
+                    );
+
+                    self.as_mut().start_send(Response {
+                        request_id: request.id,
+                        message: Err(ServerError {
+                            kind: io::ErrorKind::WouldBlock,
+                            detail: Some("Server throttled the request.".into()),
+                            _non_exhaustive: (),
+                        }),
+                        _non_exhaustive: (),
+                    })?;
+                }
+                None => return Poll::Ready(None),
+            }
+        }
+        self.project().inner.poll_next(cx)
+    }
+}
+
+impl<C> Sink<Response<<C as Channel>::Resp>> for Throttler<C>
+where
+    C: Channel,
+{
+    type Error = io::Error;
+
+    fn poll_ready(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
+        self.project().inner.poll_ready(cx)
+    }
+
+    fn start_send(self: Pin<&mut Self>, item: Response<<C as Channel>::Resp>) -> io::Result<()> {
+        self.project().inner.start_send(item)
+    }
+
+    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context) -> Poll<io::Result<()>> {
+        self.project().inner.poll_flush(cx)
+    }
+
+    fn poll_close(self: Pin<&mut Self>, cx: &mut Context) -> Poll<io::Result<()>> {
+        self.project().inner.poll_close(cx)
+    }
+}
+
+impl<C> AsRef<C> for Throttler<C> {
+    fn as_ref(&self) -> &C {
+        &self.inner
+    }
+}
+
+impl<C> Channel for Throttler<C>
+where
+    C: Channel,
+{
+    type Req = <C as Channel>::Req;
+    type Resp = <C as Channel>::Resp;
+
+    fn in_flight_requests(self: Pin<&mut Self>) -> usize {
+        self.project().inner.in_flight_requests()
+    }
+
+    fn config(&self) -> &Config {
+        self.inner.config()
+    }
+
+    fn start_request(self: Pin<&mut Self>, request_id: u64) -> AbortRegistration {
+        self.project().inner.start_request(request_id)
+    }
+}
+
+/// A stream of throttling channels.
+#[pin_project]
+#[derive(Debug)]
+pub struct ThrottlerStream<S> {
+    #[pin]
+    inner: S,
+    max_in_flight_requests: usize,
+}
+
+impl<S> ThrottlerStream<S>
+where
+    S: Stream,
+    <S as Stream>::Item: Channel,
+{
+    pub(crate) fn new(inner: S, max_in_flight_requests: usize) -> Self {
+        Self {
+            inner,
+            max_in_flight_requests,
+        }
+    }
+}
+
+impl<S> Stream for ThrottlerStream<S>
+where
+    S: Stream,
+    <S as Stream>::Item: Channel,
+{
+    type Item = Throttler<<S as Stream>::Item>;
+
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
+        match ready!(self.as_mut().project().inner.poll_next(cx)) {
+            Some(channel) => Poll::Ready(Some(Throttler::new(
+                channel,
+                *self.project().max_in_flight_requests,
+            ))),
+            None => Poll::Ready(None),
+        }
+    }
+}
+
+#[cfg(test)]
+use super::testing::{self, FakeChannel, PollExt};
+#[cfg(test)]
+use crate::Request;
+#[cfg(test)]
+use pin_utils::pin_mut;
+#[cfg(test)]
+use std::marker::PhantomData;
+
+#[test]
+fn throttler_in_flight_requests() {
+    let throttler = Throttler {
+        max_in_flight_requests: 0,
+        inner: FakeChannel::default::<isize, isize>(),
+    };
+
+    pin_mut!(throttler);
+    for i in 0..5 {
+        throttler.inner.in_flight_requests.insert(i);
+    }
+    assert_eq!(throttler.as_mut().in_flight_requests(), 5);
+}
+
+#[test]
+fn throttler_start_request() {
+    let throttler = Throttler {
+        max_in_flight_requests: 0,
+        inner: FakeChannel::default::<isize, isize>(),
+    };
+
+    pin_mut!(throttler);
+    throttler.as_mut().start_request(1);
+    assert_eq!(throttler.inner.in_flight_requests.len(), 1);
+}
+
+#[test]
+fn throttler_poll_next_done() {
+    let throttler = Throttler {
+        max_in_flight_requests: 0,
+        inner: FakeChannel::default::<isize, isize>(),
+    };
+
+    pin_mut!(throttler);
+    assert!(throttler.as_mut().poll_next(&mut testing::cx()).is_done());
+}
+
+#[test]
+fn throttler_poll_next_some() -> io::Result<()> {
+    let throttler = Throttler {
+        max_in_flight_requests: 1,
+        inner: FakeChannel::default::<isize, isize>(),
+    };
+
+    pin_mut!(throttler);
+    throttler.inner.push_req(0, 1);
+    assert!(throttler.as_mut().poll_ready(&mut testing::cx()).is_ready());
+    assert_eq!(
+        throttler
+            .as_mut()
+            .poll_next(&mut testing::cx())?
+            .map(|r| r.map(|r| (r.id, r.message))),
+        Poll::Ready(Some((0, 1)))
+    );
+    Ok(())
+}
+
+#[test]
+fn throttler_poll_next_throttled() {
+    let throttler = Throttler {
+        max_in_flight_requests: 0,
+        inner: FakeChannel::default::<isize, isize>(),
+    };
+
+    pin_mut!(throttler);
+    throttler.inner.push_req(1, 1);
+    assert!(throttler.as_mut().poll_next(&mut testing::cx()).is_done());
+    assert_eq!(throttler.inner.sink.len(), 1);
+    let resp = throttler.inner.sink.get(0).unwrap();
+    assert_eq!(resp.request_id, 1);
+    assert!(resp.message.is_err());
+}
+
+#[test]
+fn throttler_poll_next_throttled_sink_not_ready() {
+    let throttler = Throttler {
+        max_in_flight_requests: 0,
+        inner: PendingSink::default::<isize, isize>(),
+    };
+    pin_mut!(throttler);
+    assert!(throttler.poll_next(&mut testing::cx()).is_pending());
+
+    struct PendingSink<In, Out> {
+        ghost: PhantomData<fn(Out) -> In>,
+    }
+    impl PendingSink<(), ()> {
+        pub fn default<Req, Resp>() -> PendingSink<io::Result<Request<Req>>, Response<Resp>> {
+            PendingSink { ghost: PhantomData }
+        }
+    }
+    impl<In, Out> Stream for PendingSink<In, Out> {
+        type Item = In;
+        fn poll_next(self: Pin<&mut Self>, _: &mut Context) -> Poll<Option<Self::Item>> {
+            unimplemented!()
+        }
+    }
+    impl<In, Out> Sink<Out> for PendingSink<In, Out> {
+        type Error = io::Error;
+        fn poll_ready(self: Pin<&mut Self>, _: &mut Context) -> Poll<Result<(), Self::Error>> {
+            Poll::Pending
+        }
+        fn start_send(self: Pin<&mut Self>, _: Out) -> Result<(), Self::Error> {
+            Err(io::Error::from(io::ErrorKind::WouldBlock))
+        }
+        fn poll_flush(self: Pin<&mut Self>, _: &mut Context) -> Poll<Result<(), Self::Error>> {
+            Poll::Pending
+        }
+        fn poll_close(self: Pin<&mut Self>, _: &mut Context) -> Poll<Result<(), Self::Error>> {
+            Poll::Pending
+        }
+    }
+    impl<Req, Resp> Channel for PendingSink<io::Result<Request<Req>>, Response<Resp>> {
+        type Req = Req;
+        type Resp = Resp;
+        fn config(&self) -> &Config {
+            unimplemented!()
+        }
+        fn in_flight_requests(self: Pin<&mut Self>) -> usize {
+            0
+        }
+        fn start_request(self: Pin<&mut Self>, _: u64) -> AbortRegistration {
+            unimplemented!()
+        }
+    }
+}
+
+#[test]
+fn throttler_start_send() {
+    let throttler = Throttler {
+        max_in_flight_requests: 0,
+        inner: FakeChannel::default::<isize, isize>(),
+    };
+
+    pin_mut!(throttler);
+    throttler.inner.in_flight_requests.insert(0);
+    throttler
+        .as_mut()
+        .start_send(Response {
+            request_id: 0,
+            message: Ok(1),
+            _non_exhaustive: (),
+        })
+        .unwrap();
+    assert!(throttler.inner.in_flight_requests.is_empty());
+    assert_eq!(
+        throttler.inner.sink.get(0),
+        Some(&Response {
+            request_id: 0,
+            message: Ok(1),
+            _non_exhaustive: ()
+        })
+    );
+}

tarpc/src/rpc/transport/channel.rs

@@ -0,0 +1,123 @@
+// Copyright 2018 Google LLC
+//
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file or at
+// https://opensource.org/licenses/MIT.
+
+//! Transports backed by in-memory channels.
+
+use crate::PollIo;
+use futures::{channel::mpsc, task::*, Sink, Stream};
+use pin_project::pin_project;
+use std::io;
+use std::pin::Pin;
+
+/// Returns two unbounded channel peers. Each [`Stream`] yields items sent through the other's
+/// [`Sink`].
+pub fn unbounded<SinkItem, Item>() -> (
+    UnboundedChannel<SinkItem, Item>,
+    UnboundedChannel<Item, SinkItem>,
+) {
+    let (tx1, rx2) = mpsc::unbounded();
+    let (tx2, rx1) = mpsc::unbounded();
+    (
+        UnboundedChannel { tx: tx1, rx: rx1 },
+        UnboundedChannel { tx: tx2, rx: rx2 },
+    )
+}
+
+/// A bi-directional channel backed by an [`UnboundedSender`](mpsc::UnboundedSender)
+/// and [`UnboundedReceiver`](mpsc::UnboundedReceiver).
+#[pin_project]
+#[derive(Debug)]
+pub struct UnboundedChannel<Item, SinkItem> {
+    #[pin]
+    rx: mpsc::UnboundedReceiver<Item>,
+    #[pin]
+    tx: mpsc::UnboundedSender<SinkItem>,
+}
+
+impl<Item, SinkItem> Stream for UnboundedChannel<Item, SinkItem> {
+    type Item = Result<Item, io::Error>;
+
+    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> PollIo<Item> {
+        self.project().rx.poll_next(cx).map(|option| option.map(Ok))
+    }
+}
+
+impl<Item, SinkItem> Sink<SinkItem> for UnboundedChannel<Item, SinkItem> {
+    type Error = io::Error;
+
+    fn poll_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        self.project()
+            .tx
+            .poll_ready(cx)
+            .map_err(|_| io::Error::from(io::ErrorKind::NotConnected))
+    }
+
+    fn start_send(self: Pin<&mut Self>, item: SinkItem) -> io::Result<()> {
+        self.project()
+            .tx
+            .start_send(item)
+            .map_err(|_| io::Error::from(io::ErrorKind::NotConnected))
+    }
+
+    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.project()
+            .tx
+            .poll_flush(cx)
+            .map_err(|_| io::Error::from(io::ErrorKind::NotConnected))
+    }
+
+    fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        self.project()
+            .tx
+            .poll_close(cx)
+            .map_err(|_| io::Error::from(io::ErrorKind::NotConnected))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{
+        client, context,
+        server::{Handler, Server},
+        transport,
+    };
+    use assert_matches::assert_matches;
+    use futures::{prelude::*, stream};
+    use log::trace;
+    use std::io;
+
+    #[cfg(feature = "tokio1")]
+    #[tokio::test(threaded_scheduler)]
+    async fn integration() -> io::Result<()> {
+        let _ = env_logger::try_init();
+
+        let (client_channel, server_channel) = transport::channel::unbounded();
+        tokio::spawn(
+            Server::default()
+                .incoming(stream::once(future::ready(server_channel)))
+                .respond_with(|_ctx, request: String| {
+                    future::ready(request.parse::<u64>().map_err(|_| {
+                        io::Error::new(
+                            io::ErrorKind::InvalidInput,
+                            format!("{:?} is not an int", request),
+                        )
+                    }))
+                }),
+        );
+
+        let mut client = client::new(client::Config::default(), client_channel).spawn()?;
+
+        let response1 = client.call(context::current(), "123".into()).await?;
+        let response2 = client.call(context::current(), "abc".into()).await?;
+
+        trace!("response1: {:?}, response2: {:?}", response1, response2);
+
+        assert_matches!(response1, Ok(123));
+        assert_matches!(response2, Err(ref e) if e.kind() == io::ErrorKind::InvalidInput);
+
+        Ok(())
+    }
+}

tarpc/src/rpc/transport/mod.rs

@@ -0,0 +1,30 @@
+// Copyright 2018 Google LLC
+//
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file or at
+// https://opensource.org/licenses/MIT.
+
+//! Provides a [`Transport`] trait as well as implementations.
+//!
+//! The rpc crate is transport- and protocol-agnostic. Any transport that impls [`Transport`]
+//! can be plugged in, using whatever protocol it wants.
+
+use futures::prelude::*;
+use std::io;
+
+pub mod channel;
+
+pub(crate) mod sealed {
+    use super::*;
+
+    /// A bidirectional stream ([`Sink`] + [`Stream`]) of messages.
+    pub trait Transport<SinkItem, Item>:
+        Stream<Item = io::Result<Item>> + Sink<SinkItem, Error = io::Error>
+    {
+    }
+
+    impl<T, SinkItem, Item> Transport<SinkItem, Item> for T where
+        T: Stream<Item = io::Result<Item>> + Sink<SinkItem, Error = io::Error> + ?Sized
+    {
+    }
+}

tarpc/src/rpc/util/mod.rs

@@ -10,18 +10,17 @@ use std::{
     time::{Duration, SystemTime},
 };
 
-pub mod deadline_compat;
 #[cfg(feature = "serde")]
 pub mod serde;
 
-/// Types that can be represented by a [`Duration`].
-pub trait AsDuration {
-    fn as_duration(&self) -> Duration;
+/// Extension trait for [SystemTimes](SystemTime) in the future, i.e. deadlines.
+pub trait TimeUntil {
+    /// How much time from now until this time is reached.
+    fn time_until(&self) -> Duration;
 }
 
-impl AsDuration for SystemTime {
-    /// Duration of 0 if self is earlier than [`SystemTime::now`].
-    fn as_duration(&self) -> Duration {
+impl TimeUntil for SystemTime {
+    fn time_until(&self) -> Duration {
         self.duration_since(SystemTime::now()).unwrap_or_default()
     }
 }
@@ -38,9 +37,11 @@ where
     H: BuildHasher,
 {
     fn compact(&mut self, usage_ratio_threshold: f64) {
-        let usage_ratio = self.len() as f64 / self.capacity() as f64;
-        if usage_ratio < usage_ratio_threshold {
-            self.shrink_to_fit();
+        if self.capacity() > 1000 {
+            let usage_ratio = self.len() as f64 / self.capacity() as f64;
+            if usage_ratio < usage_ratio_threshold {
+                self.shrink_to_fit();
+            }
         }
     }
 }

tarpc/src/rpc/util/serde.rs

@@ -31,6 +31,7 @@ where
 }
 
 /// Serializes [`io::ErrorKind`] as a `u32`.
+#[allow(clippy::trivially_copy_pass_by_ref)] // Exact fn signature required by serde derive
 pub fn serialize_io_error_kind_as_u32<S>(
     kind: &io::ErrorKind,
     serializer: S,

tarpc/src/serde_transport/mod.rs

@@ -0,0 +1,326 @@
+// Copyright 2019 Google LLC
+//
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file or at
+// https://opensource.org/licenses/MIT.
+
+//! A generic Serde-based `Transport` that can serialize anything supported by `tokio-serde` via any medium that implements `AsyncRead` and `AsyncWrite`.
+
+#![deny(missing_docs)]
+
+use futures::{prelude::*, task::*};
+use pin_project::pin_project;
+use serde::{Deserialize, Serialize};
+use std::{error::Error, io, pin::Pin};
+use tokio::io::{AsyncRead, AsyncWrite};
+use tokio_serde::{Framed as SerdeFramed, *};
+use tokio_util::codec::{length_delimited::LengthDelimitedCodec, Framed};
+
+/// A transport that serializes to, and deserializes from, a [`TcpStream`].
+#[pin_project]
+pub struct Transport<S, Item, SinkItem, Codec> {
+    #[pin]
+    inner: SerdeFramed<Framed<S, LengthDelimitedCodec>, Item, SinkItem, Codec>,
+}
+
+impl<S, Item, SinkItem, Codec, CodecError> Stream for Transport<S, Item, SinkItem, Codec>
+where
+    S: AsyncWrite + AsyncRead,
+    Item: for<'a> Deserialize<'a>,
+    Codec: Deserializer<Item>,
+    CodecError: Into<Box<dyn std::error::Error + Send + Sync>>,
+    SerdeFramed<Framed<S, LengthDelimitedCodec>, Item, SinkItem, Codec>:
+        Stream<Item = Result<Item, CodecError>>,
+{
+    type Item = io::Result<Item>;
+
+    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<io::Result<Item>>> {
+        match self.project().inner.poll_next(cx) {
+            Poll::Pending => Poll::Pending,
+            Poll::Ready(None) => Poll::Ready(None),
+            Poll::Ready(Some(Ok::<_, CodecError>(next))) => Poll::Ready(Some(Ok(next))),
+            Poll::Ready(Some(Err::<_, CodecError>(e))) => {
+                Poll::Ready(Some(Err(io::Error::new(io::ErrorKind::Other, e))))
+            }
+        }
+    }
+}
+
+impl<S, Item, SinkItem, Codec, CodecError> Sink<SinkItem> for Transport<S, Item, SinkItem, Codec>
+where
+    S: AsyncWrite,
+    SinkItem: Serialize,
+    Codec: Serializer<SinkItem>,
+    CodecError: Into<Box<dyn Error + Send + Sync>>,
+    SerdeFramed<Framed<S, LengthDelimitedCodec>, Item, SinkItem, Codec>:
+        Sink<SinkItem, Error = CodecError>,
+{
+    type Error = io::Error;
+
+    fn poll_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        convert(self.project().inner.poll_ready(cx))
+    }
+
+    fn start_send(self: Pin<&mut Self>, item: SinkItem) -> io::Result<()> {
+        self.project()
+            .inner
+            .start_send(item)
+            .map_err(|e| io::Error::new(io::ErrorKind::Other, e))
+    }
+
+    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        convert(self.project().inner.poll_flush(cx))
+    }
+
+    fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        convert(self.project().inner.poll_close(cx))
+    }
+}
+
+fn convert<E: Into<Box<dyn Error + Send + Sync>>>(
+    poll: Poll<Result<(), E>>,
+) -> Poll<io::Result<()>> {
+    poll.map(|ready| ready.map_err(|e| io::Error::new(io::ErrorKind::Other, e)))
+}
+
+impl<S, Item, SinkItem, Codec> From<(S, Codec)> for Transport<S, Item, SinkItem, Codec>
+where
+    S: AsyncWrite + AsyncRead,
+    Item: for<'de> Deserialize<'de>,
+    SinkItem: Serialize,
+    Codec: Serializer<SinkItem> + Deserializer<Item>,
+{
+    fn from((inner, codec): (S, Codec)) -> Self {
+        Transport {
+            inner: SerdeFramed::new(Framed::new(inner, LengthDelimitedCodec::new()), codec),
+        }
+    }
+}
+
+#[cfg(feature = "tcp")]
+#[cfg_attr(docsrs, doc(cfg(feature = "tcp")))]
+/// TCP support for generic transport using Tokio.
+pub mod tcp {
+    use {
+        super::*,
+        futures::ready,
+        std::{marker::PhantomData, net::SocketAddr},
+        tokio::net::{TcpListener, TcpStream, ToSocketAddrs},
+    };
+
+    mod private {
+        use super::*;
+
+        pub trait Sealed {}
+
+        impl<Item, SinkItem, Codec> Sealed for Transport<TcpStream, Item, SinkItem, Codec> {}
+    }
+
+    impl<Item, SinkItem, Codec> Transport<TcpStream, Item, SinkItem, Codec> {
+        /// Returns the peer address of the underlying TcpStream.
+        pub fn peer_addr(&self) -> io::Result<SocketAddr> {
+            self.inner.get_ref().get_ref().peer_addr()
+        }
+        /// Returns the local address of the underlying TcpStream.
+        pub fn local_addr(&self) -> io::Result<SocketAddr> {
+            self.inner.get_ref().get_ref().local_addr()
+        }
+    }
+
+    /// Returns a new JSON transport that reads from and writes to `io`.
+    pub fn new<Item, SinkItem, Codec>(
+        io: TcpStream,
+        codec: Codec,
+    ) -> Transport<TcpStream, Item, SinkItem, Codec>
+    where
+        Item: for<'de> Deserialize<'de>,
+        SinkItem: Serialize,
+        Codec: Serializer<SinkItem> + Deserializer<Item>,
+    {
+        Transport::from((io, codec))
+    }
+
+    /// Connects to `addr`, wrapping the connection in a JSON transport.
+    pub async fn connect<A, Item, SinkItem, Codec>(
+        addr: A,
+        codec: Codec,
+    ) -> io::Result<Transport<TcpStream, Item, SinkItem, Codec>>
+    where
+        A: ToSocketAddrs,
+        Item: for<'de> Deserialize<'de>,
+        SinkItem: Serialize,
+        Codec: Serializer<SinkItem> + Deserializer<Item>,
+    {
+        Ok(new(TcpStream::connect(addr).await?, codec))
+    }
+
+    /// Listens on `addr`, wrapping accepted connections in JSON transports.
+    pub async fn listen<A, Item, SinkItem, Codec, CodecFn>(
+        addr: A,
+        codec_fn: CodecFn,
+    ) -> io::Result<Incoming<Item, SinkItem, Codec, CodecFn>>
+    where
+        A: ToSocketAddrs,
+        Item: for<'de> Deserialize<'de>,
+        Codec: Serializer<SinkItem> + Deserializer<Item>,
+        CodecFn: Fn() -> Codec,
+    {
+        let listener = TcpListener::bind(addr).await?;
+        let local_addr = listener.local_addr()?;
+        Ok(Incoming {
+            listener,
+            codec_fn,
+            local_addr,
+            ghost: PhantomData,
+        })
+    }
+
+    /// A [`TcpListener`] that wraps connections in JSON transports.
+    #[pin_project]
+    #[derive(Debug)]
+    pub struct Incoming<Item, SinkItem, Codec, CodecFn> {
+        listener: TcpListener,
+        local_addr: SocketAddr,
+        codec_fn: CodecFn,
+        ghost: PhantomData<(Item, SinkItem, Codec)>,
+    }
+
+    impl<Item, SinkItem, Codec, CodecFn> Incoming<Item, SinkItem, Codec, CodecFn> {
+        /// Returns the address being listened on.
+        pub fn local_addr(&self) -> SocketAddr {
+            self.local_addr
+        }
+    }
+
+    impl<Item, SinkItem, Codec, CodecFn> Stream for Incoming<Item, SinkItem, Codec, CodecFn>
+    where
+        Item: for<'de> Deserialize<'de>,
+        SinkItem: Serialize,
+        Codec: Serializer<SinkItem> + Deserializer<Item>,
+        CodecFn: Fn() -> Codec,
+    {
+        type Item = io::Result<Transport<TcpStream, Item, SinkItem, Codec>>;
+
+        fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+            let next =
+                ready!(Pin::new(&mut self.as_mut().project().listener.incoming()).poll_next(cx)?);
+            Poll::Ready(next.map(|conn| Ok(new(conn, (self.codec_fn)()))))
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Transport;
+    use assert_matches::assert_matches;
+    use futures::{task::*, Sink, Stream};
+    use pin_utils::pin_mut;
+    use std::{
+        io::{self, Cursor},
+        pin::Pin,
+    };
+    use tokio::io::{AsyncRead, AsyncWrite};
+    use tokio_serde::formats::SymmetricalJson;
+
+    fn ctx() -> Context<'static> {
+        Context::from_waker(&noop_waker_ref())
+    }
+
+    #[test]
+    fn test_stream() {
+        struct TestIo(Cursor<&'static [u8]>);
+
+        impl AsyncRead for TestIo {
+            fn poll_read(
+                mut self: Pin<&mut Self>,
+                cx: &mut Context<'_>,
+                buf: &mut [u8],
+            ) -> Poll<io::Result<usize>> {
+                AsyncRead::poll_read(Pin::new(self.0.get_mut()), cx, buf)
+            }
+        }
+
+        impl AsyncWrite for TestIo {
+            fn poll_write(
+                self: Pin<&mut Self>,
+                _cx: &mut Context<'_>,
+                _buf: &[u8],
+            ) -> Poll<io::Result<usize>> {
+                unreachable!()
+            }
+
+            fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+                unreachable!()
+            }
+
+            fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+                unreachable!()
+            }
+        }
+
+        let data = b"\x00\x00\x00\x18\"Test one, check check.\"";
+        let transport = Transport::from((
+            TestIo(Cursor::new(data)),
+            SymmetricalJson::<String>::default(),
+        ));
+        pin_mut!(transport);
+
+        assert_matches!(
+            transport.poll_next(&mut ctx()),
+            Poll::Ready(Some(Ok(ref s))) if s == "Test one, check check.");
+    }
+
+    #[test]
+    fn test_sink() {
+        struct TestIo<'a>(&'a mut Vec<u8>);
+
+        impl<'a> AsyncRead for TestIo<'a> {
+            fn poll_read(
+                self: Pin<&mut Self>,
+                _cx: &mut Context<'_>,
+                _buf: &mut [u8],
+            ) -> Poll<io::Result<usize>> {
+                unreachable!()
+            }
+        }
+
+        impl<'a> AsyncWrite for TestIo<'a> {
+            fn poll_write(
+                mut self: Pin<&mut Self>,
+                cx: &mut Context<'_>,
+                buf: &[u8],
+            ) -> Poll<io::Result<usize>> {
+                AsyncWrite::poll_write(Pin::new(&mut *self.0), cx, buf)
+            }
+
+            fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+                AsyncWrite::poll_flush(Pin::new(&mut *self.0), cx)
+            }
+
+            fn poll_shutdown(
+                mut self: Pin<&mut Self>,
+                cx: &mut Context<'_>,
+            ) -> Poll<io::Result<()>> {
+                AsyncWrite::poll_shutdown(Pin::new(&mut *self.0), cx)
+            }
+        }
+
+        let mut writer = vec![];
+        let transport =
+            Transport::from((TestIo(&mut writer), SymmetricalJson::<String>::default()));
+        pin_mut!(transport);
+
+        assert_matches!(
+            transport.as_mut().poll_ready(&mut ctx()),
+            Poll::Ready(Ok(()))
+        );
+        assert_matches!(
+            transport
+                .as_mut()
+                .start_send("Test one, check check.".into()),
+            Ok(())
+        );
+        assert_matches!(transport.poll_flush(&mut ctx()), Poll::Ready(Ok(())));
+        assert_eq!(writer, b"\x00\x00\x00\x18\"Test one, check check.\"");
+    }
+}

tarpc/src/trace.rs

@@ -26,11 +26,8 @@ use std::{
 ///
 /// Consists of a span identifying an event, an optional parent span identifying a causal event
 /// that triggered the current span, and a trace with which all related spans are associated.
-#[derive(Debug, PartialEq, Eq, Hash, Clone, Copy)]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Serialize, serde::Deserialize)
-)]
+#[derive(Debug, Default, PartialEq, Eq, Hash, Clone, Copy)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Context {
     /// An identifier of the trace associated with the current context. A trace ID is typically
     /// created at a root span and passed along through all causal events.
@@ -49,19 +46,13 @@ pub struct Context {
 
 /// A 128-bit UUID identifying a trace. All spans caused by the same originating span share the
 /// same trace ID.
-#[derive(Debug, PartialEq, Eq, Hash, Clone, Copy)]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Serialize, serde::Deserialize)
-)]
+#[derive(Debug, Default, PartialEq, Eq, Hash, Clone, Copy)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct TraceId(u128);
 
 /// A 64-bit identifier of a span within a trace. The identifier is unique within the span's trace.
-#[derive(Debug, PartialEq, Eq, Hash, Clone, Copy)]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Serialize, serde::Deserialize)
-)]
+#[derive(Debug, Default, PartialEq, Eq, Hash, Clone, Copy)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct SpanId(u64);
 
 impl Context {
@@ -80,7 +71,7 @@ impl TraceId {
     /// Returns a random trace ID that can be assumed to be globally unique if `rng` generates
     /// actually-random numbers.
     pub fn random<R: Rng>(rng: &mut R) -> Self {
-        TraceId((rng.next_u64() as u128) << mem::size_of::<u64>() | rng.next_u64() as u128)
+        TraceId(u128::from(rng.next_u64()) << mem::size_of::<u64>() | u128::from(rng.next_u64()))
     }
 }
 

tarpc/tests/latency.rs

@@ -1,126 +0,0 @@
-// Copyright 2018 Google LLC
-//
-// Use of this source code is governed by an MIT-style
-// license that can be found in the LICENSE file or at
-// https://opensource.org/licenses/MIT.
-
-#![feature(
-    test,
-    arbitrary_self_types,
-    pin,
-    integer_atomics,
-    futures_api,
-    generators,
-    await_macro,
-    async_await,
-    proc_macro_hygiene
-)]
-
-extern crate test;
-
-use self::test::stats::Stats;
-use futures::{compat::TokioDefaultSpawner, future, prelude::*};
-use rpc::{
-    client, context,
-    server::{Handler, Server},
-};
-use std::{
-    io,
-    time::{Duration, Instant},
-};
-
-mod ack {
-    tarpc::service! {
-        rpc ack();
-    }
-}
-
-#[derive(Clone)]
-struct Serve;
-
-impl ack::Service for Serve {
-    type AckFut = future::Ready<()>;
-
-    fn ack(self, _: context::Context) -> Self::AckFut {
-        future::ready(())
-    }
-}
-
-async fn bench() -> io::Result<()> {
-    let listener = bincode_transport::listen(&"0.0.0.0:0".parse().unwrap())?;
-    let addr = listener.local_addr();
-
-    tokio_executor::spawn(
-        Server::default()
-            .incoming(listener)
-            .take(1)
-            .respond_with(ack::serve(Serve))
-            .unit_error()
-            .boxed()
-            .compat(),
-    );
-
-    let conn = await!(bincode_transport::connect(&addr))?;
-    let mut client = await!(ack::new_stub(client::Config::default(), conn))?;
-
-    let total = 10_000usize;
-    let mut successful = 0u32;
-    let mut unsuccessful = 0u32;
-    let mut durations = vec![];
-    for _ in 1..=total {
-        let now = Instant::now();
-        let response = await!(client.ack(context::current()));
-        let elapsed = now.elapsed();
-
-        match response {
-            Ok(_) => successful += 1,
-            Err(_) => unsuccessful += 1,
-        };
-        durations.push(elapsed);
-    }
-
-    let durations_nanos = durations
-        .iter()
-        .map(|duration| duration.as_secs() as f64 * 1E9 + duration.subsec_nanos() as f64)
-        .collect::<Vec<_>>();
-
-    let (lower, median, upper) = durations_nanos.quartiles();
-
-    println!("Of {:?} runs:", durations_nanos.len());
-    println!("\tSuccessful: {:?}", successful);
-    println!("\tUnsuccessful: {:?}", unsuccessful);
-    println!(
-        "\tMean: {:?}",
-        Duration::from_nanos(durations_nanos.mean() as u64)
-    );
-    println!("\tMedian: {:?}", Duration::from_nanos(median as u64));
-    println!(
-        "\tStd Dev: {:?}",
-        Duration::from_nanos(durations_nanos.std_dev() as u64)
-    );
-    println!(
-        "\tMin: {:?}",
-        Duration::from_nanos(durations_nanos.min() as u64)
-    );
-    println!(
-        "\tMax: {:?}",
-        Duration::from_nanos(durations_nanos.max() as u64)
-    );
-    println!(
-        "\tQuartiles: ({:?}, {:?}, {:?})",
-        Duration::from_nanos(lower as u64),
-        Duration::from_nanos(median as u64),
-        Duration::from_nanos(upper as u64)
-    );
-
-    println!("done");
-    Ok(())
-}
-
-#[test]
-fn bench_small_packet() {
-    env_logger::init();
-    tarpc::init(TokioDefaultSpawner);
-
-    tokio::run(bench().map_err(|e| panic!(e.to_string())).boxed().compat())
-}

tarpc/tests/service_functional.rs

@@ -0,0 +1,112 @@
+use assert_matches::assert_matches;
+use futures::{
+    future::{ready, Ready},
+    prelude::*,
+};
+use std::io;
+use tarpc::{
+    client::{self},
+    context, serde_transport,
+    server::{self, BaseChannel, Channel, Handler},
+    transport::channel,
+};
+use tokio_serde::formats::Json;
+
+#[tarpc_plugins::service]
+trait Service {
+    async fn add(x: i32, y: i32) -> i32;
+    async fn hey(name: String) -> String;
+}
+
+#[derive(Clone)]
+struct Server;
+
+impl Service for Server {
+    type AddFut = Ready<i32>;
+
+    fn add(self, _: context::Context, x: i32, y: i32) -> Self::AddFut {
+        ready(x + y)
+    }
+
+    type HeyFut = Ready<String>;
+
+    fn hey(self, _: context::Context, name: String) -> Self::HeyFut {
+        ready(format!("Hey, {}.", name))
+    }
+}
+
+#[tokio::test(threaded_scheduler)]
+async fn sequential() -> io::Result<()> {
+    let _ = env_logger::try_init();
+
+    let (tx, rx) = channel::unbounded();
+
+    tokio::spawn(
+        BaseChannel::new(server::Config::default(), rx)
+            .respond_with(Server.serve())
+            .execute(),
+    );
+
+    let mut client = ServiceClient::new(client::Config::default(), tx).spawn()?;
+
+    assert_matches!(client.add(context::current(), 1, 2).await, Ok(3));
+    assert_matches!(
+        client.hey(context::current(), "Tim".into()).await,
+        Ok(ref s) if s == "Hey, Tim.");
+
+    Ok(())
+}
+
+#[cfg(feature = "serde1")]
+#[tokio::test(threaded_scheduler)]
+async fn serde() -> io::Result<()> {
+    let _ = env_logger::try_init();
+
+    let transport = serde_transport::tcp::listen("localhost:56789", Json::default).await?;
+    let addr = transport.local_addr();
+    tokio::spawn(
+        tarpc::Server::default()
+            .incoming(transport.take(1).filter_map(|r| async { r.ok() }))
+            .respond_with(Server.serve()),
+    );
+
+    let transport = serde_transport::tcp::connect(addr, Json::default()).await?;
+    let mut client = ServiceClient::new(client::Config::default(), transport).spawn()?;
+
+    assert_matches!(client.add(context::current(), 1, 2).await, Ok(3));
+    assert_matches!(
+        client.hey(context::current(), "Tim".to_string()).await,
+        Ok(ref s) if s == "Hey, Tim."
+    );
+
+    Ok(())
+}
+
+#[tokio::test(threaded_scheduler)]
+async fn concurrent() -> io::Result<()> {
+    let _ = env_logger::try_init();
+
+    let (tx, rx) = channel::unbounded();
+    tokio::spawn(
+        tarpc::Server::default()
+            .incoming(stream::once(ready(rx)))
+            .respond_with(Server.serve()),
+    );
+
+    let client = ServiceClient::new(client::Config::default(), tx).spawn()?;
+
+    let mut c = client.clone();
+    let req1 = c.add(context::current(), 1, 2);
+
+    let mut c = client.clone();
+    let req2 = c.add(context::current(), 3, 4);
+
+    let mut c = client.clone();
+    let req3 = c.hey(context::current(), "Tim".to_string());
+
+    assert_matches!(req1.await, Ok(3));
+    assert_matches!(req2.await, Ok(7));
+    assert_matches!(req3.await, Ok(ref s) if s == "Hey, Tim.");
+
+    Ok(())
+}

trace/Cargo.toml

@@ -1,21 +0,0 @@
-[package]
-name = "tarpc-trace"
-version = "0.1.0"
-authors = ["tikue <tikue@google.com>"]
-edition = '2018'
-license = "MIT"
-documentation = "https://docs.rs/tarpc-trace"
-homepage = "https://github.com/google/tarpc"
-repository = "https://github.com/google/tarpc"
-keywords = ["rpc", "network", "server", "api", "tls"]
-categories = ["asynchronous", "network-programming"]
-readme = "../README.md"
-description = "foundations for tracing in tarpc"
-
-[dependencies]
-rand = "0.5"
-
-[dependencies.serde]
-version = "1.0"
-optional = true
-features = ["derive"]

trace/rustfmt.toml

@@ -1 +0,0 @@
-edition = "2018"