Remove deprecated tokio-proto and replace with homegrown rpc framework (#199)

# New Crates

- crate rpc contains the core client/server request-response framework, as well as a transport trait.
- crate bincode-transport implements a transport that works almost exactly as tarpc works today (not to say it's wire-compatible).
- crate trace has some foundational types for tracing. This isn't really fleshed out yet, but it's useful for in-process log tracing, at least.

All crates are now at the top level. e.g. tarpc-plugins is now tarpc/plugins rather than tarpc/src/plugins. tarpc itself is now a *very* small code surface, as most functionality has been moved into the other more granular crates.

# New Features
- deadlines: all requests specify a deadline, and a server will stop processing a response when past its deadline.
- client cancellation propagation: when a client drops a request, the client sends a message to the server informing it to cancel its response. This means cancellations can propagate across multiple server hops.
- trace context stuff as mentioned above
- more server configuration for total connection limits, per-connection request limits, etc.

# Removals
- no more shutdown handle.  I left it out for now because of time and not being sure what the right solution is.
- all async now, no blocking stub or server interface. This helps with maintainability, and async/await makes async code much more usable. The service trait is thusly renamed Service, and the client is renamed Client.
- no built-in transport. Tarpc is now transport agnostic (see bincode-transport for transitioning existing uses).
- going along with the previous bullet, no preferred transport means no TLS support at this time. We could make a tls transport or make bincode-transport compatible with TLS.
- a lot of examples were removed because I couldn't keep up with maintaining all of them. Hopefully the ones I kept are still illustrative.
- no more plugins!

# Open Questions

1. Should client.send() return `Future<Response>` or `Future<Future<Response>>`? The former appears more ergonomic but it doesn’t allow concurrent requests with a single client handle. The latter is less ergonomic but yields back control of the client once it’s successfully sent out the request. Should we offer fns for both?
2. Should rpc service! Fns take &mut self or &self or self? The service needs to impl Clone anyway, technically we only need to clone it once per connection, and then leave it up to the user to decide if they want to clone it per RPC. In practice, everyone doing nontrivial stuff will need to clone it per RPC, I think.
3. Do the request/response structs look ok?
4. Is supporting server shutdown/lameduck important?

Fixes #178 #155 #124 #104 #83 #38

trace/src/lib.rs

@@ -0,0 +1,105 @@
+// Copyright 2018 Google Inc. All Rights Reserved.
+//
+// Licensed under the MIT License, <LICENSE or http://opensource.org/licenses/MIT>.
+// This file may not be copied, modified, or distributed except according to those terms.
+
+#![deny(missing_docs, missing_debug_implementations)]
+
+//! Provides building blocks for tracing distributed programs.
+//!
+//! A trace is logically a tree of causally-related events called spans. Traces are tracked via a
+//! [context](Context) that identifies the current trace, span, and parent of the current span.  In
+//! distributed systems, a context can be sent from client to server to connect events occurring on
+//! either side.
+//!
+//! This crate's design is based on [opencensus
+//! tracing](https://opencensus.io/core-concepts/tracing/).
+
+use rand::Rng;
+use std::{
+    fmt::{self, Formatter},
+    mem,
+};
+
+/// A context for tracing the execution of processes, distributed or otherwise.
+///
+/// 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)
+)]
+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.
+    pub trace_id: TraceId,
+    /// An identifier of the current span. In typical RPC usage, a span is created by a client
+    /// before making an RPC, and the span ID is sent to the server. The server is free to create
+    /// its own spans, for which it sets the client's span as the parent span.
+    pub span_id: SpanId,
+    /// An identifier of the span that originated the current span. For example, if a server sends
+    /// an RPC in response to a client request that included a span, the server would create a span
+    /// for the RPC and set its parent to the span_id in the incoming request's context.
+    ///
+    /// If `parent_id` is `None`, then this is a root context.
+    pub parent_id: Option<SpanId>,
+}
+
+/// 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)
+)]
+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)
+)]
+pub struct SpanId(u64);
+
+impl Context {
+    /// Constructs a new root context. A root context is one with no parent span.
+    pub fn new_root() -> Self {
+        let rng = &mut rand::thread_rng();
+        Context {
+            trace_id: TraceId::random(rng),
+            span_id: SpanId::random(rng),
+            parent_id: None,
+        }
+    }
+}
+
+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)
+    }
+}
+
+impl SpanId {
+    /// Returns a random span ID that can be assumed to be unique within a single trace.
+    pub fn random<R: Rng>(rng: &mut R) -> Self {
+        SpanId(rng.next_u64())
+    }
+}
+
+impl fmt::Display for TraceId {
+    fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {
+        write!(f, "{:02x}", self.0)?;
+        Ok(())
+    }
+}
+
+impl fmt::Display for SpanId {
+    fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {
+        write!(f, "{:02x}", self.0)?;
+        Ok(())
+    }
+}