prepare v0.2.6 release (#1995)

This fixes an API compatibility regression when `AsyncSeek` was added.

Fixes: #1989

.cirrus.yml

@@ -8,14 +8,18 @@ freebsd_instance:
 task:
   name: FreeBSD 12.0
   env:
-    LOOM_MAX_DURATION: 10
+    LOOM_MAX_PREEMPTIONS: 2
+    RUSTFLAGS: -Dwarnings
   setup_script:
     - pkg install -y curl
     - curl https://sh.rustup.rs -sSf --output rustup.sh
-    - sh rustup.sh -y
+    - sh rustup.sh -y --profile minimal --default-toolchain stable
     - . $HOME/.cargo/env
     - rustup target add i686-unknown-freebsd
     - |
+      echo "~~~~ rustc --version ~~~~"
+      rustc --version
+
       # Remove any existing patch statements
       mv Cargo.toml Cargo.toml.bck
       sed -n '/\[patch.crates-io\]/q;p' Cargo.toml.bck > Cargo.toml
@@ -27,15 +31,12 @@ task:
       echo "~~~~ Cargo.toml ~~~~"
       cat Cargo.toml
       echo "~~~~~~~~~~~~~~~~~~~~"
-  cargo_cache:
-    folder: $HOME/.cargo/registry
   test_script:
     - . $HOME/.cargo/env
-    - cargo test --all --no-fail-fast
-    - cargo doc --all
-  i686_test_script:
-    - . $HOME/.cargo/env
-    - |
-      cargo test --all --exclude tokio-tls --no-fail-fast --target i686-unknown-freebsd
-  before_cache_script:
-    - rm -rf $HOME/.cargo/registry/index
+    - cargo test --all
+    - cargo doc --all --no-deps
+  # TODO: Re-enable
+  # i686_test_script:
+  #   - . $HOME/.cargo/env
+  #   - |
+  #     cargo test --all --exclude tokio-tls --exclude tokio-macros --target i686-unknown-freebsd

CONTRIBUTING.md

@@ -12,10 +12,10 @@ use your help.
 This guide will help you get started. **Do not let this guide intimidate you**.
 It should be considered a map to help you navigate the process.
 
-You may also get help with contributing in the [dev channel][dev], please join
+The [dev channel][dev] is available for any concerns not covered in this guide, please join
 us!
 
-[dev]: https://gitter.im/tokio-rs/dev
+[dev]: https://discord.gg/6yGkFeN
 
 ## Conduct
 
@@ -153,8 +153,6 @@ The type level example for `tokio_timer::Timeout` provides a good example of a
 documentation test:
 
 ```
-/// # extern crate futures;
-/// # extern crate tokio;
 /// // import the `timeout` function, usually this is done
 /// // with `use tokio::prelude::*`
 /// use tokio::prelude::FutureExt;
@@ -192,8 +190,6 @@ If this were a documentation test for the `Timeout::new` function, then the
 example would explicitly use `Timeout::new`. For example:
 
 ```
-/// # extern crate futures;
-/// # extern crate tokio;
 /// use tokio::timer::Timeout;
 /// use futures::Future;
 /// use futures::sync::oneshot;
@@ -385,3 +381,63 @@ _Adapted from the [Node.js contributing guide][node]_.
 [node]: https://github.com/nodejs/node/blob/master/CONTRIBUTING.md
 [hiding-a-comment]: https://help.github.com/articles/managing-disruptive-comments/#hiding-a-comment
 [documentation test]: https://doc.rust-lang.org/rustdoc/documentation-tests.html
+
+## Releasing
+
+Since the Tokio project consists of a number of crates, many of which depend on
+each other, releasing new versions to crates.io can involve some complexities.
+When releasing a new version of a crate, follow these steps:
+
+1. **Ensure that the release crate has no path dependencies.** When the HEAD
+   version of a Tokio crate requires unreleased changes in another Tokio crate,
+   the crates.io dependency on the second crate will be replaced with a path
+   dependency. Crates with path dependencies cannot be published, so before
+   publishing the dependent crate, any path dependencies must also be published.
+   This should be done through a form of depth-first tree traversal:
+
+   1. Starting with the first path dependency in the crate to be released,
+      inspect the `Cargo.toml` for the dependency. If the dependency has any
+      path dependencies of its own, repeat this step with the first such
+      dependency.
+   2. Begin the release process for the path dependency.
+   3. Once the path dependency has been published to crates.io, update the
+      dependent crate to depend on the crates.io version.
+   4. When all path dependencies have been published, the dependent crate may
+      be published.
+
+   To verify that a crate is ready to publish, run:
+
+   ```bash
+   bin/publish --dry-run <CRATE NAME> <CRATE VERSION>
+   ```
+
+2. **Update Cargo metadata.** After releasing any path dependencies, update the
+   `version` field in `Cargo.toml` to the new version, and the `documentation`
+   field to the docs.rs URL of the new version.
+3. **Update other documentation links.** Update the `#![doc(html_root_url)]`
+   attribute in the crate's `lib.rs` and the "Documentation" link in the crate's
+   `README.md` to point to the docs.rs URL of the new version.
+4. **Update the changelog for the crate.** Each crate in the Tokio repository
+   has its own `CHANGELOG.md` in that crate's subdirectory. Any changes to that
+   crate since the last release should be added to the changelog. Change
+   descriptions may be taken from the Git history, but should be edited to
+   ensure a consistent format, based on [Keep A Changelog][keep-a-changelog].
+   Other entries in that crate's changelog may also be used for reference.
+5. **Perform a final audit for breaking changes.** Compare the HEAD version of
+   crate with the Git tag for the most recent release version. If there are any
+   breaking API changes, determine if those changes can be made without breaking
+   existing APIs. If so, resolve those issues. Otherwise, if it is necessary to
+   make a breaking release, update the version numbers to reflect this.
+6. **Open a pull request with your changes.** Once that pull request has been
+   approved by a maintainer and the pull request has been merged, continue to
+   the next step.
+7. **Release the crate.** Run the following command:
+
+   ```bash
+   bin/publish <NAME OF CRATE> <VERSION>
+   ```
+
+   Your editor and prompt you to edit a message for the tag. Copy the changelog
+   entry for that release version into your editor and close the window.
+
+[keep-a-changelog]: https://github.com/olivierlacan/keep-a-changelog/blob/master/CHANGELOG.md

Cargo.toml

@@ -2,22 +2,13 @@
 
 members = [
   "tokio",
-  "tokio-async-await",
-  "tokio-buf",
-  "tokio-codec",
-  "tokio-current-thread",
-  "tokio-executor",
-  "tokio-fs",
-  "tokio-io",
-  "tokio-reactor",
-  "tokio-signal",
-  "tokio-sync",
-  "tokio-threadpool",
-  "tokio-timer",
-  "tokio-tcp",
+  "tokio-macros",
+  "tokio-test",
   "tokio-tls",
-  "tokio-trace",
-  "tokio-trace/tokio-trace-core",
-  "tokio-udp",
-  "tokio-uds",
+  "tokio-util",
+
+  # Internal
+  "examples",
+  "tests-build",
+  "tests-integration",
 ]

README.md

@@ -15,25 +15,22 @@ the Rust programming language. It is:
 [![Crates.io][crates-badge]][crates-url]
 [![MIT licensed][mit-badge]][mit-url]
 [![Build Status][azure-badge]][azure-url]
-[![Gitter chat][gitter-badge]][gitter-url]
+[![Discord chat][discord-badge]][discord-url]
 
 [crates-badge]: https://img.shields.io/crates/v/tokio.svg
 [crates-url]: https://crates.io/crates/tokio
 [mit-badge]: https://img.shields.io/badge/license-MIT-blue.svg
-[mit-url]: LICENSE-MIT
+[mit-url]: LICENSE
 [azure-badge]: https://dev.azure.com/tokio-rs/Tokio/_apis/build/status/tokio-rs.tokio?branchName=master
 [azure-url]: https://dev.azure.com/tokio-rs/Tokio/_build/latest?definitionId=1&branchName=master
-[gitter-badge]: https://img.shields.io/gitter/room/tokio-rs/tokio.svg
-[gitter-url]: https://gitter.im/tokio-rs/tokio
+[discord-badge]: https://img.shields.io/discord/500028886025895936.svg?logo=discord&style=flat-square
+[discord-url]: https://discord.gg/6yGkFeN
 
 [Website](https://tokio.rs) |
-[Guides](https://tokio.rs/docs/getting-started/hello-world/) |
-[API Docs](https://docs.rs/tokio/0.1.18/tokio) |
-[Chat](https://gitter.im/tokio-rs/tokio)
-
-The API docs for the master branch are published [here][master-dox].
-
-[master-dox]: https://tokio-rs.github.io/tokio/doc/tokio/
+[Guides](https://tokio.rs/docs/) |
+[API Docs](https://docs.rs/tokio/latest/tokio) |
+[Roadmap](https://github.com/tokio-rs/tokio/blob/master/ROADMAP.md) |
+[Chat](https://discord.gg/6yGkFeN)
 
 ## Overview
 
@@ -42,72 +39,73 @@ asynchronous applications with the Rust programming language. At a high
 level, it provides a few major components:
 
 * A multithreaded, work-stealing based task [scheduler].
-* A [reactor] backed by the operating system's event queue (epoll, kqueue,
+* A reactor backed by the operating system's event queue (epoll, kqueue,
   IOCP, etc...).
 * Asynchronous [TCP and UDP][net] sockets.
 
 These components provide the runtime components necessary for building
 an asynchronous application.
 
-[net]: https://docs.rs/tokio/0.1.18/tokio/net/index.html
-[reactor]: https://docs.rs/tokio/0.1.18/tokio/reactor/index.html
-[scheduler]: https://docs.rs/tokio/0.1.18/tokio/runtime/index.html
+[net]: https://docs.rs/tokio/latest/tokio/net/index.html
+[scheduler]: https://docs.rs/tokio/latest/tokio/runtime/index.html
 
 ## Example
 
 A basic TCP echo server with Tokio:
 
-```rust
-extern crate tokio;
-
-use tokio::prelude::*;
-use tokio::io::copy;
+```rust,no_run
 use tokio::net::TcpListener;
+use tokio::prelude::*;
 
-fn main() {
-    // Bind the server's socket.
-    let addr = "127.0.0.1:12345".parse().unwrap();
-    let listener = TcpListener::bind(&addr)
-        .expect("unable to bind TCP listener");
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let mut listener = TcpListener::bind("127.0.0.1:8080").await?;
 
-    // Pull out a stream of sockets for incoming connections
-    let server = listener.incoming()
-        .map_err(|e| eprintln!("accept failed = {:?}", e))
-        .for_each(|sock| {
-            // Split up the reading and writing parts of the
-            // socket.
-            let (reader, writer) = sock.split();
+    loop {
+        let (mut socket, _) = listener.accept().await?;
 
-            // A future that echos the data and returns how
-            // many bytes were copied...
-            let bytes_copied = copy(reader, writer);
+        tokio::spawn(async move {
+            let mut buf = [0; 1024];
 
-            // ... after which we'll print what happened.
-            let handle_conn = bytes_copied.map(|amt| {
-                println!("wrote {:?} bytes", amt)
-            }).map_err(|err| {
-                eprintln!("IO error {:?}", err)
-            });
+            // In a loop, read data from the socket and write the data back.
+            loop {
+                let n = match socket.read(&mut buf).await {
+                    // socket closed
+                    Ok(n) if n == 0 => return,
+                    Ok(n) => n,
+                    Err(e) => {
+                        eprintln!("failed to read from socket; err = {:?}", e);
+                        return;
+                    }
+                };
 
-            // Spawn the future as a concurrent task.
-            tokio::spawn(handle_conn)
+                // Write the data back
+                if let Err(e) = socket.write_all(&buf[0..n]).await {
+                    eprintln!("failed to write to socket; err = {:?}", e);
+                    return;
+                }
+            }
         });
-
-    // Start the Tokio runtime
-    tokio::run(server);
+    }
 }
 ```
 
-More examples can be found [here](examples).
+More examples can be found [here](examples). Note that the `master` branch
+is currently being updated to use `async` / `await`. The examples are
+not fully ported. Examples for stable Tokio can be found
+[here](https://github.com/tokio-rs/tokio/tree/v0.1.x/tokio/examples).
+
 
 ## Getting Help
 
 First, see if the answer to your question can be found in the [Guides] or the
 [API documentation]. If the answer is not there, there is an active community in
-the [Tokio Gitter channel][chat]. We would be happy to try to answer your
-question.  Last, if that doesn't work, try opening an [issue] with the question.
+the [Tokio Discord server][chat]. We would be happy to try to answer your
+question. Last, if that doesn't work, try opening an [issue] with the question.
 
-[chat]: https://gitter.im/tokio-rs/tokio
+[Guides]: https://tokio.rs/docs/
+[API documentation]: https://docs.rs/tokio/latest/tokio
+[chat]: https://discord.gg/6yGkFeN
 [issue]: https://github.com/tokio-rs/tokio/issues/new
 
 ## Contributing
@@ -118,54 +116,22 @@ project.
 
 [guide]: CONTRIBUTING.md
 
-## Project layout
+## Related Projects
 
-The `tokio` crate, found at the root, is primarily intended for use by
-application developers.  Library authors should depend on the sub crates, which
-have greater guarantees of stability.
+In addition to the crates in this repository, the Tokio project also maintains
+several other libraries, including:
 
-The crates included as part of Tokio are:
+* [`tracing`] (formerly `tokio-trace`): A framework for application-level
+  tracing and async-aware diagnostics.
 
-* [`tokio-async-await`]: Experimental `async` / `await` support.
+* [`mio`]: A low-level, cross-platform abstraction over OS I/O APIs that powers
+  `tokio`.
 
-* [`tokio-codec`]: Utilities for encoding and decoding protocol frames.
+* [`bytes`]: Utilities for working with bytes, including efficient byte buffers.
 
-* [`tokio-current-thread`]: Schedule the execution of futures on the current
-  thread.
-
-* [`tokio-executor`]: Task execution related traits and utilities.
-
-* [`tokio-fs`]: Filesystem (and standard in / out) APIs.
-
-* [`tokio-io`]: Asynchronous I/O related traits and utilities.
-
-* [`tokio-reactor`]: Event loop that drives I/O resources (like TCP and UDP
-  sockets).
-
-* [`tokio-tcp`]: TCP bindings for use with `tokio-io` and `tokio-reactor`.
-
-* [`tokio-threadpool`]: Schedules the execution of futures across a pool of
-  threads.
-
-* [ `tokio-timer`]: Time related APIs.
-
-* [`tokio-udp`]: UDP bindings for use with `tokio-io` and `tokio-reactor`.
-
-* [`tokio-uds`]: Unix Domain Socket bindings for use with `tokio-io` and
-  `tokio-reactor`.
-
-[`tokio-async-await`]: tokio-async-await
-[`tokio-codec`]: tokio-codec
-[`tokio-current-thread`]: tokio-current-thread
-[`tokio-executor`]: tokio-executor
-[`tokio-fs`]: tokio-fs
-[`tokio-io`]: tokio-io
-[`tokio-reactor`]: tokio-reactor
-[`tokio-tcp`]: tokio-tcp
-[`tokio-threadpool`]: tokio-threadpool
-[`tokio-timer`]: tokio-timer
-[`tokio-udp`]: tokio-udp
-[`tokio-uds`]: tokio-uds
+[`tracing`]: https://github.com/tokio-rs/tracing
+[`mio`]: https://github.com/tokio-rs/mio
+[`bytes`]: https://github.com/tokio-rs/bytes
 
 ## Supported Rust Versions
 

ROADMAP.md

@@ -0,0 +1,67 @@
+# Tokio Roadmap
+
+## A Roadmap to 1.0
+
+The question of "why not 1.0?" has come up a few times. After all, Tokio 0.1 has
+been stable for three years. The short answer: because it isn't time. There is
+nobody who would rather ship a Tokio 1.0 than us. It also isn't something to rush.
+
+After all, `async / await` only landed in the stable Rust channel weeks ago.
+There has been no significant production validation yet, except maybe fuchsia
+and that seems like a fairly specialized use case. This release of Tokio
+includes significant new code and new strategies with feature flags. Also, there
+are still big open questions, such as the [proposed changes][pr-1744] to
+`AsyncRead` and `AsyncWrite`.
+
+Tokio 1.0 will be released as soon as the APIs are proven to handle real-world
+production cases.
+
+### Tokio 1.0 in Q3 2020 with LTS support
+
+The Tokio 1.0 release will be **no later** than Q3 2020. It will also come with
+"long-term support" guarantees:
+
+* A minimum of 5 years of maintenance.
+* A minimum of 3 years before a hypothetical 2.0 release.
+
+When Tokio 1.0 is released in Q3 2020, on-going support, security fixes, and
+critical bug fixes are guaranteed until **at least** Q3 2025. Tokio 2.0 will not
+be released until **at least** Q3 2023 (though, ideally there will never been a
+Tokio 2.0 release).
+
+### How to get there
+
+While Tokio 0.1 probably should have been a 1.0, Tokio 0.2 will be a **true**
+0.2 release. There will breaking change releases every 2 ~ 3 months until 1.0.
+These changes will be **much** smaller than going from 0.1 -> 0.2. It is
+expected that the 1.0 release will look a lot like 0.2.
+
+### What is expected to change
+
+The biggest change will be the `AsyncRead` and `AsyncWrite` traits. Based on
+experience gained over the past 3 years, there are a couple of issues to
+address:
+
+* Be able to **safely** use uninitialized memory as a read buffer.
+* Practical read vectored and write vectored APIs.
+
+There are a few strategies to solve these problems. These strategies need to be
+investigated and the solution validated. You can see [this comment][pr-1744-comment] for a
+detailed statement of the problem.
+
+The other major change, which has been in the works for a while, is updating
+Mio. Mio 0.6 was first released almost 4 years ago and has not had a breaking
+change since. Mio 0.7 has been in the works for a while. It includes a full
+rewrite of the windows support as well as a refined API. More will be written
+about this shortly.
+
+Finally, now that the API is starting to stabilize, effort will be put into
+documentation. Tokio 0.2 is being released before updating the website and many
+of the old content will no longer be relevant. In the coming weeks, expect to
+see updates there.
+
+So, we have our work cut out for us. We hope you enjoy this 0.2 release and are
+looking forward to your feedback and help.
+
+[pr-1744]: https://github.com/tokio-rs/tokio/pull/1744
+[pr-1744-comment]: https://github.com/tokio-rs/tokio/pull/1744#issuecomment-553575438

azure-pipelines.yml

@@ -1,89 +1,61 @@
 trigger: ["master"]
 pr: ["master"]
 
-jobs:
-# Check formatting
-- template: ci/azure-rustfmt.yml
-  parameters:
-    name: rustfmt
+variables:
+  RUSTFLAGS: -Dwarnings
+  nightly: nightly-2019-11-16
 
+jobs:
 # Test top level crate
 - template: ci/azure-test-stable.yml
   parameters:
     name: test_tokio
+    rust: stable
     displayName: Test tokio
     cross: true
     crates:
       - tokio
+      - tests-integration
 
-# Test crates that are platform specific
-- template: ci/azure-test-stable.yml
-  parameters:
-    name: test_sub_cross
-    displayName: Test sub crates -
-    cross: true
-    crates:
-      - tokio-fs
-      - tokio-reactor
-      - tokio-signal
-      - tokio-tcp
-      - tokio-tls
-      - tokio-udp
-      - tokio-uds
-
-# Test crates that are NOT platform specific
+# Test sub crates
 - template: ci/azure-test-stable.yml
   parameters:
     name: test_linux
     displayName: Test sub crates -
-    crates:
-      - tokio-buf
-      - tokio-codec
-      - tokio-current-thread
-      - tokio-executor
-      - tokio-io
-      - tokio-sync
-      - tokio-threadpool
-      - tokio-timer
-      - tokio-trace
-      - tokio-trace/tokio-trace-core
-
-- template: ci/azure-cargo-check.yml
-  parameters:
-    name: features
-    displayName: Check feature permtuations
     rust: stable
     crates:
-      tokio:
-        - codec
-        - fs
-        - io
-        - reactor
-        - rt-full
-        - tcp
-        - timer
-        - udp
-        - uds
-      tokio-buf:
-        - util
+      - tokio-macros
+      - tokio-test
+      - tokio-tls
+      - tokio-util
+      - examples
 
-# Check async / await
-- template: ci/azure-cargo-check.yml
+# Run tests from `tests-build`. This requires a different process
+- template: ci/azure-test-build.yml
   parameters:
-    name: async_await
-    displayName: Async / Await
-    rust: nightly-2019-02-28
-    noDefaultFeatures: ''
-    benches: true
+    name: test_build
+    displayName: Test build permutations
+    rust: stable
+
+# Run loom tests
+- template: ci/azure-loom.yml
+  parameters:
+    name: loom
+    rust: stable
     crates:
-      tokio:
-        - async-await-preview
+      - tokio
 
 # Try cross compiling
 - template: ci/azure-cross-compile.yml
   parameters:
-    name: cross_32bit_linux
-    target: i686-unknown-linux-gnu
+    name: cross
+    rust: stable
+
+# Check each feature works properly
+- template: ci/azure-check-features.yml
+  parameters:
+    rust: $(nightly)
+    name: check_features
 
 # This represents the minimum Rust version supported by
 # Tokio. Updating this should be done in a dedicated PR and
@@ -95,21 +67,42 @@ jobs:
 - template: ci/azure-check-minrust.yml
   parameters:
     name: minrust
-    rust_version: 1.26.0
+    rust: 1.39.0
 
-- template: ci/azure-tsan.yml
+# Check formatting
+- template: ci/azure-rustfmt.yml
   parameters:
-    name: tsan
+    rust: stable
+    name: rustfmt
+
+# Apply clippy lints to all crates
+- template: ci/azure-clippy.yml
+  parameters:
+    rust: stable
+    name: clippy
+
+# Check doc generation
+- template: ci/azure-check-docs.yml
+  parameters:
+    rust: $(nightly)
+    name: docs
+
+# - template: ci/azure-tsan.yml
+#   parameters:
+#     name: tsan
+#     rust: stable
 
 - template: ci/azure-deploy-docs.yml
   parameters:
+    rust: stable
     dependsOn:
       - rustfmt
+      - clippy
       - test_tokio
-      - test_sub_cross
       - test_linux
-      - features
-      - async_await
-      - cross_32bit_linux
+      - test_build
+      - loom
+      - cross
       - minrust
-      - tsan
+      - check_features
+#      - tsan

benches/latency.rs

@@ -1,115 +0,0 @@
-#![feature(test)]
-#![deny(warnings)]
-
-extern crate test;
-#[macro_use]
-extern crate futures;
-extern crate tokio;
-
-use std::io;
-use std::net::SocketAddr;
-use std::thread;
-
-use futures::sync::mpsc;
-use futures::sync::oneshot;
-use futures::{Future, Poll, Sink, Stream};
-use test::Bencher;
-use tokio::net::UdpSocket;
-
-/// UDP echo server
-struct EchoServer {
-    socket: UdpSocket,
-    buf: Vec<u8>,
-    to_send: Option<(usize, SocketAddr)>,
-}
-
-impl EchoServer {
-    fn new(s: UdpSocket) -> Self {
-        EchoServer {
-            socket: s,
-            to_send: None,
-            buf: vec![0u8; 1600],
-        }
-    }
-}
-
-impl Future for EchoServer {
-    type Item = ();
-    type Error = io::Error;
-
-    fn poll(&mut self) -> Poll<(), io::Error> {
-        loop {
-            if let Some(&(size, peer)) = self.to_send.as_ref() {
-                try_ready!(self.socket.poll_send_to(&self.buf[..size], &peer));
-                self.to_send = None;
-            }
-            self.to_send = Some(try_ready!(self.socket.poll_recv_from(&mut self.buf)));
-        }
-    }
-}
-
-#[bench]
-fn udp_echo_latency(b: &mut Bencher) {
-    let any_addr = "127.0.0.1:0".to_string();
-    let any_addr = any_addr.parse::<SocketAddr>().unwrap();
-
-    let (stop_c, stop_p) = oneshot::channel::<()>();
-    let (tx, rx) = oneshot::channel();
-
-    let child = thread::spawn(move || {
-        let socket = tokio::net::UdpSocket::bind(&any_addr).unwrap();
-        tx.send(socket.local_addr().unwrap()).unwrap();
-
-        let server = EchoServer::new(socket);
-        let server = server.select(stop_p.map_err(|_| panic!()));
-        let server = server.map_err(|_| ());
-        server.wait().unwrap();
-    });
-
-    let client = std::net::UdpSocket::bind(&any_addr).unwrap();
-
-    let server_addr = rx.wait().unwrap();
-    let mut buf = [0u8; 1000];
-
-    // warmup phase; for some reason initial couple of
-    // runs are much slower
-    //
-    // TODO: Describe the exact reasons; caching? branch predictor? lazy closures?
-    for _ in 0..8 {
-        client.send_to(&buf, &server_addr).unwrap();
-        let _ = client.recv_from(&mut buf).unwrap();
-    }
-
-    b.iter(|| {
-        client.send_to(&buf, &server_addr).unwrap();
-        let _ = client.recv_from(&mut buf).unwrap();
-    });
-
-    stop_c.send(()).unwrap();
-    child.join().unwrap();
-}
-
-#[bench]
-fn futures_channel_latency(b: &mut Bencher) {
-    let (mut in_tx, in_rx) = mpsc::channel(32);
-    let (out_tx, out_rx) = mpsc::channel::<_>(32);
-
-    let child = thread::spawn(|| out_tx.send_all(in_rx.then(|r| r.unwrap())).wait());
-    let mut rx_iter = out_rx.wait();
-
-    // warmup phase; for some reason initial couple of runs are much slower
-    //
-    // TODO: Describe the exact reasons; caching? branch predictor? lazy closures?
-    for _ in 0..8 {
-        in_tx.start_send(Ok(1usize)).unwrap();
-        let _ = rx_iter.next();
-    }
-
-    b.iter(|| {
-        in_tx.start_send(Ok(1usize)).unwrap();
-        let _ = rx_iter.next();
-    });
-
-    drop(in_tx);
-    child.join().unwrap().unwrap();
-}

benches/mio-ops.rs

@@ -1,57 +0,0 @@
-// Measure cost of different operations
-// to get a sense of performance tradeoffs
-#![feature(test)]
-#![deny(warnings)]
-
-extern crate mio;
-extern crate test;
-
-use test::Bencher;
-
-use mio::tcp::TcpListener;
-use mio::{PollOpt, Ready, Token};
-
-#[bench]
-fn mio_register_deregister(b: &mut Bencher) {
-    let addr = "127.0.0.1:0".parse().unwrap();
-    // Setup the server socket
-    let sock = TcpListener::bind(&addr).unwrap();
-    let poll = mio::Poll::new().unwrap();
-
-    const CLIENT: Token = Token(1);
-
-    b.iter(|| {
-        poll.register(&sock, CLIENT, Ready::readable(), PollOpt::edge())
-            .unwrap();
-        poll.deregister(&sock).unwrap();
-    });
-}
-
-#[bench]
-fn mio_reregister(b: &mut Bencher) {
-    let addr = "127.0.0.1:0".parse().unwrap();
-    // Setup the server socket
-    let sock = TcpListener::bind(&addr).unwrap();
-    let poll = mio::Poll::new().unwrap();
-
-    const CLIENT: Token = Token(1);
-    poll.register(&sock, CLIENT, Ready::readable(), PollOpt::edge())
-        .unwrap();
-
-    b.iter(|| {
-        poll.reregister(&sock, CLIENT, Ready::readable(), PollOpt::edge())
-            .unwrap();
-    });
-    poll.deregister(&sock).unwrap();
-}
-
-#[bench]
-fn mio_poll(b: &mut Bencher) {
-    let poll = mio::Poll::new().unwrap();
-    let timeout = std::time::Duration::new(0, 0);
-    let mut events = mio::Events::with_capacity(1024);
-
-    b.iter(|| {
-        poll.poll(&mut events, Some(timeout)).unwrap();
-    });
-}

benches/tcp.rs

@@ -1,261 +0,0 @@
-#![feature(test)]
-#![deny(warnings)]
-
-extern crate futures;
-extern crate tokio;
-
-#[macro_use]
-extern crate tokio_io;
-
-pub extern crate test;
-
-mod prelude {
-    pub use futures::*;
-    pub use tokio::net::{TcpListener, TcpStream};
-    pub use tokio::reactor::Reactor;
-    pub use tokio_io::io::read_to_end;
-
-    pub use std::io::{self, Read, Write};
-    pub use std::thread;
-    pub use std::time::Duration;
-    pub use test::{self, Bencher};
-}
-
-mod connect_churn {
-    use prelude::*;
-
-    const NUM: usize = 300;
-    const CONCURRENT: usize = 8;
-
-    #[bench]
-    fn one_thread(b: &mut Bencher) {
-        let addr = "127.0.0.1:0".parse().unwrap();
-
-        b.iter(move || {
-            let listener = TcpListener::bind(&addr).unwrap();
-            let addr = listener.local_addr().unwrap();
-
-            // Spawn a single future that accepts & drops connections
-            let serve_incomings = listener
-                .incoming()
-                .map_err(|e| panic!("server err: {:?}", e))
-                .for_each(|_| Ok(()));
-
-            let connects = stream::iter_result((0..NUM).map(|_| {
-                Ok(TcpStream::connect(&addr).and_then(|sock| {
-                    sock.set_linger(Some(Duration::from_secs(0))).unwrap();
-                    read_to_end(sock, vec![])
-                }))
-            }));
-
-            let connects_concurrent = connects
-                .buffer_unordered(CONCURRENT)
-                .map_err(|e| panic!("client err: {:?}", e))
-                .for_each(|_| Ok(()));
-
-            serve_incomings
-                .select(connects_concurrent)
-                .map(|_| ())
-                .map_err(|_| ())
-                .wait()
-                .unwrap();
-        });
-    }
-
-    fn n_workers(n: usize, b: &mut Bencher) {
-        let (shutdown_tx, shutdown_rx) = sync::oneshot::channel();
-        let (addr_tx, addr_rx) = sync::oneshot::channel();
-
-        // Spawn reactor thread
-        let server_thread = thread::spawn(move || {
-            // Bind the TCP listener
-            let listener = TcpListener::bind(&"127.0.0.1:0".parse().unwrap()).unwrap();
-
-            // Get the address being listened on.
-            let addr = listener.local_addr().unwrap();
-
-            // Send the remote & address back to the main thread
-            addr_tx.send(addr).unwrap();
-
-            // Spawn a single future that accepts & drops connections
-            let serve_incomings = listener
-                .incoming()
-                .map_err(|e| panic!("server err: {:?}", e))
-                .for_each(|_| Ok(()));
-
-            // Run server
-            serve_incomings
-                .select(shutdown_rx)
-                .map(|_| ())
-                .map_err(|_| ())
-                .wait()
-                .unwrap();
-        });
-
-        // Get the bind addr of the server
-        let addr = addr_rx.wait().unwrap();
-
-        b.iter(move || {
-            use std::sync::{Arc, Barrier};
-
-            // Create a barrier to coordinate threads
-            let barrier = Arc::new(Barrier::new(n + 1));
-
-            // Spawn worker threads
-            let threads: Vec<_> = (0..n)
-                .map(|_| {
-                    let barrier = barrier.clone();
-                    let addr = addr.clone();
-
-                    thread::spawn(move || {
-                        let connects = stream::iter_result((0..(NUM / n)).map(|_| {
-                            Ok(TcpStream::connect(&addr)
-                                .map_err(|e| panic!("connect err: {:?}", e))
-                                .and_then(|sock| {
-                                    sock.set_linger(Some(Duration::from_secs(0))).unwrap();
-                                    read_to_end(sock, vec![])
-                                }))
-                        }));
-
-                        barrier.wait();
-
-                        connects
-                            .buffer_unordered(CONCURRENT)
-                            .map_err(|e| panic!("client err: {:?}", e))
-                            .for_each(|_| Ok(()))
-                            .wait()
-                            .unwrap();
-                    })
-                })
-                .collect();
-
-            barrier.wait();
-
-            for th in threads {
-                th.join().unwrap();
-            }
-        });
-
-        // Shutdown the server
-        shutdown_tx.send(()).unwrap();
-        server_thread.join().unwrap();
-    }
-
-    #[bench]
-    fn two_threads(b: &mut Bencher) {
-        n_workers(1, b);
-    }
-
-    #[bench]
-    fn multi_threads(b: &mut Bencher) {
-        n_workers(4, b);
-    }
-}
-
-mod transfer {
-    use prelude::*;
-    use std::{cmp, mem};
-
-    const MB: usize = 3 * 1024 * 1024;
-
-    struct Drain {
-        sock: TcpStream,
-        chunk: usize,
-    }
-
-    impl Future for Drain {
-        type Item = ();
-        type Error = io::Error;
-
-        fn poll(&mut self) -> Poll<(), io::Error> {
-            let mut buf: [u8; 1024] = unsafe { mem::uninitialized() };
-
-            loop {
-                match try_nb!(self.sock.read(&mut buf[..self.chunk])) {
-                    0 => return Ok(Async::Ready(())),
-                    _ => {}
-                }
-            }
-        }
-    }
-
-    struct Transfer {
-        sock: TcpStream,
-        rem: usize,
-        chunk: usize,
-    }
-
-    impl Future for Transfer {
-        type Item = ();
-        type Error = io::Error;
-
-        fn poll(&mut self) -> Poll<(), io::Error> {
-            while self.rem > 0 {
-                let len = cmp::min(self.rem, self.chunk);
-                let buf = &DATA[..len];
-
-                let n = try_nb!(self.sock.write(&buf));
-                self.rem -= n;
-            }
-
-            Ok(Async::Ready(()))
-        }
-    }
-
-    static DATA: [u8; 1024] = [0; 1024];
-
-    fn one_thread(b: &mut Bencher, read_size: usize, write_size: usize) {
-        let addr = "127.0.0.1:0".parse().unwrap();
-
-        b.iter(move || {
-            let listener = TcpListener::bind(&addr).unwrap();
-            let addr = listener.local_addr().unwrap();
-
-            // Spawn a single future that accepts 1 connection, Drain it and drops
-            let server = listener
-                .incoming()
-                .into_future() // take the first connection
-                .map_err(|(e, _other_incomings)| e)
-                .map(|(connection, _other_incomings)| connection.unwrap())
-                .and_then(|sock| {
-                    sock.set_linger(Some(Duration::from_secs(0))).unwrap();
-                    let drain = Drain {
-                        sock: sock,
-                        chunk: read_size,
-                    };
-                    drain
-                        .map(|_| ())
-                        .map_err(|e| panic!("server error: {:?}", e))
-                })
-                .map_err(|e| panic!("server err: {:?}", e));
-
-            let client = TcpStream::connect(&addr)
-                .and_then(move |sock| Transfer {
-                    sock: sock,
-                    rem: MB,
-                    chunk: write_size,
-                })
-                .map_err(|e| panic!("client err: {:?}", e));
-
-            server.join(client).wait().unwrap();
-        });
-    }
-
-    mod small_chunks {
-        use prelude::*;
-
-        #[bench]
-        fn one_thread(b: &mut Bencher) {
-            super::one_thread(b, 32, 32);
-        }
-    }
-
-    mod big_chunks {
-        use prelude::*;
-
-        #[bench]
-        fn one_thread(b: &mut Bencher) {
-            super::one_thread(b, 1_024, 1_024);
-        }
-    }
-}

bin/publish

@@ -0,0 +1,121 @@
+#!/usr/bin/env bash
+set -e
+USAGE="Publish a new release of a tokio crate
+
+USAGE:
+    $(basename "$0") [OPTIONS] [CRATE] [VERSION]
+
+OPTIONS:
+    -v, --verbose   Use verbose Cargo output
+    -d, --dry-run   Perform a dry run (do not publish or tag the release)
+    -h, --help      Show this help text and exit"
+
+DRY_RUN=""
+VERBOSE=""
+
+err() {
+    echo -e "\e[31m\e[1merror:\e[0m $@" 1>&2;
+}
+
+status() {
+    WIDTH=12
+    printf "\e[32m\e[1m%${WIDTH}s\e[0m %s\n" "$1" "$2"
+}
+
+verify() {
+    status "Verifying" "if $CRATE v$VERSION can be released"
+    ACTUAL=$(cargo pkgid | sed -n 's/.*#\(.*\)/\1/p')
+
+    if [ "$ACTUAL" != "$VERSION" ]; then
+        err "expected to release version $VERSION, but Cargo.toml contained $ACTUAL"
+        exit 1
+    fi
+
+    if git tag -l | grep -Fxq "$TAG" ; then
+        err "git tag \`$TAG\` already exists"
+        exit 1
+    fi
+
+    PATH_DEPS=$(grep -F "path = \"" Cargo.toml | sed -e 's/^/  /')
+    if [ -n "$PATH_DEPS" ]; then
+        err "crate \`$CRATE\` contained path dependencies:\n$PATH_DEPS"
+        echo "path dependencies must be removed prior to release"
+        exit 1
+    fi
+}
+
+release() {
+    status "Releasing" "$CRATE v$VERSION"
+    cargo package $VERBOSE
+    cargo publish $VERBOSE $DRY_RUN
+
+    status "Tagging" "$TAG"
+    if [ -n "$DRY_RUN" ]; then
+        echo "# git tag $TAG && git push --tags"
+    else
+        git tag "$TAG" && git push --tags
+    fi
+}
+
+while [[ $# -gt 0 ]]
+do
+
+case "$1" in
+    -h|--help)
+    echo "$USAGE"
+    exit 0
+    ;;
+    -v|--verbose)
+    VERBOSE="--verbose"
+    set +x
+    shift
+    ;;
+    -d|--dry-run)
+    DRY_RUN="--dry-run"
+    shift
+    ;;
+    -*)
+    err "unknown flag \"$1\""
+    echo "$USAGE"
+    exit 1
+    ;;
+    *) # crate or version
+    if [ -z "$CRATE" ]; then
+        CRATE="$1"
+    elif [ -z "$VERSION" ]; then
+        VERSION="$1"
+    else
+        err "unknown positional argument \"$1\""
+        echo "$USAGE"
+        exit 1
+    fi
+    shift
+    ;;
+esac
+done
+# set -- "${POSITIONAL[@]}"
+
+if [ -z "$VERSION" ]; then
+    err "no version specified!"
+    HELP=1
+fi
+
+if [ -n "$CRATE" ]; then
+    TAG="$CRATE-$VERSION"
+else
+    err "no crate specified!"
+    HELP=1
+fi
+
+if [ -n "$HELP" ]; then
+    echo "$USAGE"
+    exit 1
+fi
+
+if [ -d "$CRATE" ]; then
+    (cd "$CRATE" && verify && release )
+else
+    err "no such crate \"$CRATE\""
+    exit 1
+fi
+

bin/update-doc

@@ -0,0 +1,118 @@
+#!/usr/bin/env bash
+set -e
+USAGE="Update links to docs.rs in a tokio crate
+
+USAGE:
+    $(basename "$0") [OPTIONS] [CRATE] [VERSION]
+
+OPTIONS:
+    -d, --dry-run       Perform a dry run (do not modify any file)
+    -h, --help          Show this help text and exit"
+
+err() {
+    echo -e "\e[31m\e[1merror:\e[0m $@" 1>&2;
+}
+
+status() {
+    WIDTH=12
+    printf "\e[32m\e[1m%${WIDTH}s\e[0m %s\n" "$1" "$2"
+}
+
+c1grep() { grep "$@" || test $? = 1; }
+
+update_versions_in_doc() {
+    # Print what is being/would be done
+    if [ -n "$DRY_RUN" ]; then
+        local MSG="Would change:"
+    else
+        local MSG="Updating:"
+    fi
+    git grep -lr "docs.rs/$CRATE/" \
+        | xargs sed --quiet \
+            -E "s|docs.rs/$CRATE/[0-9.]+|docs.rs/$CRATE/$VERSION|gp" \
+        | sed -e "s/^/$MSG /"
+
+    # Apply changes if not in dry run
+    if [ -z "$DRY_RUN" ]; then
+        git grep -lr "docs.rs/$CRATE/" \
+            | xargs sed -i \
+                -E "s|docs.rs/$CRATE/[0-9.]+|docs.rs/$CRATE/$VERSION|g"
+    fi
+}
+
+update() {
+    update_versions_in_doc
+}
+
+show_outdated() {
+    OUTDATED=$(git grep -rn "docs.rs/$CRATE/" \
+        | c1grep -v "$VERSION" \
+        | sed -e 's/^/ - /')
+    if [[ -n "$OUTDATED" ]]; then
+        echo "Found the following links to docs.rs with an outdated version:"
+        echo "$OUTDATED"
+        echo
+    else
+        echo "Nothing to do."
+        exit 1
+    fi
+}
+
+while [[ $# -gt 0 ]]
+do
+
+case "$1" in
+    -h|--help)
+    echo "$USAGE"
+    exit 0
+    ;;
+    -d|--dry-run)
+    DRY_RUN="--dry-run"
+    shift
+    ;;
+    -*)
+    err "unknown flag \"$1\""
+    echo "$USAGE"
+    exit 1
+    ;;
+    *) # crate or version
+    if [ -z "$CRATE" ]; then
+        CRATE="$1"
+    elif [ -z "$VERSION" ]; then
+        VERSION="$1"
+    else
+        err "unknown positional argument \"$1\""
+        echo "$USAGE"
+        exit 1
+    fi
+    shift
+    ;;
+esac
+done
+# set -- "${POSITIONAL[@]}"
+
+if [ -z "$VERSION" ]; then
+    err "no version specified!"
+    HELP=1
+fi
+
+if [ -n "$CRATE" ]; then
+    TAG="$CRATE-$VERSION"
+else
+    err "no crate specified!"
+    HELP=1
+fi
+
+if [ -n "$HELP" ]; then
+    echo "$USAGE"
+    exit 1
+fi
+
+if [ -d "$CRATE" ]; then
+    # Does not cd in order to update everywhere
+    show_outdated && update
+else
+    err "no such crate \"$CRATE\""
+    exit 1
+fi
+

ci/azure-cargo-check.yml

@@ -27,7 +27,3 @@ jobs:
       - script: cargo check ${{ parameters.noDefaultFeatures }} --features ${{ feature }}
         displayName: Check `${{ crate.key }}`, features = ${{ feature }}
         workingDirectory: $(Build.SourcesDirectory)/${{ crate.key }}
-
-  - ${{ if parameters.benches }}:
-    - script: cargo check --benches --all
-      displayName: Check benchmarks

ci/azure-check-docs.yml

@@ -0,0 +1,15 @@
+jobs:
+# Check docs
+- job: ${{ parameters.name }}
+  displayName: Check docs
+  pool:
+    vmImage: ubuntu-16.04
+  steps:
+    - template: azure-install-rust.yml
+      parameters:
+        rust_version: ${{ parameters.rust }}
+
+    - script: |
+        RUSTDOCFLAGS="--cfg docsrs" cargo doc --lib --no-deps --all-features
+      displayName: Check docs
+

ci/azure-check-features.yml

@@ -0,0 +1,32 @@
+jobs:
+- job: ${{ parameters.name }}
+  displayName: Check features
+  strategy:
+    matrix:
+      Linux:
+        vmImage: ubuntu-16.04
+      MacOS:
+        vmImage: macOS-10.13
+      Windows:
+        vmImage: vs2017-win2016
+  pool:
+    vmImage: $(vmImage)
+
+  steps:
+  - template: azure-install-rust.yml
+    parameters:
+      rust_version: ${{ parameters.rust }}
+
+  - template: azure-patch-crates.yml
+
+  - script: cargo install cargo-hack
+    displayName: Install cargo-hack
+
+  # Check each feature works properly
+  # * --each-feature
+  #   run for each feature which includes --no-default-features and default features of package
+  # * -Z avoid-dev-deps
+  #   build without dev-dependencies to avoid https://github.com/rust-lang/cargo/issues/4866
+  #   tracking-issue: https://github.com/rust-lang/cargo/issues/5133
+  - script: cargo hack check --all --each-feature -Z avoid-dev-deps
+    displayName: cargo hack check --all --each-feature

ci/azure-check-minrust.yml

@@ -6,7 +6,7 @@ jobs:
   steps:
   - template: azure-install-rust.yml
     parameters:
-      rust_version: ${{ parameters.rust_version }}
+      rust_version: ${{ parameters.rust }}
 
   - template: azure-patch-crates.yml
 

ci/azure-clippy.yml

@@ -0,0 +1,16 @@
+jobs:
+- job: ${{ parameters.name }}
+  displayName: Clippy
+  pool:
+    vmImage: ubuntu-16.04
+  steps:
+    - template: azure-install-rust.yml
+      parameters:
+        rust_version: ${{ parameters.rust }}
+    - script: |
+        rustup component add clippy
+        cargo clippy --version
+      displayName: Install clippy
+    - script: |
+        cargo clippy --all --all-features -- -A clippy::mutex-atomic -A clippy::needless-doctest-main
+      displayName: cargo clippy --all

ci/azure-cross-compile.yml

@@ -1,24 +1,44 @@
 jobs:
 - job: ${{ parameters.name }}
   displayName: ${{ parameters.displayName }}
+  strategy:
+    matrix:
+      i686:
+        vmImage: ubuntu-16.04
+        target: i686-unknown-linux-gnu
+      powerpc:
+        vmImage: ubuntu-16.04
+        target: powerpc-unknown-linux-gnu
+      powerpc64:
+        vmImage: ubuntu-16.04
+        target: powerpc64-unknown-linux-gnu
+      mips:
+        vmImage: ubuntu-16.04
+        target: mips-unknown-linux-gnu
+      arm:
+        vmImage: ubuntu-16.04
+        target: arm-linux-androideabi
   pool:
-    vmImage: ubuntu-16.04
+    vmImage: $(vmImage)
   steps:
   - template: azure-install-rust.yml
     parameters:
-      rust_version: stable
+      rust_version: ${{ parameters.rust }}
+
+  - script: sudo apt-get update
+    displayName: apt-get update
 
   - script: sudo apt-get install gcc-multilib
-    displayName: "Install gcc-multilib"
+    displayName: Install gcc-multilib
 
-  - script: rustup target add ${{ parameters.target }}
-    displayName: "Add target"
+  - script: cargo install cross
+    displayName: Install cross
 
   # Always patch
   - template: azure-patch-crates.yml
 
-  - script: cargo check --all --exclude tokio-tls --target ${{ parameters.target }}
+  - script: cross check --all --exclude tokio-tls --target $(target)
     displayName: Check source
 
-  - script: cargo check --tests --all --exclude tokio-tls --target ${{ parameters.target }}
-    displayName: Check tests
+  # - script: cross check --tests --all --exclude tokio-tls --target $(target)
+  #   displayName: Check tests

ci/azure-deploy-docs.yml

@@ -12,9 +12,10 @@ jobs:
   steps:
   - template: azure-install-rust.yml
     parameters:
-      rust_version: stable
+      # rust_version: stable
+      rust_version: ${{ parameters.rust }}
   - script: |
-      cargo doc --all --no-deps
+      cargo doc --all --no-deps --all-features
       cp -R target/doc '$(Build.BinariesDirectory)'
     displayName: 'Generate Documentation'
   - script: |

ci/azure-install-rust.yml

@@ -2,7 +2,10 @@ steps:
   # Linux and macOS.
   - script: |
       set -e
-      curl https://sh.rustup.rs -sSf | sh -s -- -y --default-toolchain $RUSTUP_TOOLCHAIN
+      curl https://sh.rustup.rs -sSf | sh -s -- -y --profile minimal --default-toolchain none
+      export PATH=$PATH:$HOME/.cargo/bin
+      rustup toolchain install $RUSTUP_TOOLCHAIN
+      rustup default $RUSTUP_TOOLCHAIN
       echo "##vso[task.setvariable variable=PATH;]$PATH:$HOME/.cargo/bin"
     env:
       RUSTUP_TOOLCHAIN: ${{parameters.rust_version}}
@@ -12,8 +15,10 @@ steps:
   # Windows.
   - script: |
       curl -sSf -o rustup-init.exe https://win.rustup.rs
-      rustup-init.exe -y --default-toolchain %RUSTUP_TOOLCHAIN%
+      rustup-init.exe -y --profile minimal --default-toolchain none
       set PATH=%PATH%;%USERPROFILE%\.cargo\bin
+      rustup toolchain install %RUSTUP_TOOLCHAIN%
+      rustup default %RUSTUP_TOOLCHAIN%
       echo "##vso[task.setvariable variable=PATH;]%PATH%;%USERPROFILE%\.cargo\bin"
     env:
       RUSTUP_TOOLCHAIN: ${{parameters.rust_version}}
@@ -22,6 +27,7 @@ steps:
 
   # All platforms.
   - script: |
+        rustup toolchain list
         rustc -Vv
         cargo -V
     displayName: Query rust and cargo versions

ci/azure-is-release.yml

@@ -2,7 +2,7 @@ steps:
   - bash: |
       set -e
 
-      if git log --no-merges -1 --format='%s' | grep -q '[ci-release]'; then
+      if git log --no-merges -1 --format='%B' | grep -qF '[ci-release]'; then
         echo "##vso[task.setvariable variable=isRelease]true"
       fi
     failOnStderr: true

ci/azure-loom.yml

@@ -0,0 +1,18 @@
+jobs:
+- job: ${{ parameters.name }}
+  displayName: Loom tests
+  pool:
+    vmImage: ubuntu-16.04
+
+  steps:
+  - template: azure-install-rust.yml
+    parameters:
+      rust_version: ${{ parameters.rust }}
+
+  - ${{ each crate in parameters.crates }}:
+    - script: RUSTFLAGS="--cfg loom" cargo test --lib --release --features "full" -- --test-threads=1 --nocapture
+      env:
+        LOOM_MAX_PREEMPTIONS: 1
+        CI: 'True'
+      displayName: test ${{ crate }}
+      workingDirectory: $(Build.SourcesDirectory)/${{ crate }}

ci/azure-rustfmt.yml

@@ -7,9 +7,10 @@ jobs:
   steps:
     - template: azure-install-rust.yml
       parameters:
-        rust_version: stable
+        rust_version: ${{ parameters.rust }}
     - script: |
         rustup component add rustfmt
+        cargo fmt --version
       displayName: Install rustfmt
     - script: |
         cargo fmt --all -- --check

ci/azure-test-build.yml

@@ -0,0 +1,17 @@
+jobs:
+- job: ${{ parameters.name }}
+  displayName: ${{ parameters.displayName }}
+  pool:
+    vmImage: 'Ubuntu 16.04'
+
+  steps:
+  - template: azure-install-rust.yml
+    parameters:
+      rust_version: ${{ parameters.rust }}
+
+  - script: cargo install cargo-hack
+    displayName: Install cargo-hack
+
+  - script: cargo hack test --each-feature
+    displayName: cargo hack test --each-feature
+    workingDirectory: $(Build.SourcesDirectory)/tests-build

ci/azure-test-nightly.yml

@@ -0,0 +1,19 @@
+jobs:
+- job: ${{ parameters.name }}
+  displayName: ${{ parameters.displayName }}
+  pool:
+    vmImage: ubuntu-16.04
+
+  steps:
+  - template: azure-install-rust.yml
+    parameters:
+      rust_version: ${{ parameters.rust }}
+
+  - template: azure-patch-crates.yml
+
+  - script: cargo check --all
+    displayName: cargo check --all
+
+  # Check benches
+  - script: cargo check --benches --all
+    displayName: Check benchmarks

ci/azure-test-stable.yml

@@ -17,25 +17,26 @@ jobs:
   steps:
   - template: azure-install-rust.yml
     parameters:
-      rust_version: stable
+      rust_version: ${{ parameters.rust }}
 
   - template: azure-is-release.yml
 
   - ${{ each crate in parameters.crates }}:
-    - script: cargo test
+    # Run with all crate features
+    - script: cargo test --all-features
       env:
-        LOOM_MAX_DURATION: 10
+        LOOM_MAX_PREEMPTIONS: 2
         CI: 'True'
-      displayName: cargo test -p ${{ crate }}
+      displayName: ${{ crate }} - cargo test --all-features
       workingDirectory: $(Build.SourcesDirectory)/${{ crate }}
-      condition: and(succeeded(), not(variables['isRelease']))
 
   - template: azure-patch-crates.yml
 
   - ${{ each crate in parameters.crates }}:
-    - script: cargo test
+    # Run with all crate features
+    - script: cargo test --all-features
       env:
-        LOOM_MAX_DURATION: 10
+        LOOM_MAX_PREEMPTIONS: 2
         CI: 'True'
-      displayName: cargo test -p ${{ crate }} (PATCHED)
+      displayName: ${{ crate }} - cargo test --all-features
       workingDirectory: $(Build.SourcesDirectory)/${{ crate }}

ci/azure-tsan.yml

@@ -5,14 +5,12 @@ jobs:
     matrix:
       Timer:
         cmd: cargo test -p tokio-timer --test hammer
-      Threadpool:
-        cmd: cargo test -p tokio-threadpool --tests
   pool:
     vmImage: ubuntu-16.04
   steps:
   - template: azure-install-rust.yml
     parameters:
-      rust_version: nightly-2018-11-18
+      rust_version: ${{ parameters.rust }}
 
   - template: azure-patch-crates.yml
   - script: |

ci/patch.toml

@@ -2,21 +2,7 @@
 # repository.
 [patch.crates-io]
 tokio = { path = "tokio" }
-tokio-async-await = { path = "tokio-async-await" }
-tokio-buf = { path = "tokio-buf" }
-tokio-codec = { path = "tokio-codec" }
-tokio-current-thread = { path = "tokio-current-thread" }
-tokio-executor = { path = "tokio-executor" }
-tokio-fs = { path = "tokio-fs" }
-tokio-io = { path = "tokio-io" }
-tokio-reactor = { path = "tokio-reactor" }
-tokio-signal = { path = "tokio-signal" }
-tokio-sync = { path = "tokio-sync" }
-tokio-threadpool = { path = "tokio-threadpool" }
-tokio-timer = { path = "tokio-timer" }
-tokio-tcp = { path = "tokio-tcp" }
+tokio-macros = { path = "tokio-macros" }
+tokio-test = { path = "tokio-test" }
 tokio-tls = { path = "tokio-tls" }
-tokio-trace = { path = "tokio-trace" }
-tokio-trace-core = { path = "tokio-trace/tokio-trace-core" }
-tokio-udp = { path = "tokio-udp" }
-tokio-uds = { path = "tokio-uds" }
+tokio-util = { path = "tokio-util" }

ci/tsan

@@ -8,6 +8,8 @@ race:Weak*drop
 # `std` mpsc is not used in any Tokio code base. This race is triggered by some
 # rust runtime logic.
 race:std*mpsc_queue
+race:std*lang_start
+race:drop*std::thread*
 
 # Probably more fences in std.
 race:__call_tls_dtors

examples/Cargo.toml

@@ -0,0 +1,61 @@
+[package]
+name = "examples"
+version = "0.0.0"
+publish = false
+edition = "2018"
+
+[dev-dependencies]
+tokio = { version = "0.2.0", path = "../tokio", features = ["full"] }
+tokio-util = { version = "0.2.0", path = "../tokio-util", features = ["full"] }
+bytes = "0.5"
+futures = "0.3.0"
+http = "0.2"
+serde = "1.0"
+serde_derive = "1.0"
+serde_json = "1.0"
+httparse = "1.0"
+time = "0.1"
+
+[[example]]
+name = "chat"
+path = "chat.rs"
+
+[[example]]
+name = "connect"
+path = "connect.rs"
+
+[[example]]
+name = "echo-udp"
+path = "echo-udp.rs"
+
+[[example]]
+name = "echo"
+path = "echo.rs"
+
+[[example]]
+name = "hello_world"
+path = "hello_world.rs"
+
+[[example]]
+name = "print_each_packet"
+path = "print_each_packet.rs"
+
+[[example]]
+name = "proxy"
+path = "proxy.rs"
+
+[[example]]
+name = "tinydb"
+path = "tinydb.rs"
+
+[[example]]
+name = "udp-client"
+path = "udp-client.rs"
+
+[[example]]
+name = "udp-codec"
+path = "udp-codec.rs"
+
+[[example]]
+name = "tinyhttp"
+path = "tinyhttp.rs"

examples/README.md

@@ -1,60 +1,6 @@
 ## Examples of how to use Tokio
 
-This directory contains a number of examples showcasing various capabilities of
-the `tokio` crate.
-
-All examples can be executed with:
-
-```
-cargo run --example $name
-```
-
-A high level description of each example is:
-
-* [`hello_world`](hello_world.rs) - a tiny server that writes "hello world" to
-  all connected clients and then terminates the connection, should help see how
-  to create and initialize `tokio`.
-
-* [`echo`](echo.rs) - this is your standard TCP "echo server" which accepts
-  connections and then echos back any contents that are read from each connected
-  client.
-
-* [`print_each_packet`](print_each_packet.rs) - this server will create a TCP
-  listener, accept connections in a loop, and put down in the stdout everything
-  that's read off of each TCP connection.
-
-* [`echo-udp`](echo-udp.rs) - again your standard "echo server", except for UDP
-  instead of TCP.  This will echo back any packets received to the original
-  sender.
-
-* [`connect`](connect.rs) - this is a `nc`-like clone which can be used to
-  interact with most other examples. The program creates a TCP connection or UDP
-  socket to sends all information read on stdin to the remote peer, displaying
-  any data received on stdout. Often quite useful when interacting with the
-  various other servers here!
-
-* [`chat`](chat.rs) - this spins up a local TCP server which will broadcast from
-  any connected client to all other connected clients. You can connect to this
-  in multiple terminals and use it to chat between the terminals.
-
-* [`chat-combinator`](chat-combinator.rs) - Similar to `chat`, but this uses a
-  much more functional programming approach using combinators.
-
-* [`proxy`](proxy.rs) - an example proxy server that will forward all connected
-  TCP clients to the remote address specified when starting the program.
-
-* [`tinyhttp`](tinyhttp.rs) - a tiny HTTP/1.1 server which doesn't support HTTP
-  request bodies showcasing running on multiple cores, working with futures and
-  spawning tasks, and finally framing a TCP connection to discrete
-  request/response objects.
-
-* [`tinydb`](tinydb.rs) - an in-memory database which shows sharing state
-  between all connected clients, notably the key/value store of this database.
-
-* [`udp-client`](udp-client.rs) - a simple `send_dgram`/`recv_dgram` example.
-
-* [`manual-runtime`](manual-runtime.rs) - manually composing a runtime.
-
-If you've got an example you'd like to see here, please feel free to open an
-issue. Otherwise if you've got an example you'd like to add, please feel free
-to make a PR!
+The `master` branch is currently being updated to use `async` / `await`.
+The examples are not fully ported. Examples for stable Tokio can be
+found
+[here](https://github.com/tokio-rs/tokio/tree/v0.1.x/tokio/examples).

examples/chat-combinator-current-thread.rs

@@ -1,172 +0,0 @@
-//! A chat server that broadcasts a message to all connections.
-//!
-//! This is a line-based server which accepts connections, reads lines from
-//! those connections, and broadcasts the lines to all other connected clients.
-//!
-//! This example is similar to chat.rs, but uses combinators and a much more
-//! functional style.
-//!
-//! Because we are here running the reactor/executor on the same thread instead
-//! of a threadpool, we can avoid full synchronization with Arc + Mutex and use
-//! Rc + RefCell instead. The max performance is however limited to a CPU HW
-//! thread.
-//!
-//! You can test this out by running:
-//!
-//!     cargo run --example chat-combinator-current-thread
-//!
-//! And then in another window run:
-//!
-//!     cargo run --example connect 127.0.0.1:8080
-//!
-//! You can run the second command in multiple windows and then chat between the
-//! two, seeing the messages from the other client as they're received. For all
-//! connected clients they'll all join the same room and see everyone else's
-//! messages.
-
-#![deny(warnings)]
-
-extern crate futures;
-extern crate tokio;
-
-use tokio::io;
-use tokio::net::TcpListener;
-use tokio::prelude::*;
-use tokio::runtime::current_thread::{Runtime, TaskExecutor};
-
-use std::cell::RefCell;
-use std::collections::HashMap;
-use std::env;
-use std::io::BufReader;
-use std::iter;
-use std::rc::Rc;
-
-fn main() -> Result<(), Box<std::error::Error>> {
-    let mut runtime = Runtime::new().unwrap();
-
-    // Create the TCP listener we'll accept connections on.
-    let addr = env::args().nth(1).unwrap_or("127.0.0.1:8080".to_string());
-    let addr = addr.parse()?;
-
-    let socket = TcpListener::bind(&addr)?;
-    println!("Listening on: {}", addr);
-
-    // This is running on the Tokio current_thread runtime, so it will be single-
-    // threaded. The `Rc<RefCell<...>>` allows state to be shared across the tasks.
-    let connections = Rc::new(RefCell::new(HashMap::new()));
-
-    // The server task asynchronously iterates over and processes each incoming
-    // connection.
-    let srv = socket
-        .incoming()
-        .map_err(|e| {
-            println!("failed to accept socket; error = {:?}", e);
-            e
-        })
-        .for_each(move |stream| {
-            // The client's socket address
-            let addr = stream.peer_addr()?;
-
-            println!("New Connection: {}", addr);
-
-            // Split the TcpStream into two separate handles. One handle for reading
-            // and one handle for writing. This lets us use separate tasks for
-            // reading and writing.
-            let (reader, writer) = stream.split();
-
-            // Create a channel for our stream, which other sockets will use to
-            // send us messages. Then register our address with the stream to send
-            // data to us.
-            let (tx, rx) = futures::sync::mpsc::unbounded();
-            let mut conns = connections.borrow_mut();
-            conns.insert(addr, tx);
-
-            // Define here what we do for the actual I/O. That is, read a bunch of
-            // lines from the socket and dispatch them while we also write any lines
-            // from other sockets.
-            let connections_inner = connections.clone();
-            let reader = BufReader::new(reader);
-
-            // Model the read portion of this socket by mapping an infinite
-            // iterator to each line off the socket. This "loop" is then
-            // terminated with an error once we hit EOF on the socket.
-            let iter = stream::iter_ok::<_, io::Error>(iter::repeat(()));
-
-            let socket_reader = iter.fold(reader, move |reader, _| {
-                // Read a line off the socket, failing if we're at EOF
-                let line = io::read_until(reader, b'\n', Vec::new());
-                let line = line.and_then(|(reader, vec)| {
-                    if vec.len() == 0 {
-                        Err(io::Error::new(io::ErrorKind::BrokenPipe, "broken pipe"))
-                    } else {
-                        Ok((reader, vec))
-                    }
-                });
-
-                // Convert the bytes we read into a string, and then send that
-                // string to all other connected clients.
-                let line = line.map(|(reader, vec)| (reader, String::from_utf8(vec)));
-
-                // Move the connection state into the closure below.
-                let connections = connections_inner.clone();
-
-                line.map(move |(reader, message)| {
-                    println!("{}: {:?}", addr, message);
-                    let mut conns = connections.borrow_mut();
-
-                    if let Ok(msg) = message {
-                        // For each open connection except the sender, send the
-                        // string via the channel.
-                        let iter = conns
-                            .iter_mut()
-                            .filter(|&(&k, _)| k != addr)
-                            .map(|(_, v)| v);
-                        for tx in iter {
-                            tx.unbounded_send(format!("{}: {}", addr, msg)).unwrap();
-                        }
-                    } else {
-                        let tx = conns.get_mut(&addr).unwrap();
-                        tx.unbounded_send("You didn't send valid UTF-8.".to_string())
-                            .unwrap();
-                    }
-
-                    reader
-                })
-            });
-
-            // Whenever we receive a string on the Receiver, we write it to
-            // `WriteHalf<TcpStream>`.
-            let socket_writer = rx.fold(writer, |writer, msg| {
-                let amt = io::write_all(writer, msg.into_bytes());
-                let amt = amt.map(|(writer, _)| writer);
-                amt.map_err(|_| ())
-            });
-
-            // Now that we've got futures representing each half of the socket, we
-            // use the `select` combinator to wait for either half to be done to
-            // tear down the other. Then we spawn off the result.
-            let connections = connections.clone();
-            let socket_reader = socket_reader.map_err(|_| ());
-            let connection = socket_reader.map(|_| ()).select(socket_writer.map(|_| ()));
-
-            // Spawn locally a task to process the connection
-            TaskExecutor::current()
-                .spawn_local(Box::new(connection.then(move |_| {
-                    let mut conns = connections.borrow_mut();
-                    conns.remove(&addr);
-                    println!("Connection {} closed.", addr);
-                    Ok(())
-                })))
-                .unwrap();
-
-            Ok(())
-        })
-        .map_err(|err| println!("error occurred: {:?}", err));
-
-    // Spawn srv itself
-    runtime.spawn(srv);
-
-    // Execute server
-    runtime.run().unwrap();
-    Ok(())
-}

examples/chat-combinator.rs

@@ -1,156 +0,0 @@
-//! A chat server that broadcasts a message to all connections.
-//!
-//! This is a line-based server which accepts connections, reads lines from
-//! those connections, and broadcasts the lines to all other connected clients.
-//!
-//! This example is similar to chat.rs, but uses combinators and a much more
-//! functional style.
-//!
-//! You can test this out by running:
-//!
-//!     cargo run --example chat
-//!
-//! And then in another window run:
-//!
-//!     cargo run --example connect 127.0.0.1:8080
-//!
-//! You can run the second command in multiple windows and then chat between the
-//! two, seeing the messages from the other client as they're received. For all
-//! connected clients they'll all join the same room and see everyone else's
-//! messages.
-
-#![deny(warnings)]
-
-extern crate futures;
-extern crate tokio;
-
-use tokio::io;
-use tokio::net::TcpListener;
-use tokio::prelude::*;
-
-use std::collections::HashMap;
-use std::env;
-use std::io::BufReader;
-use std::iter;
-use std::sync::{Arc, Mutex};
-
-fn main() -> Result<(), Box<std::error::Error>> {
-    // Create the TCP listener we'll accept connections on.
-    let addr = env::args().nth(1).unwrap_or("127.0.0.1:8080".to_string());
-    let addr = addr.parse()?;
-
-    let socket = TcpListener::bind(&addr)?;
-    println!("Listening on: {}", addr);
-
-    // This is running on the Tokio runtime, so it will be multi-threaded. The
-    // `Arc<Mutex<...>>` allows state to be shared across the threads.
-    let connections = Arc::new(Mutex::new(HashMap::new()));
-
-    // The server task asynchronously iterates over and processes each incoming
-    // connection.
-    let srv = socket
-        .incoming()
-        .map_err(|e| {
-            println!("failed to accept socket; error = {:?}", e);
-            e
-        })
-        .for_each(move |stream| {
-            // The client's socket address
-            let addr = stream.peer_addr()?;
-
-            println!("New Connection: {}", addr);
-
-            // Split the TcpStream into two separate handles. One handle for reading
-            // and one handle for writing. This lets us use separate tasks for
-            // reading and writing.
-            let (reader, writer) = stream.split();
-
-            // Create a channel for our stream, which other sockets will use to
-            // send us messages. Then register our address with the stream to send
-            // data to us.
-            let (tx, rx) = futures::sync::mpsc::unbounded();
-            connections.lock().unwrap().insert(addr, tx);
-
-            // Define here what we do for the actual I/O. That is, read a bunch of
-            // lines from the socket and dispatch them while we also write any lines
-            // from other sockets.
-            let connections_inner = connections.clone();
-            let reader = BufReader::new(reader);
-
-            // Model the read portion of this socket by mapping an infinite
-            // iterator to each line off the socket. This "loop" is then
-            // terminated with an error once we hit EOF on the socket.
-            let iter = stream::iter_ok::<_, io::Error>(iter::repeat(()));
-
-            let socket_reader = iter.fold(reader, move |reader, _| {
-                // Read a line off the socket, failing if we're at EOF
-                let line = io::read_until(reader, b'\n', Vec::new());
-                let line = line.and_then(|(reader, vec)| {
-                    if vec.len() == 0 {
-                        Err(io::Error::new(io::ErrorKind::BrokenPipe, "broken pipe"))
-                    } else {
-                        Ok((reader, vec))
-                    }
-                });
-
-                // Convert the bytes we read into a string, and then send that
-                // string to all other connected clients.
-                let line = line.map(|(reader, vec)| (reader, String::from_utf8(vec)));
-
-                // Move the connection state into the closure below.
-                let connections = connections_inner.clone();
-
-                line.map(move |(reader, message)| {
-                    println!("{}: {:?}", addr, message);
-                    let mut conns = connections.lock().unwrap();
-
-                    if let Ok(msg) = message {
-                        // For each open connection except the sender, send the
-                        // string via the channel.
-                        let iter = conns
-                            .iter_mut()
-                            .filter(|&(&k, _)| k != addr)
-                            .map(|(_, v)| v);
-                        for tx in iter {
-                            tx.unbounded_send(format!("{}: {}", addr, msg)).unwrap();
-                        }
-                    } else {
-                        let tx = conns.get_mut(&addr).unwrap();
-                        tx.unbounded_send("You didn't send valid UTF-8.".to_string())
-                            .unwrap();
-                    }
-
-                    reader
-                })
-            });
-
-            // Whenever we receive a string on the Receiver, we write it to
-            // `WriteHalf<TcpStream>`.
-            let socket_writer = rx.fold(writer, |writer, msg| {
-                let amt = io::write_all(writer, msg.into_bytes());
-                let amt = amt.map(|(writer, _)| writer);
-                amt.map_err(|_| ())
-            });
-
-            // Now that we've got futures representing each half of the socket, we
-            // use the `select` combinator to wait for either half to be done to
-            // tear down the other. Then we spawn off the result.
-            let connections = connections.clone();
-            let socket_reader = socket_reader.map_err(|_| ());
-            let connection = socket_reader.map(|_| ()).select(socket_writer.map(|_| ()));
-
-            // Spawn a task to process the connection
-            tokio::spawn(connection.then(move |_| {
-                connections.lock().unwrap().remove(&addr);
-                println!("Connection {} closed.", addr);
-                Ok(())
-            }));
-
-            Ok(())
-        })
-        .map_err(|err| println!("error occurred: {:?}", err));
-
-    // execute server
-    tokio::run(srv);
-    Ok(())
-}

examples/chat.rs

@@ -24,29 +24,64 @@
 //! connected clients they'll all join the same room and see everyone else's
 //! messages.
 
-#![deny(warnings)]
+#![warn(rust_2018_idioms)]
 
-extern crate tokio;
-#[macro_use]
-extern crate futures;
-extern crate bytes;
-
-use bytes::{BufMut, Bytes, BytesMut};
-use futures::future::{self, Either};
-use futures::sync::mpsc;
-use tokio::io;
 use tokio::net::{TcpListener, TcpStream};
-use tokio::prelude::*;
+use tokio::stream::{Stream, StreamExt};
+use tokio::sync::{mpsc, Mutex};
+use tokio_util::codec::{Framed, LinesCodec, LinesCodecError};
 
+use futures::SinkExt;
 use std::collections::HashMap;
+use std::env;
+use std::error::Error;
+use std::io;
 use std::net::SocketAddr;
-use std::sync::{Arc, Mutex};
+use std::pin::Pin;
+use std::sync::Arc;
+use std::task::{Context, Poll};
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn Error>> {
+    // Create the shared state. This is how all the peers communicate.
+    //
+    // The server task will hold a handle to this. For every new client, the
+    // `state` handle is cloned and passed into the task that processes the
+    // client connection.
+    let state = Arc::new(Mutex::new(Shared::new()));
+
+    let addr = env::args()
+        .nth(1)
+        .unwrap_or_else(|| "127.0.0.1:6142".to_string());
+
+    // Bind a TCP listener to the socket address.
+    //
+    // Note that this is the Tokio TcpListener, which is fully async.
+    let mut listener = TcpListener::bind(&addr).await?;
+
+    println!("server running on {}", addr);
+
+    loop {
+        // Asynchronously wait for an inbound TcpStream.
+        let (stream, addr) = listener.accept().await?;
+
+        // Clone a handle to the `Shared` state for the new connection.
+        let state = Arc::clone(&state);
+
+        // Spawn our handler to be run asynchronously.
+        tokio::spawn(async move {
+            if let Err(e) = process(state, stream, addr).await {
+                println!("an error occured; error = {:?}", e);
+            }
+        });
+    }
+}
 
 /// Shorthand for the transmit half of the message channel.
-type Tx = mpsc::UnboundedSender<Bytes>;
+type Tx = mpsc::UnboundedSender<String>;
 
 /// Shorthand for the receive half of the message channel.
-type Rx = mpsc::UnboundedReceiver<Bytes>;
+type Rx = mpsc::UnboundedReceiver<String>;
 
 /// Data that is shared between all peers in the chat server.
 ///
@@ -60,64 +95,18 @@ struct Shared {
 
 /// The state for each connected client.
 struct Peer {
-    /// Name of the peer.
-    ///
-    /// When a client connects, the first line sent is treated as the client's
-    /// name (like alice or bob). The name is used to preface all messages that
-    /// arrive from the client so that we can simulate a real chat server:
-    ///
-    /// ```text
-    /// alice: Hello everyone.
-    /// bob: Welcome to telnet chat!
-    /// ```
-    name: BytesMut,
-
     /// The TCP socket wrapped with the `Lines` codec, defined below.
     ///
     /// This handles sending and receiving data on the socket. When using
     /// `Lines`, we can work at the line level instead of having to manage the
     /// raw byte operations.
-    lines: Lines,
-
-    /// Handle to the shared chat state.
-    ///
-    /// This is used to broadcast messages read off the socket to all connected
-    /// peers.
-    state: Arc<Mutex<Shared>>,
+    lines: Framed<TcpStream, LinesCodec>,
 
     /// Receive half of the message channel.
     ///
     /// This is used to receive messages from peers. When a message is received
     /// off of this `Rx`, it will be written to the socket.
     rx: Rx,
-
-    /// Client socket address.
-    ///
-    /// The socket address is used as the key in the `peers` HashMap. The
-    /// address is saved so that the `Peer` drop implementation can clean up its
-    /// entry.
-    addr: SocketAddr,
-}
-
-/// Line based codec
-///
-/// This decorates a socket and presents a line based read / write interface.
-///
-/// As a user of `Lines`, we can focus on working at the line level. So, we send
-/// and receive values that represent entire lines. The `Lines` codec will
-/// handle the encoding and decoding as well as reading from and writing to the
-/// socket.
-#[derive(Debug)]
-struct Lines {
-    /// The TCP socket.
-    socket: TcpStream,
-
-    /// Buffer used when reading from the socket. Data is not returned from this
-    /// buffer until an entire line has been read.
-    rd: BytesMut,
-
-    /// Buffer used to stage data before writing it to the socket.
-    wr: BytesMut,
 }
 
 impl Shared {
@@ -127,347 +116,143 @@ impl Shared {
             peers: HashMap::new(),
         }
     }
+
+    /// Send a `LineCodec` encoded message to every peer, except
+    /// for the sender.
+    async fn broadcast(&mut self, sender: SocketAddr, message: &str) {
+        for peer in self.peers.iter_mut() {
+            if *peer.0 != sender {
+                let _ = peer.1.send(message.into());
+            }
+        }
+    }
 }
 
 impl Peer {
     /// Create a new instance of `Peer`.
-    fn new(name: BytesMut, state: Arc<Mutex<Shared>>, lines: Lines) -> Peer {
+    async fn new(
+        state: Arc<Mutex<Shared>>,
+        lines: Framed<TcpStream, LinesCodec>,
+    ) -> io::Result<Peer> {
         // Get the client socket address
-        let addr = lines.socket.peer_addr().unwrap();
+        let addr = lines.get_ref().peer_addr()?;
 
         // Create a channel for this peer
-        let (tx, rx) = mpsc::unbounded();
+        let (tx, rx) = mpsc::unbounded_channel();
 
         // Add an entry for this `Peer` in the shared state map.
-        state.lock().unwrap().peers.insert(addr, tx);
+        state.lock().await.peers.insert(addr, tx);
 
-        Peer {
-            name,
-            lines,
-            state,
-            rx,
-            addr,
-        }
+        Ok(Peer { lines, rx })
     }
 }
 
-/// This is where a connected client is managed.
-///
-/// A `Peer` is also a future representing completely processing the client.
-///
-/// When a `Peer` is created, the first line (representing the client's name)
-/// has already been read. When the socket closes, the `Peer` future completes.
-///
-/// While processing, the peer future implementation will:
-///
-/// 1) Receive messages on its message channel and write them to the socket.
-/// 2) Receive messages from the socket and broadcast them to all peers.
-///
-impl Future for Peer {
-    type Item = ();
-    type Error = io::Error;
+#[derive(Debug)]
+enum Message {
+    /// A message that should be broadcasted to others.
+    Broadcast(String),
 
-    fn poll(&mut self) -> Poll<(), io::Error> {
-        // Tokio (and futures) use cooperative scheduling without any
-        // preemption. If a task never yields execution back to the executor,
-        // then other tasks may be starved.
-        //
-        // To deal with this, robust applications should not have any unbounded
-        // loops. In this example, we will read at most `LINES_PER_TICK` lines
-        // from the client on each tick.
-        //
-        // If the limit is hit, the current task is notified, informing the
-        // executor to schedule the task again asap.
-        const LINES_PER_TICK: usize = 10;
-
-        // Receive all messages from peers.
-        for i in 0..LINES_PER_TICK {
-            // Polling an `UnboundedReceiver` cannot fail, so `unwrap` here is
-            // safe.
-            match self.rx.poll().unwrap() {
-                Async::Ready(Some(v)) => {
-                    // Buffer the line. Once all lines are buffered, they will
-                    // be flushed to the socket (right below).
-                    self.lines.buffer(&v);
-
-                    // If this is the last iteration, the loop will break even
-                    // though there could still be lines to read. Because we did
-                    // not reach `Async::NotReady`, we have to notify ourselves
-                    // in order to tell the executor to schedule the task again.
-                    if i + 1 == LINES_PER_TICK {
-                        task::current().notify();
-                    }
-                }
-                _ => break,
-            }
-        }
-
-        // Flush the write buffer to the socket
-        let _ = self.lines.poll_flush()?;
-
-        // Read new lines from the socket
-        while let Async::Ready(line) = self.lines.poll()? {
-            println!("Received line ({:?}) : {:?}", self.name, line);
-
-            if let Some(message) = line {
-                // Append the peer's name to the front of the line:
-                let mut line = self.name.clone();
-                line.extend_from_slice(b": ");
-                line.extend_from_slice(&message);
-                line.extend_from_slice(b"\r\n");
-
-                // We're using `Bytes`, which allows zero-copy clones (by
-                // storing the data in an Arc internally).
-                //
-                // However, before cloning, we must freeze the data. This
-                // converts it from mutable -> immutable, allowing zero copy
-                // cloning.
-                let line = line.freeze();
-
-                // Now, send the line to all other peers
-                for (addr, tx) in &self.state.lock().unwrap().peers {
-                    // Don't send the message to ourselves
-                    if *addr != self.addr {
-                        // The send only fails if the rx half has been dropped,
-                        // however this is impossible as the `tx` half will be
-                        // removed from the map before the `rx` is dropped.
-                        tx.unbounded_send(line.clone()).unwrap();
-                    }
-                }
-            } else {
-                // EOF was reached. The remote client has disconnected. There is
-                // nothing more to do.
-                return Ok(Async::Ready(()));
-            }
-        }
-
-        // As always, it is important to not just return `NotReady` without
-        // ensuring an inner future also returned `NotReady`.
-        //
-        // We know we got a `NotReady` from either `self.rx` or `self.lines`, so
-        // the contract is respected.
-        Ok(Async::NotReady)
-    }
+    /// A message that should be received by a client
+    Received(String),
 }
 
-impl Drop for Peer {
-    fn drop(&mut self) {
-        self.state.lock().unwrap().peers.remove(&self.addr);
-    }
-}
+// Peer implements `Stream` in a way that polls both the `Rx`, and `Framed` types.
+// A message is produced whenever an event is ready until the `Framed` stream returns `None`.
+impl Stream for Peer {
+    type Item = Result<Message, LinesCodecError>;
 
-impl Lines {
-    /// Create a new `Lines` codec backed by the socket
-    fn new(socket: TcpStream) -> Self {
-        Lines {
-            socket,
-            rd: BytesMut::new(),
-            wr: BytesMut::new(),
-        }
-    }
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        // First poll the `UnboundedReceiver`.
 
-    /// Buffer a line.
-    ///
-    /// This writes the line to an internal buffer. Calls to `poll_flush` will
-    /// attempt to flush this buffer to the socket.
-    fn buffer(&mut self, line: &[u8]) {
-        // Ensure the buffer has capacity. Ideally this would not be unbounded,
-        // but to keep the example simple, we will not limit this.
-        self.wr.reserve(line.len());
-
-        // Push the line onto the end of the write buffer.
-        //
-        // The `put` function is from the `BufMut` trait.
-        self.wr.put(line);
-    }
-
-    /// Flush the write buffer to the socket
-    fn poll_flush(&mut self) -> Poll<(), io::Error> {
-        // As long as there is buffered data to write, try to write it.
-        while !self.wr.is_empty() {
-            // Try to write some bytes to the socket
-            let n = try_ready!(self.socket.poll_write(&self.wr));
-
-            // As long as the wr is not empty, a successful write should
-            // never write 0 bytes.
-            assert!(n > 0);
-
-            // This discards the first `n` bytes of the buffer.
-            let _ = self.wr.split_to(n);
+        if let Poll::Ready(Some(v)) = Pin::new(&mut self.rx).poll_next(cx) {
+            return Poll::Ready(Some(Ok(Message::Received(v))));
         }
 
-        Ok(Async::Ready(()))
-    }
+        // Secondly poll the `Framed` stream.
+        let result: Option<_> = futures::ready!(Pin::new(&mut self.lines).poll_next(cx));
 
-    /// Read data from the socket.
-    ///
-    /// This only returns `Ready` when the socket has closed.
-    fn fill_read_buf(&mut self) -> Poll<(), io::Error> {
-        loop {
-            // Ensure the read buffer has capacity.
-            //
-            // This might result in an internal allocation.
-            self.rd.reserve(1024);
+        Poll::Ready(match result {
+            // We've received a message we should broadcast to others.
+            Some(Ok(message)) => Some(Ok(Message::Broadcast(message))),
 
-            // Read data into the buffer.
-            let n = try_ready!(self.socket.read_buf(&mut self.rd));
+            // An error occured.
+            Some(Err(e)) => Some(Err(e)),
 
-            if n == 0 {
-                return Ok(Async::Ready(()));
-            }
-        }
-    }
-}
-
-impl Stream for Lines {
-    type Item = BytesMut;
-    type Error = io::Error;
-
-    fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
-        // First, read any new data that might have been received off the socket
-        let sock_closed = self.fill_read_buf()?.is_ready();
-
-        // Now, try finding lines
-        let pos = self
-            .rd
-            .windows(2)
-            .enumerate()
-            .find(|&(_, bytes)| bytes == b"\r\n")
-            .map(|(i, _)| i);
-
-        if let Some(pos) = pos {
-            // Remove the line from the read buffer and set it to `line`.
-            let mut line = self.rd.split_to(pos + 2);
-
-            // Drop the trailing \r\n
-            line.split_off(pos);
-
-            // Return the line
-            return Ok(Async::Ready(Some(line)));
-        }
-
-        if sock_closed {
-            Ok(Async::Ready(None))
-        } else {
-            Ok(Async::NotReady)
-        }
-    }
-}
-
-/// Spawn a task to manage the socket.
-///
-/// This will read the first line from the socket to identify the client, then
-/// add the client to the set of connected peers in the chat service.
-fn process(socket: TcpStream, state: Arc<Mutex<Shared>>) {
-    // Wrap the socket with the `Lines` codec that we wrote above.
-    //
-    // By doing this, we can operate at the line level instead of doing raw byte
-    // manipulation.
-    let lines = Lines::new(socket);
-
-    // The first line is treated as the client's name. The client is not added
-    // to the set of connected peers until this line is received.
-    //
-    // We use the `into_future` combinator to extract the first item from the
-    // lines stream. `into_future` takes a `Stream` and converts it to a future
-    // of `(first, rest)` where `rest` is the original stream instance.
-    let connection = lines
-        .into_future()
-        // `into_future` doesn't have the right error type, so map the error to
-        // make it work.
-        .map_err(|(e, _)| e)
-        // Process the first received line as the client's name.
-        .and_then(|(name, lines)| {
-            // If `name` is `None`, then the client disconnected without
-            // actually sending a line of data.
-            //
-            // Since the connection is closed, there is no further work that we
-            // need to do. So, we just terminate processing by returning
-            // `future::ok()`.
-            //
-            // The problem is that only a single future type can be returned
-            // from a combinator closure, but we want to return both
-            // `future::ok()` and `Peer` (below).
-            //
-            // This is a common problem, so the `futures` crate solves this by
-            // providing the `Either` helper enum that allows creating a single
-            // return type that covers two concrete future types.
-            let name = match name {
-                Some(name) => name,
-                None => {
-                    // The remote client closed the connection without sending
-                    // any data.
-                    return Either::A(future::ok(()));
-                }
-            };
-
-            println!("`{:?}` is joining the chat", name);
-
-            // Create the peer.
-            //
-            // This is also a future that processes the connection, only
-            // completing when the socket closes.
-            let peer = Peer::new(name, state, lines);
-
-            // Wrap `peer` with `Either::B` to make the return type fit.
-            Either::B(peer)
+            // The stream has been exhausted.
+            None => None,
         })
-        // Task futures have an error of type `()`, this ensures we handle the
-        // error. We do this by printing the error to STDOUT.
-        .map_err(|e| {
-            println!("connection error = {:?}", e);
-        });
-
-    // Spawn the task. Internally, this submits the task to a thread pool.
-    tokio::spawn(connection);
+    }
 }
 
-pub fn main() -> Result<(), Box<std::error::Error>> {
-    // Create the shared state. This is how all the peers communicate.
-    //
-    // The server task will hold a handle to this. For every new client, the
-    // `state` handle is cloned and passed into the task that processes the
-    // client connection.
-    let state = Arc::new(Mutex::new(Shared::new()));
+/// Process an individual chat client
+async fn process(
+    state: Arc<Mutex<Shared>>,
+    stream: TcpStream,
+    addr: SocketAddr,
+) -> Result<(), Box<dyn Error>> {
+    let mut lines = Framed::new(stream, LinesCodec::new());
 
-    let addr = "127.0.0.1:6142".parse()?;
+    // Send a prompt to the client to enter their username.
+    lines
+        .send(String::from("Please enter your username:"))
+        .await?;
 
-    // Bind a TCP listener to the socket address.
-    //
-    // Note that this is the Tokio TcpListener, which is fully async.
-    let listener = TcpListener::bind(&addr)?;
+    // Read the first line from the `LineCodec` stream to get the username.
+    let username = match lines.next().await {
+        Some(Ok(line)) => line,
+        // We didn't get a line so we return early here.
+        _ => {
+            println!("Failed to get username from {}. Client disconnected.", addr);
+            return Ok(());
+        }
+    };
 
-    // The server task asynchronously iterates over and processes each
-    // incoming connection.
-    let server = listener
-        .incoming()
-        .for_each(move |socket| {
-            // Spawn a task to process the connection
-            process(socket, state.clone());
-            Ok(())
-        })
-        .map_err(|err| {
-            // All tasks must have an `Error` type of `()`. This forces error
-            // handling and helps avoid silencing failures.
-            //
-            // In our example, we are only going to log the error to STDOUT.
-            println!("accept error = {:?}", err);
-        });
+    // Register our peer with state which internally sets up some channels.
+    let mut peer = Peer::new(state.clone(), lines).await?;
 
-    println!("server running on localhost:6142");
+    // A client has connected, let's let everyone know.
+    {
+        let mut state = state.lock().await;
+        let msg = format!("{} has joined the chat", username);
+        println!("{}", msg);
+        state.broadcast(addr, &msg).await;
+    }
+
+    // Process incoming messages until our stream is exhausted by a disconnect.
+    while let Some(result) = peer.next().await {
+        match result {
+            // A message was received from the current user, we should
+            // broadcast this message to the other users.
+            Ok(Message::Broadcast(msg)) => {
+                let mut state = state.lock().await;
+                let msg = format!("{}: {}", username, msg);
+
+                state.broadcast(addr, &msg).await;
+            }
+            // A message was received from a peer. Send it to the
+            // current user.
+            Ok(Message::Received(msg)) => {
+                peer.lines.send(msg).await?;
+            }
+            Err(e) => {
+                println!(
+                    "an error occured while processing messages for {}; error = {:?}",
+                    username, e
+                );
+            }
+        }
+    }
+
+    // If this section is reached it means that the client was disconnected!
+    // Let's let everyone still connected know about it.
+    {
+        let mut state = state.lock().await;
+        state.peers.remove(&addr);
+
+        let msg = format!("{} has left the chat", username);
+        println!("{}", msg);
+        state.broadcast(addr, &msg).await;
+    }
 
-    // Start the Tokio runtime.
-    //
-    // The Tokio is a pre-configured "out of the box" runtime for building
-    // asynchronous applications. It includes both a reactor and a task
-    // scheduler. This means applications are multithreaded by default.
-    //
-    // This function blocks until the runtime reaches an idle state. Idle is
-    // defined as all spawned tasks have completed and all I/O resources (TCP
-    // sockets in our case) have been dropped.
-    //
-    // In our example, we have not defined a shutdown strategy, so this will
-    // block until `ctrl-c` is pressed at the terminal.
-    tokio::run(server);
     Ok(())
 }

examples/connect.rs

@@ -14,22 +14,18 @@
 //! this repository! Many of them recommend running this as a simple "hook up
 //! stdin/stdout to a server" to get up and running.
 
-#![deny(warnings)]
+#![warn(rust_2018_idioms)]
 
-extern crate bytes;
-extern crate futures;
-extern crate tokio;
-extern crate tokio_io;
+use futures::StreamExt;
+use tokio::io;
+use tokio_util::codec::{BytesCodec, FramedRead, FramedWrite};
 
 use std::env;
-use std::io::{self, Read, Write};
+use std::error::Error;
 use std::net::SocketAddr;
-use std::thread;
 
-use futures::sync::mpsc;
-use tokio::prelude::*;
-
-fn main() -> Result<(), Box<std::error::Error>> {
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn Error>> {
     // Determine if we're going to run in TCP or UDP mode
     let mut args = env::args().skip(1).collect::<Vec<_>>();
     let tcp = match args.iter().position(|a| a == "--udp") {
@@ -41,217 +37,113 @@ fn main() -> Result<(), Box<std::error::Error>> {
     };
 
     // Parse what address we're going to connect to
-    let addr = match args.first() {
-        Some(addr) => addr,
-        None => Err("this program requires at least one argument")?,
-    };
+    let addr = args
+        .first()
+        .ok_or("this program requires at least one argument")?;
     let addr = addr.parse::<SocketAddr>()?;
 
-    // Right now Tokio doesn't support a handle to stdin running on the event
-    // loop, so we farm out that work to a separate thread. This thread will
-    // read data (with blocking I/O) from stdin and then send it to the event
-    // loop over a standard futures channel.
-    let (stdin_tx, stdin_rx) = mpsc::channel(0);
-    thread::spawn(|| read_stdin(stdin_tx));
-    let stdin_rx = stdin_rx.map_err(|_| panic!("errors not possible on rx"));
+    let stdin = FramedRead::new(io::stdin(), BytesCodec::new());
+    let stdin = stdin.map(|i| i.map(|bytes| bytes.freeze()));
+    let stdout = FramedWrite::new(io::stdout(), BytesCodec::new());
 
-    // Now that we've got our stdin read we either set up our TCP connection or
-    // our UDP connection to get a stream of bytes we're going to emit to
-    // stdout.
-    let stdout = if tcp {
-        tcp::connect(&addr, Box::new(stdin_rx))?
+    if tcp {
+        tcp::connect(&addr, stdin, stdout).await?;
     } else {
-        udp::connect(&addr, Box::new(stdin_rx))?
-    };
+        udp::connect(&addr, stdin, stdout).await?;
+    }
 
-    // And now with our stream of bytes to write to stdout, we execute that in
-    // the event loop! Note that this is doing blocking I/O to emit data to
-    // stdout, and in general it's a no-no to do that sort of work on the event
-    // loop. In this case, though, we know it's ok as the event loop isn't
-    // otherwise running anything useful.
-    let mut out = io::stdout();
-
-    tokio::run({
-        stdout
-            .for_each(move |chunk| out.write_all(&chunk))
-            .map_err(|e| println!("error reading stdout; error = {:?}", e))
-    });
     Ok(())
 }
 
-mod codec {
-    use bytes::{BufMut, BytesMut};
-    use std::io;
-    use tokio::codec::{Decoder, Encoder};
-
-    /// A simple `Codec` implementation that just ships bytes around.
-    ///
-    /// This type is used for "framing" a TCP/UDP stream of bytes but it's really
-    /// just a convenient method for us to work with streams/sinks for now.
-    /// This'll just take any data read and interpret it as a "frame" and
-    /// conversely just shove data into the output location without looking at
-    /// it.
-    pub struct Bytes;
-
-    impl Decoder for Bytes {
-        type Item = BytesMut;
-        type Error = io::Error;
-
-        fn decode(&mut self, buf: &mut BytesMut) -> io::Result<Option<BytesMut>> {
-            if buf.len() > 0 {
-                let len = buf.len();
-                Ok(Some(buf.split_to(len)))
-            } else {
-                Ok(None)
-            }
-        }
-    }
-
-    impl Encoder for Bytes {
-        type Item = Vec<u8>;
-        type Error = io::Error;
-
-        fn encode(&mut self, data: Vec<u8>, buf: &mut BytesMut) -> io::Result<()> {
-            buf.put(&data[..]);
-            Ok(())
-        }
-    }
-}
-
 mod tcp {
-    use tokio;
-    use tokio::codec::Decoder;
+    use bytes::Bytes;
+    use futures::{future, Sink, SinkExt, Stream, StreamExt};
+    use std::{error::Error, io, net::SocketAddr};
     use tokio::net::TcpStream;
-    use tokio::prelude::*;
+    use tokio_util::codec::{BytesCodec, FramedRead, FramedWrite};
 
-    use bytes::BytesMut;
-    use codec::Bytes;
-
-    use std::error::Error;
-    use std::io;
-    use std::net::SocketAddr;
-
-    pub fn connect(
+    pub async fn connect(
         addr: &SocketAddr,
-        stdin: Box<Stream<Item = Vec<u8>, Error = io::Error> + Send>,
-    ) -> Result<Box<Stream<Item = BytesMut, Error = io::Error> + Send>, Box<Error>> {
-        let tcp = TcpStream::connect(addr);
-
-        // After the TCP connection has been established, we set up our client
-        // to start forwarding data.
-        //
-        // First we use the `Io::framed` method with a simple implementation of
-        // a `Codec` (listed below) that just ships bytes around. We then split
-        // that in two to work with the stream and sink separately.
-        //
-        // Half of the work we're going to do is to take all data we receive on
-        // `stdin` and send that along the TCP stream (`sink`). The second half
-        // is to take all the data we receive (`stream`) and then write that to
-        // stdout. We'll be passing this handle back out from this method.
-        //
-        // You'll also note that we *spawn* the work to read stdin and write it
-        // to the TCP stream. This is done to ensure that happens concurrently
-        // with us reading data from the stream.
-        let stream = Box::new(
-            tcp.map(move |stream| {
-                let (sink, stream) = Bytes.framed(stream).split();
-
-                tokio::spawn(stdin.forward(sink).then(|result| {
-                    if let Err(e) = result {
-                        println!("failed to write to socket: {}", e)
-                    }
-                    Ok(())
-                }));
-
-                stream
+        mut stdin: impl Stream<Item = Result<Bytes, io::Error>> + Unpin,
+        mut stdout: impl Sink<Bytes, Error = io::Error> + Unpin,
+    ) -> Result<(), Box<dyn Error>> {
+        let mut stream = TcpStream::connect(addr).await?;
+        let (r, w) = stream.split();
+        let mut sink = FramedWrite::new(w, BytesCodec::new());
+        // filter map Result<BytesMut, Error> stream into just a Bytes stream to match stdout Sink
+        // on the event of an Error, log the error and end the stream
+        let mut stream = FramedRead::new(r, BytesCodec::new())
+            .filter_map(|i| match i {
+                //BytesMut into Bytes
+                Ok(i) => future::ready(Some(i.freeze())),
+                Err(e) => {
+                    println!("failed to read from socket; error={}", e);
+                    future::ready(None)
+                }
             })
-            .flatten_stream(),
-        );
-        Ok(stream)
+            .map(Ok);
+
+        match future::join(sink.send_all(&mut stdin), stdout.send_all(&mut stream)).await {
+            (Err(e), _) | (_, Err(e)) => Err(e.into()),
+            _ => Ok(()),
+        }
     }
 }
 
 mod udp {
+    use bytes::Bytes;
+    use futures::{future, Sink, SinkExt, Stream, StreamExt};
     use std::error::Error;
     use std::io;
     use std::net::SocketAddr;
+    use tokio::net::udp::{RecvHalf, SendHalf};
+    use tokio::net::UdpSocket;
 
-    use bytes::BytesMut;
-    use tokio;
-    use tokio::net::{UdpFramed, UdpSocket};
-    use tokio::prelude::*;
-
-    use codec::Bytes;
-
-    pub fn connect(
-        &addr: &SocketAddr,
-        stdin: Box<Stream<Item = Vec<u8>, Error = io::Error> + Send>,
-    ) -> Result<Box<Stream<Item = BytesMut, Error = io::Error> + Send>, Box<Error>> {
+    pub async fn connect(
+        addr: &SocketAddr,
+        stdin: impl Stream<Item = Result<Bytes, io::Error>> + Unpin,
+        stdout: impl Sink<Bytes, Error = io::Error> + Unpin,
+    ) -> Result<(), Box<dyn Error>> {
         // We'll bind our UDP socket to a local IP/port, but for now we
         // basically let the OS pick both of those.
-        let addr_to_bind = if addr.ip().is_ipv4() {
-            "0.0.0.0:0".parse()?
+        let bind_addr = if addr.ip().is_ipv4() {
+            "0.0.0.0:0"
         } else {
-            "[::]:0".parse()?
-        };
-        let udp = match UdpSocket::bind(&addr_to_bind) {
-            Ok(udp) => udp,
-            Err(_) => Err("failed to bind socket")?,
+            "[::]:0"
         };
 
-        // Like above with TCP we use an instance of `Bytes` codec to transform
-        // this UDP socket into a framed sink/stream which operates over
-        // discrete values. In this case we're working with *pairs* of socket
-        // addresses and byte buffers.
-        let (sink, stream) = UdpFramed::new(udp, Bytes).split();
+        let socket = UdpSocket::bind(&bind_addr).await?;
+        socket.connect(addr).await?;
+        let (mut r, mut w) = socket.split();
 
-        // All bytes from `stdin` will go to the `addr` specified in our
-        // argument list. Like with TCP this is spawned concurrently
-        let forward_stdin = stdin
-            .map(move |chunk| (chunk, addr))
-            .forward(sink)
-            .then(|result| {
-                if let Err(e) = result {
-                    println!("failed to write to socket: {}", e)
-                }
-                Ok(())
-            });
+        future::try_join(send(stdin, &mut w), recv(stdout, &mut r)).await?;
 
-        // With UDP we could receive data from any source, so filter out
-        // anything coming from a different address
-        let receive = stream.filter_map(move |(chunk, src)| {
-            if src == addr {
-                Some(chunk.into())
-            } else {
-                None
+        Ok(())
+    }
+
+    async fn send(
+        mut stdin: impl Stream<Item = Result<Bytes, io::Error>> + Unpin,
+        writer: &mut SendHalf,
+    ) -> Result<(), io::Error> {
+        while let Some(item) = stdin.next().await {
+            let buf = item?;
+            writer.send(&buf[..]).await?;
+        }
+
+        Ok(())
+    }
+
+    async fn recv(
+        mut stdout: impl Sink<Bytes, Error = io::Error> + Unpin,
+        reader: &mut RecvHalf,
+    ) -> Result<(), io::Error> {
+        loop {
+            let mut buf = vec![0; 1024];
+            let n = reader.recv(&mut buf[..]).await?;
+
+            if n > 0 {
+                stdout.send(Bytes::from(buf)).await?;
             }
-        });
-
-        let stream = Box::new(
-            future::lazy(|| {
-                tokio::spawn(forward_stdin);
-                future::ok(receive)
-            })
-            .flatten_stream(),
-        );
-        Ok(stream)
-    }
-}
-
-// Our helper method which will read data from stdin and send it along the
-// sender provided.
-fn read_stdin(mut tx: mpsc::Sender<Vec<u8>>) {
-    let mut stdin = io::stdin();
-    loop {
-        let mut buf = vec![0; 1024];
-        let n = match stdin.read(&mut buf) {
-            Err(_) | Ok(0) => break,
-            Ok(n) => n,
-        };
-        buf.truncate(n);
-        tx = match tx.send(buf).wait() {
-            Ok(tx) => tx,
-            Err(_) => break,
-        };
+        }
     }
 }

examples/echo-udp.rs

@@ -10,17 +10,13 @@
 //!
 //! Each line you type in to the `nc` terminal should be echo'd back to you!
 
-#![deny(warnings)]
-
-#[macro_use]
-extern crate futures;
-extern crate tokio;
+#![warn(rust_2018_idioms)]
 
+use std::error::Error;
 use std::net::SocketAddr;
 use std::{env, io};
-
+use tokio;
 use tokio::net::UdpSocket;
-use tokio::prelude::*;
 
 struct Server {
     socket: UdpSocket,
@@ -28,47 +24,48 @@ struct Server {
     to_send: Option<(usize, SocketAddr)>,
 }
 
-impl Future for Server {
-    type Item = ();
-    type Error = io::Error;
+impl Server {
+    async fn run(self) -> Result<(), io::Error> {
+        let Server {
+            mut socket,
+            mut buf,
+            mut to_send,
+        } = self;
 
-    fn poll(&mut self) -> Poll<(), io::Error> {
         loop {
             // First we check to see if there's a message we need to echo back.
             // If so then we try to send it back to the original source, waiting
             // until it's writable and we're able to do so.
-            if let Some((size, peer)) = self.to_send {
-                let amt = try_ready!(self.socket.poll_send_to(&self.buf[..size], &peer));
+            if let Some((size, peer)) = to_send {
+                let amt = socket.send_to(&buf[..size], &peer).await?;
+
                 println!("Echoed {}/{} bytes to {}", amt, size, peer);
-                self.to_send = None;
             }
 
             // If we're here then `to_send` is `None`, so we take a look for the
             // next message we're going to echo back.
-            self.to_send = Some(try_ready!(self.socket.poll_recv_from(&mut self.buf)));
+            to_send = Some(socket.recv_from(&mut buf).await?);
         }
     }
 }
 
-fn main() -> Result<(), Box<std::error::Error>> {
-    let addr = env::args().nth(1).unwrap_or("127.0.0.1:8080".to_string());
-    let addr = addr.parse::<SocketAddr>()?;
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn Error>> {
+    let addr = env::args()
+        .nth(1)
+        .unwrap_or_else(|| "127.0.0.1:8080".to_string());
 
-    let socket = UdpSocket::bind(&addr)?;
+    let socket = UdpSocket::bind(&addr).await?;
     println!("Listening on: {}", socket.local_addr()?);
 
     let server = Server {
-        socket: socket,
+        socket,
         buf: vec![0; 1024],
         to_send: None,
     };
 
     // This starts the server task.
-    //
-    // `map_err` handles the error by logging it and maps the future to a type
-    // that can be spawned.
-    //
-    // `tokio::run` spawns the task on the Tokio runtime and starts running.
-    tokio::run(server.map_err(|e| println!("server error = {:?}", e)));
+    server.run().await?;
+
     Ok(())
 }

examples/echo.rs

@@ -19,97 +19,61 @@
 //! you! If you open up multiple terminals running the `connect` example you
 //! should be able to see them all make progress simultaneously.
 
-#![deny(warnings)]
+#![warn(rust_2018_idioms)]
 
-extern crate tokio;
-
-use tokio::io;
+use tokio;
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use tokio::net::TcpListener;
-use tokio::prelude::*;
 
 use std::env;
-use std::net::SocketAddr;
+use std::error::Error;
 
-fn main() -> Result<(), Box<std::error::Error>> {
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn Error>> {
     // Allow passing an address to listen on as the first argument of this
     // program, but otherwise we'll just set up our TCP listener on
     // 127.0.0.1:8080 for connections.
-    let addr = env::args().nth(1).unwrap_or("127.0.0.1:8080".to_string());
-    let addr = addr.parse::<SocketAddr>()?;
+    let addr = env::args()
+        .nth(1)
+        .unwrap_or_else(|| "127.0.0.1:8080".to_string());
 
     // Next up we create a TCP listener which will listen for incoming
     // connections. This TCP listener is bound to the address we determined
-    // above and must be associated with an event loop, so we pass in a handle
-    // to our event loop. After the socket's created we inform that we're ready
-    // to go and start accepting connections.
-    let socket = TcpListener::bind(&addr)?;
+    // above and must be associated with an event loop.
+    let mut listener = TcpListener::bind(&addr).await?;
     println!("Listening on: {}", addr);
 
-    // Here we convert the `TcpListener` to a stream of incoming connections
-    // with the `incoming` method. We then define how to process each element in
-    // the stream with the `for_each` method.
-    //
-    // This combinator, defined on the `Stream` trait, will allow us to define a
-    // computation to happen for all items on the stream (in this case TCP
-    // connections made to the server).  The return value of the `for_each`
-    // method is itself a future representing processing the entire stream of
-    // connections, and ends up being our server.
-    let done = socket
-        .incoming()
-        .map_err(|e| println!("failed to accept socket; error = {:?}", e))
-        .for_each(move |socket| {
-            // Once we're inside this closure this represents an accepted client
-            // from our server. The `socket` is the client connection (similar to
-            // how the standard library operates).
-            //
-            // We just want to copy all data read from the socket back onto the
-            // socket itself (e.g. "echo"). We can use the standard `io::copy`
-            // combinator in the `tokio-core` crate to do precisely this!
-            //
-            // The `copy` function takes two arguments, where to read from and where
-            // to write to. We only have one argument, though, with `socket`.
-            // Luckily there's a method, `Io::split`, which will split an Read/Write
-            // stream into its two halves. This operation allows us to work with
-            // each stream independently, such as pass them as two arguments to the
-            // `copy` function.
-            //
-            // The `copy` function then returns a future, and this future will be
-            // resolved when the copying operation is complete, resolving to the
-            // amount of data that was copied.
-            let (reader, writer) = socket.split();
-            let amt = io::copy(reader, writer);
+    loop {
+        // Asynchronously wait for an inbound socket.
+        let (mut socket, _) = listener.accept().await?;
 
-            // After our copy operation is complete we just print out some helpful
-            // information.
-            let msg = amt.then(move |result| {
-                match result {
-                    Ok((amt, _, _)) => println!("wrote {} bytes", amt),
-                    Err(e) => println!("error: {}", e),
+        // And this is where much of the magic of this server happens. We
+        // crucially want all clients to make progress concurrently, rather than
+        // blocking one on completion of another. To achieve this we use the
+        // `tokio::spawn` function to execute the work in the background.
+        //
+        // Essentially here we're executing a new task to run concurrently,
+        // which will allow all of our clients to be processed concurrently.
+
+        tokio::spawn(async move {
+            let mut buf = [0; 1024];
+
+            // In a loop, read data from the socket and write the data back.
+            loop {
+                let n = socket
+                    .read(&mut buf)
+                    .await
+                    .expect("failed to read data from socket");
+
+                if n == 0 {
+                    return;
                 }
 
-                Ok(())
-            });
-
-            // And this is where much of the magic of this server happens. We
-            // crucially want all clients to make progress concurrently, rather than
-            // blocking one on completion of another. To achieve this we use the
-            // `tokio::spawn` function to execute the work in the background.
-            //
-            // This function will transfer ownership of the future (`msg` in this
-            // case) to the Tokio runtime thread pool that. The thread pool will
-            // drive the future to completion.
-            //
-            // Essentially here we're executing a new task to run concurrently,
-            // which will allow all of our clients to be processed concurrently.
-            tokio::spawn(msg)
+                socket
+                    .write_all(&buf[0..n])
+                    .await
+                    .expect("failed to write data to socket");
+            }
         });
-
-    // And finally now that we've define what our server is, we run it!
-    //
-    // This starts the Tokio runtime, spawns the server task, and blocks the
-    // current thread until all tasks complete execution. Since the `done` task
-    // never completes (it just keeps accepting sockets), `tokio::run` blocks
-    // forever (until ctrl-c is pressed).
-    tokio::run(done);
-    Ok(())
+    }
 }

examples/hello_world.rs

@@ -11,48 +11,23 @@
 //!
 //!     cargo run --example hello_world
 
-#![deny(warnings)]
+#![warn(rust_2018_idioms)]
 
-extern crate tokio;
-
-use tokio::io;
+use tokio::io::AsyncWriteExt;
 use tokio::net::TcpStream;
-use tokio::prelude::*;
 
-pub fn main() -> Result<(), Box<std::error::Error>> {
-    let addr = "127.0.0.1:6142".parse()?;
+use std::error::Error;
 
+#[tokio::main]
+pub async fn main() -> Result<(), Box<dyn Error>> {
     // Open a TCP stream to the socket address.
     //
     // Note that this is the Tokio TcpStream, which is fully async.
-    let client = TcpStream::connect(&addr)
-        .and_then(|stream| {
-            println!("created stream");
-            io::write_all(stream, "hello world\n").then(|result| {
-                println!("wrote to stream; success={:?}", result.is_ok());
-                Ok(())
-            })
-        })
-        .map_err(|err| {
-            // All tasks must have an `Error` type of `()`. This forces error
-            // handling and helps avoid silencing failures.
-            //
-            // In our example, we are only going to log the error to STDOUT.
-            println!("connection error = {:?}", err);
-        });
+    let mut stream = TcpStream::connect("127.0.0.1:6142").await?;
+    println!("created stream");
 
-    // Start the Tokio runtime.
-    //
-    // The Tokio is a pre-configured "out of the box" runtime for building
-    // asynchronous applications. It includes both a reactor and a task
-    // scheduler. This means applications are multithreaded by default.
-    //
-    // This function blocks until the runtime reaches an idle state. Idle is
-    // defined as all spawned tasks have completed and all I/O resources (TCP
-    // sockets in our case) have been dropped.
-    println!("About to create the stream and write to it...");
-    tokio::run(client);
-    println!("Stream has been created and written to.");
+    let result = stream.write(b"hello world\n").await;
+    println!("wrote to stream; success={:?}", result.is_ok());
 
     Ok(())
 }

examples/manual-runtime.rs

@@ -1,87 +0,0 @@
-//! An example how to manually assemble a runtime and run some tasks on it.
-//!
-//! This is closer to the single-threaded runtime than the default tokio one, as it is simpler to
-//! grasp. There are conceptually similar, but the multi-threaded one would be more code. If you
-//! just want to *use* a single-threaded runtime, use the one provided by tokio directly
-//! (`tokio::runtime::current_thread::Runtime::new()`. This is a demonstration only.
-//!
-//! Note that the error handling is a bit left out. Also, the `run` could be modified to return the
-//! result of the provided future.
-
-extern crate futures;
-extern crate tokio;
-extern crate tokio_current_thread;
-extern crate tokio_executor;
-extern crate tokio_reactor;
-extern crate tokio_timer;
-
-use std::io::Error as IoError;
-use std::time::{Duration, Instant};
-
-use futures::{future, Future};
-use tokio_current_thread::CurrentThread;
-use tokio_reactor::Reactor;
-use tokio_timer::timer::{self, Timer};
-
-/// Creates a "runtime".
-///
-/// This is similar to running `tokio::runtime::current_thread::Runtime::new()`.
-fn run<F: Future<Item = (), Error = ()>>(f: F) -> Result<(), IoError> {
-    // We need a reactor to receive events about IO objects from kernel
-    let reactor = Reactor::new()?;
-    let reactor_handle = reactor.handle();
-    // Place a timer wheel on top of the reactor. If there are no timeouts to fire, it'll let the
-    // reactor pick up some new external events.
-    let timer = Timer::new(reactor);
-    let timer_handle = timer.handle();
-    // And now put a single-threaded executor on top of the timer. When there are no futures ready
-    // to do something, it'll let the timer or the reactor generate some new stimuli for the
-    // futures to continue in their life.
-    let mut executor = CurrentThread::new_with_park(timer);
-    // Binds an executor to this thread
-    let mut enter = tokio_executor::enter().expect("Multiple executors at once");
-    // This will set the default handle and timer to use inside the closure and run the future.
-    tokio_reactor::with_default(&reactor_handle, &mut enter, |enter| {
-        timer::with_default(&timer_handle, enter, |enter| {
-            // The TaskExecutor is a fake executor that looks into the current single-threaded
-            // executor when used. This is a trick, because we need two mutable references to the
-            // executor (one to run the provided future, another to install as the default one). We
-            // use the fake one here as the default one.
-            let mut default_executor = tokio_current_thread::TaskExecutor::current();
-            tokio_executor::with_default(&mut default_executor, enter, |enter| {
-                let mut executor = executor.enter(enter);
-                // Run the provided future
-                executor.block_on(f).unwrap();
-                // Run all the other futures that are still left in the executor
-                executor.run().unwrap();
-            });
-        });
-    });
-    Ok(())
-}
-
-fn main() -> Result<(), Box<std::error::Error>> {
-    run(future::lazy(|| {
-        // Here comes the application logic. It can spawn further tasks by tokio_current_thread::spawn().
-        // It also can use the default reactor and create timeouts.
-
-        // Connect somewhere. And then do nothing with it. Yes, useless.
-        //
-        // This will use the default reactor which runs in the current thread.
-        let connect = tokio::net::TcpStream::connect(&"127.0.0.1:53".parse().unwrap())
-            .map(|_| println!("Connected"))
-            .map_err(|e| println!("Failed to connect: {}", e));
-        // We can spawn it without requiring Send. This would panic if we run it outside of the
-        // `run` (or outside of anything else)
-        tokio_current_thread::spawn(connect);
-
-        // We can also create timeouts.
-        let deadline = tokio::timer::Delay::new(Instant::now() + Duration::from_secs(5))
-            .map(|()| println!("5 seconds are over"))
-            .map_err(|e| println!("Failed to wait: {}", e));
-        // We can spawn on the default executor, which is also the local one.
-        tokio::executor::spawn(deadline);
-        Ok(())
-    }))?;
-    Ok(())
-}

examples/print_each_packet.rs

@@ -52,99 +52,55 @@
 //! ```
 //!
 
-#![deny(warnings)]
+#![warn(rust_2018_idioms)]
 
-extern crate tokio;
-extern crate tokio_codec;
-
-use tokio::codec::Decoder;
 use tokio::net::TcpListener;
-use tokio::prelude::*;
-use tokio_codec::BytesCodec;
+use tokio::stream::StreamExt;
+use tokio_util::codec::{BytesCodec, Decoder};
 
 use std::env;
-use std::net::SocketAddr;
 
-fn main() -> Result<(), Box<std::error::Error>> {
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Allow passing an address to listen on as the first argument of this
     // program, but otherwise we'll just set up our TCP listener on
     // 127.0.0.1:8080 for connections.
-    let addr = env::args().nth(1).unwrap_or("127.0.0.1:8080".to_string());
-    let addr = addr.parse::<SocketAddr>()?;
+    let addr = env::args()
+        .nth(1)
+        .unwrap_or_else(|| "127.0.0.1:8080".to_string());
 
     // Next up we create a TCP listener which will listen for incoming
     // connections. This TCP listener is bound to the address we determined
     // above and must be associated with an event loop, so we pass in a handle
     // to our event loop. After the socket's created we inform that we're ready
     // to go and start accepting connections.
-    let socket = TcpListener::bind(&addr)?;
+    let mut listener = TcpListener::bind(&addr).await?;
     println!("Listening on: {}", addr);
 
-    // Here we convert the `TcpListener` to a stream of incoming connections
-    // with the `incoming` method. We then define how to process each element in
-    // the stream with the `for_each` method.
-    //
-    // This combinator, defined on the `Stream` trait, will allow us to define a
-    // computation to happen for all items on the stream (in this case TCP
-    // connections made to the server).  The return value of the `for_each`
-    // method is itself a future representing processing the entire stream of
-    // connections, and ends up being our server.
-    let done = socket
-        .incoming()
-        .map_err(|e| println!("failed to accept socket; error = {:?}", e))
-        .for_each(move |socket| {
-            // Once we're inside this closure this represents an accepted client
-            // from our server. The `socket` is the client connection (similar to
-            // how the standard library operates).
-            //
-            // We're parsing each socket with the `BytesCodec` included in `tokio_io`,
-            // and then we `split` each codec into the reader/writer halves.
-            //
-            // See https://docs.rs/tokio-codec/0.1/src/tokio_codec/bytes_codec.rs.html
-            let framed = BytesCodec::new().framed(socket);
-            let (_writer, reader) = framed.split();
+    loop {
+        // Asynchronously wait for an inbound socket.
+        let (socket, _) = listener.accept().await?;
 
-            let processor = reader
-                .for_each(|bytes| {
-                    println!("bytes: {:?}", bytes);
-                    Ok(())
-                })
-                // After our copy operation is complete we just print out some helpful
-                // information.
-                .and_then(|()| {
-                    println!("Socket received FIN packet and closed connection");
-                    Ok(())
-                })
-                .or_else(|err| {
-                    println!("Socket closed with error: {:?}", err);
-                    // We have to return the error to catch it in the next ``.then` call
-                    Err(err)
-                })
-                .then(|result| {
-                    println!("Socket closed with result: {:?}", result);
-                    Ok(())
-                });
+        // And this is where much of the magic of this server happens. We
+        // crucially want all clients to make progress concurrently, rather than
+        // blocking one on completion of another. To achieve this we use the
+        // `tokio::spawn` function to execute the work in the background.
+        //
+        // Essentially here we're executing a new task to run concurrently,
+        // which will allow all of our clients to be processed concurrently.
+        tokio::spawn(async move {
+            // We're parsing each socket with the `BytesCodec` included in `tokio::codec`.
+            let mut framed = BytesCodec::new().framed(socket);
 
-            // And this is where much of the magic of this server happens. We
-            // crucially want all clients to make progress concurrently, rather than
-            // blocking one on completion of another. To achieve this we use the
-            // `tokio::spawn` function to execute the work in the background.
-            //
-            // This function will transfer ownership of the future (`msg` in this
-            // case) to the Tokio runtime thread pool that. The thread pool will
-            // drive the future to completion.
-            //
-            // Essentially here we're executing a new task to run concurrently,
-            // which will allow all of our clients to be processed concurrently.
-            tokio::spawn(processor)
+            // We loop while there are messages coming from the Stream `framed`.
+            // The stream will return None once the client disconnects.
+            while let Some(message) = framed.next().await {
+                match message {
+                    Ok(bytes) => println!("bytes: {:?}", bytes),
+                    Err(err) => println!("Socket closed with error: {:?}", err),
+                }
+            }
+            println!("Socket received FIN packet and closed connection");
         });
-
-    // And finally now that we've define what our server is, we run it!
-    //
-    // This starts the Tokio runtime, spawns the server task, and blocks the
-    // current thread until all tasks complete execution. Since the `done` task
-    // never completes (it just keeps accepting sockets), `tokio::run` blocks
-    // forever (until ctrl-c is pressed).
-    tokio::run(done);
-    Ok(())
+    }
 }

examples/proxy.rs

@@ -20,111 +20,53 @@
 //! This final terminal will connect to our proxy, which will in turn connect to
 //! the echo server, and you'll be able to see data flowing between them.
 
-#![deny(warnings)]
+#![warn(rust_2018_idioms)]
 
-extern crate tokio;
-
-use std::env;
-use std::io::{self, Read, Write};
-use std::net::{Shutdown, SocketAddr};
-use std::sync::{Arc, Mutex};
-
-use tokio::io::{copy, shutdown};
+use tokio::io;
 use tokio::net::{TcpListener, TcpStream};
-use tokio::prelude::*;
 
-fn main() -> Result<(), Box<std::error::Error>> {
-    let listen_addr = env::args().nth(1).unwrap_or("127.0.0.1:8081".to_string());
-    let listen_addr = listen_addr.parse::<SocketAddr>()?;
+use futures::future::try_join;
+use futures::FutureExt;
+use std::env;
+use std::error::Error;
 
-    let server_addr = env::args().nth(2).unwrap_or("127.0.0.1:8080".to_string());
-    let server_addr = server_addr.parse::<SocketAddr>()?;
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn Error>> {
+    let listen_addr = env::args()
+        .nth(1)
+        .unwrap_or_else(|| "127.0.0.1:8081".to_string());
+    let server_addr = env::args()
+        .nth(2)
+        .unwrap_or_else(|| "127.0.0.1:8080".to_string());
 
-    // Create a TCP listener which will listen for incoming connections.
-    let socket = TcpListener::bind(&listen_addr)?;
     println!("Listening on: {}", listen_addr);
     println!("Proxying to: {}", server_addr);
 
-    let done = socket
-        .incoming()
-        .map_err(|e| println!("error accepting socket; error = {:?}", e))
-        .for_each(move |client| {
-            let server = TcpStream::connect(&server_addr);
-            let amounts = server.and_then(move |server| {
-                // Create separate read/write handles for the TCP clients that we're
-                // proxying data between. Note that typically you'd use
-                // `AsyncRead::split` for this operation, but we want our writer
-                // handles to have a custom implementation of `shutdown` which
-                // actually calls `TcpStream::shutdown` to ensure that EOF is
-                // transmitted properly across the proxied connection.
-                //
-                // As a result, we wrap up our client/server manually in arcs and
-                // use the impls below on our custom `MyTcpStream` type.
-                let client_reader = MyTcpStream(Arc::new(Mutex::new(client)));
-                let client_writer = client_reader.clone();
-                let server_reader = MyTcpStream(Arc::new(Mutex::new(server)));
-                let server_writer = server_reader.clone();
+    let mut listener = TcpListener::bind(listen_addr).await?;
 
-                // Copy the data (in parallel) between the client and the server.
-                // After the copy is done we indicate to the remote side that we've
-                // finished by shutting down the connection.
-                let client_to_server = copy(client_reader, server_writer)
-                    .and_then(|(n, _, server_writer)| shutdown(server_writer).map(move |_| n));
-
-                let server_to_client = copy(server_reader, client_writer)
-                    .and_then(|(n, _, client_writer)| shutdown(client_writer).map(move |_| n));
-
-                client_to_server.join(server_to_client)
-            });
-
-            let msg = amounts
-                .map(move |(from_client, from_server)| {
-                    println!(
-                        "client wrote {} bytes and received {} bytes",
-                        from_client, from_server
-                    );
-                })
-                .map_err(|e| {
-                    // Don't panic. Maybe the client just disconnected too soon.
-                    println!("error: {}", e);
-                });
-
-            tokio::spawn(msg);
-
-            Ok(())
+    while let Ok((inbound, _)) = listener.accept().await {
+        let transfer = transfer(inbound, server_addr.clone()).map(|r| {
+            if let Err(e) = r {
+                println!("Failed to transfer; error={}", e);
+            }
         });
 
-    tokio::run(done);
+        tokio::spawn(transfer);
+    }
+
     Ok(())
 }
 
-// This is a custom type used to have a custom implementation of the
-// `AsyncWrite::shutdown` method which actually calls `TcpStream::shutdown` to
-// notify the remote end that we're done writing.
-#[derive(Clone)]
-struct MyTcpStream(Arc<Mutex<TcpStream>>);
+async fn transfer(mut inbound: TcpStream, proxy_addr: String) -> Result<(), Box<dyn Error>> {
+    let mut outbound = TcpStream::connect(proxy_addr).await?;
 
-impl Read for MyTcpStream {
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        self.0.lock().unwrap().read(buf)
-    }
-}
-
-impl Write for MyTcpStream {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.0.lock().unwrap().write(buf)
-    }
-
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-impl AsyncRead for MyTcpStream {}
-
-impl AsyncWrite for MyTcpStream {
-    fn shutdown(&mut self) -> Poll<(), io::Error> {
-        try!(self.0.lock().unwrap().shutdown(Shutdown::Write));
-        Ok(().into())
-    }
+    let (mut ri, mut wi) = inbound.split();
+    let (mut ro, mut wo) = outbound.split();
+
+    let client_to_server = io::copy(&mut ri, &mut wo);
+    let server_to_client = io::copy(&mut ro, &mut wi);
+
+    try_join(client_to_server, server_to_client).await?;
+
+    Ok(())
 }

examples/tinydb.rs

@@ -39,20 +39,18 @@
 //! * `SET $key $value` - this will set the value of `$key` to `$value`,
 //!   returning the previous value, if any.
 
-#![deny(warnings)]
+#![warn(rust_2018_idioms)]
 
-extern crate tokio;
+use tokio::net::TcpListener;
+use tokio::stream::StreamExt;
+use tokio_util::codec::{Framed, LinesCodec};
 
+use futures::SinkExt;
 use std::collections::HashMap;
 use std::env;
-use std::io::BufReader;
-use std::net::SocketAddr;
+use std::error::Error;
 use std::sync::{Arc, Mutex};
 
-use tokio::io::{lines, write_all};
-use tokio::net::TcpListener;
-use tokio::prelude::*;
-
 /// The in-memory database shared amongst all clients.
 ///
 /// This database will be shared via `Arc`, so to mutate the internal map we're
@@ -83,12 +81,15 @@ enum Response {
     },
 }
 
-fn main() -> Result<(), Box<std::error::Error>> {
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn Error>> {
     // Parse the address we're going to run this server on
     // and set up our TCP listener to accept connections.
-    let addr = env::args().nth(1).unwrap_or("127.0.0.1:8080".to_string());
-    let addr = addr.parse::<SocketAddr>()?;
-    let listener = TcpListener::bind(&addr).map_err(|_| "failed to bind")?;
+    let addr = env::args()
+        .nth(1)
+        .unwrap_or_else(|| "127.0.0.1:8080".to_string());
+
+    let mut listener = TcpListener::bind(&addr).await?;
     println!("Listening on: {}", addr);
 
     // Create the shared state of this server that will be shared amongst all
@@ -102,91 +103,87 @@ fn main() -> Result<(), Box<std::error::Error>> {
         map: Mutex::new(initial_db),
     });
 
-    let done = listener
-        .incoming()
-        .map_err(|e| println!("error accepting socket; error = {:?}", e))
-        .for_each(move |socket| {
-            // As with many other small examples, the first thing we'll do is
-            // *split* this TCP stream into two separately owned halves. This'll
-            // allow us to work with the read and write halves independently.
-            let (reader, writer) = socket.split();
+    loop {
+        match listener.accept().await {
+            Ok((socket, _)) => {
+                // After getting a new connection first we see a clone of the database
+                // being created, which is creating a new reference for this connected
+                // client to use.
+                let db = db.clone();
 
-            // Since our protocol is line-based we use `tokio_io`'s `lines` utility
-            // to convert our stream of bytes, `reader`, into a `Stream` of lines.
-            let lines = lines(BufReader::new(reader));
+                // Like with other small servers, we'll `spawn` this client to ensure it
+                // runs concurrently with all other clients. The `move` keyword is used
+                // here to move ownership of our db handle into the async closure.
+                tokio::spawn(async move {
+                    // Since our protocol is line-based we use `tokio_codecs`'s `LineCodec`
+                    // to convert our stream of bytes, `socket`, into a `Stream` of lines
+                    // as well as convert our line based responses into a stream of bytes.
+                    let mut lines = Framed::new(socket, LinesCodec::new());
 
-            // Here's where the meat of the processing in this server happens. First
-            // we see a clone of the database being created, which is creating a
-            // new reference for this connected client to use. Also note the `move`
-            // keyword on the closure here which moves ownership of the reference
-            // into the closure, which we'll need for spawning the client below.
-            //
-            // The `map` function here means that we'll run some code for all
-            // requests (lines) we receive from the client. The actual handling here
-            // is pretty simple, first we parse the request and if it's valid we
-            // generate a response based on the values in the database.
-            let db = db.clone();
-            let responses = lines.map(move |line| {
-                let request = match Request::parse(&line) {
-                    Ok(req) => req,
-                    Err(e) => return Response::Error { msg: e },
-                };
+                    // Here for every line we get back from the `Framed` decoder,
+                    // we parse the request, and if it's valid we generate a response
+                    // based on the values in the database.
+                    while let Some(result) = lines.next().await {
+                        match result {
+                            Ok(line) => {
+                                let response = handle_request(&line, &db);
 
-                let mut db = db.map.lock().unwrap();
-                match request {
-                    Request::Get { key } => match db.get(&key) {
-                        Some(value) => Response::Value {
-                            key,
-                            value: value.clone(),
-                        },
-                        None => Response::Error {
-                            msg: format!("no key {}", key),
-                        },
-                    },
-                    Request::Set { key, value } => {
-                        let previous = db.insert(key.clone(), value.clone());
-                        Response::Set {
-                            key,
-                            value,
-                            previous,
+                                let response = response.serialize();
+
+                                if let Err(e) = lines.send(response).await {
+                                    println!("error on sending response; error = {:?}", e);
+                                }
+                            }
+                            Err(e) => {
+                                println!("error on decoding from socket; error = {:?}", e);
+                            }
                         }
                     }
-                }
-            });
 
-            // At this point `responses` is a stream of `Response` types which we
-            // now want to write back out to the client. To do that we use
-            // `Stream::fold` to perform a loop here, serializing each response and
-            // then writing it out to the client.
-            let writes = responses.fold(writer, |writer, response| {
-                let mut response = response.serialize();
-                response.push('\n');
-                write_all(writer, response.into_bytes()).map(|(w, _)| w)
-            });
+                    // The connection will be closed at this point as `lines.next()` has returned `None`.
+                });
+            }
+            Err(e) => println!("error accepting socket; error = {:?}", e),
+        }
+    }
+}
 
-            // Like with other small servers, we'll `spawn` this client to ensure it
-            // runs concurrently with all other clients, for now ignoring any errors
-            // that we see.
-            let msg = writes.then(move |_| Ok(()));
+fn handle_request(line: &str, db: &Arc<Database>) -> Response {
+    let request = match Request::parse(&line) {
+        Ok(req) => req,
+        Err(e) => return Response::Error { msg: e },
+    };
 
-            tokio::spawn(msg)
-        });
-
-    tokio::run(done);
-    Ok(())
+    let mut db = db.map.lock().unwrap();
+    match request {
+        Request::Get { key } => match db.get(&key) {
+            Some(value) => Response::Value {
+                key,
+                value: value.clone(),
+            },
+            None => Response::Error {
+                msg: format!("no key {}", key),
+            },
+        },
+        Request::Set { key, value } => {
+            let previous = db.insert(key.clone(), value.clone());
+            Response::Set {
+                key,
+                value,
+                previous,
+            }
+        }
+    }
 }
 
 impl Request {
     fn parse(input: &str) -> Result<Request, String> {
-        let mut parts = input.splitn(3, " ");
+        let mut parts = input.splitn(3, ' ');
         match parts.next() {
             Some("GET") => {
-                let key = match parts.next() {
-                    Some(key) => key,
-                    None => return Err(format!("GET must be followed by a key")),
-                };
+                let key = parts.next().ok_or("GET must be followed by a key")?;
                 if parts.next().is_some() {
-                    return Err(format!("GET's key must not be followed by anything"));
+                    return Err("GET's key must not be followed by anything".into());
                 }
                 Ok(Request::Get {
                     key: key.to_string(),
@@ -195,11 +192,11 @@ impl Request {
             Some("SET") => {
                 let key = match parts.next() {
                     Some(key) => key,
-                    None => return Err(format!("SET must be followed by a key")),
+                    None => return Err("SET must be followed by a key".into()),
                 };
                 let value = match parts.next() {
                     Some(value) => value,
-                    None => return Err(format!("SET needs a value")),
+                    None => return Err("SET needs a value".into()),
                 };
                 Ok(Request::Set {
                     key: key.to_string(),
@@ -207,7 +204,7 @@ impl Request {
                 })
             }
             Some(cmd) => Err(format!("unknown command: {}", cmd)),
-            None => Err(format!("empty input")),
+            None => Err("empty input".into()),
         }
     }
 }

examples/tinyhttp.rs

@@ -11,108 +11,85 @@
 //! respectively. By default this will run I/O on all the cores your system has
 //! available, and it doesn't support HTTP request bodies.
 
-#![deny(warnings)]
-
-extern crate bytes;
-extern crate http;
-extern crate httparse;
-#[macro_use]
-extern crate serde_derive;
-extern crate serde_json;
-extern crate time;
-extern crate tokio;
-extern crate tokio_io;
-
-use std::net::SocketAddr;
-use std::{env, fmt, io};
-
-use tokio::codec::{Decoder, Encoder};
-use tokio::net::{TcpListener, TcpStream};
-use tokio::prelude::*;
+#![warn(rust_2018_idioms)]
 
 use bytes::BytesMut;
-use http::header::HeaderValue;
-use http::{Request, Response, StatusCode};
+use futures::SinkExt;
+use http::{header::HeaderValue, Request, Response, StatusCode};
+#[macro_use]
+extern crate serde_derive;
+use serde_json;
+use std::{env, error::Error, fmt, io};
+use tokio::net::{TcpListener, TcpStream};
+use tokio::stream::StreamExt;
+use tokio_util::codec::{Decoder, Encoder, Framed};
 
-fn main() -> Result<(), Box<std::error::Error>> {
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn Error>> {
     // Parse the arguments, bind the TCP socket we'll be listening to, spin up
     // our worker threads, and start shipping sockets to those worker threads.
-    let addr = env::args().nth(1).unwrap_or("127.0.0.1:8080".to_string());
-    let addr = addr.parse::<SocketAddr>()?;
-
-    let listener = TcpListener::bind(&addr)?;
+    let addr = env::args()
+        .nth(1)
+        .unwrap_or_else(|| "127.0.0.1:8080".to_string());
+    let mut server = TcpListener::bind(&addr).await?;
+    let mut incoming = server.incoming();
     println!("Listening on: {}", addr);
 
-    tokio::run({
-        listener
-            .incoming()
-            .map_err(|e| println!("failed to accept socket; error = {:?}", e))
-            .for_each(|socket| {
-                process(socket);
-                Ok(())
-            })
-    });
+    while let Some(Ok(stream)) = incoming.next().await {
+        tokio::spawn(async move {
+            if let Err(e) = process(stream).await {
+                println!("failed to process connection; error = {}", e);
+            }
+        });
+    }
+
     Ok(())
 }
 
-fn process(socket: TcpStream) {
-    let (tx, rx) =
-        // Frame the socket using the `Http` protocol. This maps the TCP socket
-        // to a Stream + Sink of HTTP frames.
-        Http.framed(socket)
-        // This splits a single `Stream + Sink` value into two separate handles
-        // that can be used independently (even on different tasks or threads).
-        .split();
+async fn process(stream: TcpStream) -> Result<(), Box<dyn Error>> {
+    let mut transport = Framed::new(stream, Http);
 
-    // Map all requests into responses and send them back to the client.
-    let task = tx.send_all(rx.and_then(respond)).then(|res| {
-        if let Err(e) = res {
-            println!("failed to process connection; error = {:?}", e);
+    while let Some(request) = transport.next().await {
+        match request {
+            Ok(request) => {
+                let response = respond(request).await?;
+                transport.send(response).await?;
+            }
+            Err(e) => return Err(e.into()),
         }
+    }
 
-        Ok(())
-    });
-
-    // Spawn the task that handles the connection.
-    tokio::spawn(task);
+    Ok(())
 }
 
-/// "Server logic" is implemented in this function.
-///
-/// This function is a map from and HTTP request to a future of a response and
-/// represents the various handling a server might do. Currently the contents
-/// here are pretty uninteresting.
-fn respond(req: Request<()>) -> Box<Future<Item = Response<String>, Error = io::Error> + Send> {
-    let f = future::lazy(move || {
-        let mut response = Response::builder();
-        let body = match req.uri().path() {
-            "/plaintext" => {
-                response.header("Content-Type", "text/plain");
-                "Hello, World!".to_string()
-            }
-            "/json" => {
-                response.header("Content-Type", "application/json");
+async fn respond(req: Request<()>) -> Result<Response<String>, Box<dyn Error>> {
+    let mut response = Response::builder();
+    let body = match req.uri().path() {
+        "/plaintext" => {
+            response = response.header("Content-Type", "text/plain");
+            "Hello, World!".to_string()
+        }
+        "/json" => {
+            response = response.header("Content-Type", "application/json");
 
-                #[derive(Serialize)]
-                struct Message {
-                    message: &'static str,
-                }
-                serde_json::to_string(&Message {
-                    message: "Hello, World!",
-                })?
+            #[derive(Serialize)]
+            struct Message {
+                message: &'static str,
             }
-            _ => {
-                response.status(StatusCode::NOT_FOUND);
-                String::new()
-            }
-        };
-        let response = response
-            .body(body)
-            .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?;
-        Ok(response)
-    });
+            serde_json::to_string(&Message {
+                message: "Hello, World!",
+            })?
+        }
+        _ => {
+            response = response.status(StatusCode::NOT_FOUND);
+            String::new()
+        }
+    };
+    let response = response
+        .body(body)
+        .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?;
 
-    Box::new(f)
+    Ok(response)
 }
 
 struct Http;
@@ -157,13 +134,13 @@ impl Encoder for Http {
         // doesn't go through io::Error.
         struct BytesWrite<'a>(&'a mut BytesMut);
 
-        impl<'a> fmt::Write for BytesWrite<'a> {
+        impl fmt::Write for BytesWrite<'_> {
             fn write_str(&mut self, s: &str) -> fmt::Result {
                 self.0.extend_from_slice(s.as_bytes());
                 Ok(())
             }
 
-            fn write_fmt(&mut self, args: fmt::Arguments) -> fmt::Result {
+            fn write_fmt(&mut self, args: fmt::Arguments<'_>) -> fmt::Result {
                 fmt::write(self, args)
             }
         }
@@ -222,16 +199,19 @@ impl Decoder for Http {
         }
         let data = src.split_to(amt).freeze();
         let mut ret = Request::builder();
-        ret.method(&data[method.0..method.1]);
-        ret.uri(data.slice(path.0, path.1));
-        ret.version(http::Version::HTTP_11);
+        ret = ret.method(&data[method.0..method.1]);
+        let s = data.slice(path.0..path.1);
+        let s = unsafe { String::from_utf8_unchecked(Vec::from(s.as_ref())) };
+        ret = ret.uri(s);
+        ret = ret.version(http::Version::HTTP_11);
         for header in headers.iter() {
             let (k, v) = match *header {
                 Some((ref k, ref v)) => (k, v),
                 None => break,
             };
-            let value = unsafe { HeaderValue::from_shared_unchecked(data.slice(v.0, v.1)) };
-            ret.header(&data[k.0..k.1], value);
+            let value = HeaderValue::from_bytes(data.slice(v.0..v.1).as_ref())
+                .map_err(|_| io::Error::new(io::ErrorKind::Other, "header decode error"))?;
+            ret = ret.header(&data[k.0..k.1], value);
         }
 
         let req = ret
@@ -286,7 +266,7 @@ mod date {
     }));
 
     impl fmt::Display for Now {
-        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
             LAST.with(|cache| {
                 let mut cache = cache.borrow_mut();
                 let now = time::get_time();
@@ -313,7 +293,7 @@ mod date {
 
     struct LocalBuffer<'a>(&'a mut LastRenderedNow);
 
-    impl<'a> fmt::Write for LocalBuffer<'a> {
+    impl fmt::Write for LocalBuffer<'_> {
         fn write_str(&mut self, s: &str) -> fmt::Result {
             let start = self.0.amt;
             let end = start + s.len();

examples/udp-client.rs

@@ -26,26 +26,27 @@
 //! Please mind that since the UDP protocol doesn't have any capabilities to detect a broken
 //! connection the server needs to be run first, otherwise the client will block forever.
 
-extern crate futures;
-extern crate tokio;
+#![warn(rust_2018_idioms)]
 
 use std::env;
-use std::io::stdin;
+use std::error::Error;
+use std::io::{stdin, Read};
 use std::net::SocketAddr;
 use tokio::net::UdpSocket;
-use tokio::prelude::*;
 
-fn get_stdin_data() -> Result<Vec<u8>, Box<std::error::Error>> {
+fn get_stdin_data() -> Result<Vec<u8>, Box<dyn std::error::Error>> {
     let mut buf = Vec::new();
     stdin().read_to_end(&mut buf)?;
     Ok(buf)
 }
 
-fn main() -> Result<(), Box<std::error::Error>> {
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn Error>> {
     let remote_addr: SocketAddr = env::args()
         .nth(1)
-        .unwrap_or("127.0.0.1:8080".into())
+        .unwrap_or_else(|| "127.0.0.1:8080".into())
         .parse()?;
+
     // We use port 0 to let the operating system allocate an available port for us.
     let local_addr: SocketAddr = if remote_addr.is_ipv4() {
         "0.0.0.0:0"
@@ -53,18 +54,19 @@ fn main() -> Result<(), Box<std::error::Error>> {
         "[::]:0"
     }
     .parse()?;
-    let socket = UdpSocket::bind(&local_addr)?;
+
+    let mut socket = UdpSocket::bind(local_addr).await?;
     const MAX_DATAGRAM_SIZE: usize = 65_507;
-    socket
-        .send_dgram(get_stdin_data()?, &remote_addr)
-        .and_then(|(socket, _)| socket.recv_dgram(vec![0u8; MAX_DATAGRAM_SIZE]))
-        .map(|(_, data, len, _)| {
-            println!(
-                "Received {} bytes:\n{}",
-                len,
-                String::from_utf8_lossy(&data[..len])
-            )
-        })
-        .wait()?;
+    socket.connect(&remote_addr).await?;
+    let data = get_stdin_data()?;
+    socket.send(&data).await?;
+    let mut data = vec![0u8; MAX_DATAGRAM_SIZE];
+    let len = socket.recv(&mut data).await?;
+    println!(
+        "Received {} bytes:\n{}",
+        len,
+        String::from_utf8_lossy(&data[..len])
+    );
+
     Ok(())
 }

examples/udp-codec.rs

@@ -1,65 +1,80 @@
 //! This example leverages `BytesCodec` to create a UDP client and server which
 //! speak a custom protocol.
 //!
-//! Here we're using the codec from tokio-io to convert a UDP socket to a stream of
+//! Here we're using the codec from `tokio-codec` to convert a UDP socket to a stream of
 //! client messages. These messages are then processed and returned back as a
 //! new message with a new destination. Overall, we then use this to construct a
 //! "ping pong" pair where two sockets are sending messages back and forth.
 
-#![deny(warnings)]
+#![warn(rust_2018_idioms)]
 
-extern crate env_logger;
-extern crate tokio;
-extern crate tokio_codec;
-extern crate tokio_io;
+use tokio::net::UdpSocket;
+use tokio::stream::StreamExt;
+use tokio::{io, time};
+use tokio_util::codec::BytesCodec;
+use tokio_util::udp::UdpFramed;
 
+use bytes::Bytes;
+use futures::{FutureExt, SinkExt};
+use std::env;
+use std::error::Error;
 use std::net::SocketAddr;
+use std::time::Duration;
 
-use tokio::net::{UdpFramed, UdpSocket};
-use tokio::prelude::*;
-use tokio_codec::BytesCodec;
-
-fn main() -> Result<(), Box<std::error::Error>> {
-    let _ = env_logger::init();
-
-    let addr: SocketAddr = "127.0.0.1:0".parse()?;
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn Error>> {
+    let addr = env::args()
+        .nth(1)
+        .unwrap_or_else(|| "127.0.0.1:0".to_string());
 
     // Bind both our sockets and then figure out what ports we got.
-    let a = UdpSocket::bind(&addr)?;
-    let b = UdpSocket::bind(&addr)?;
+    let a = UdpSocket::bind(&addr).await?;
+    let b = UdpSocket::bind(&addr).await?;
+
     let b_addr = b.local_addr()?;
 
-    // We're parsing each socket with the `BytesCodec` included in `tokio_io`, and then we
-    // `split` each codec into the sink/stream halves.
-    let (a_sink, a_stream) = UdpFramed::new(a, BytesCodec::new()).split();
-    let (b_sink, b_stream) = UdpFramed::new(b, BytesCodec::new()).split();
+    let mut a = UdpFramed::new(a, BytesCodec::new());
+    let mut b = UdpFramed::new(b, BytesCodec::new());
 
     // Start off by sending a ping from a to b, afterwards we just print out
     // what they send us and continually send pings
-    // let pings = stream::iter((0..5).map(Ok));
-    let a = a_sink.send(("PING".into(), b_addr)).and_then(|a_sink| {
-        let mut i = 0;
-        let a_stream = a_stream.take(4).map(move |(msg, addr)| {
-            i += 1;
-            println!("[a] recv: {}", String::from_utf8_lossy(&msg));
-            (format!("PING {}", i).into(), addr)
-        });
-        a_sink.send_all(a_stream)
-    });
+    let a = ping(&mut a, b_addr);
 
     // The second client we have will receive the pings from `a` and then send
     // back pongs.
-    let b_stream = b_stream.map(|(msg, addr)| {
-        println!("[b] recv: {}", String::from_utf8_lossy(&msg));
-        ("PONG".into(), addr)
-    });
-    let b = b_sink.send_all(b_stream);
+    let b = pong(&mut b);
+
+    // Run both futures simultaneously of `a` and `b` sending messages back and forth.
+    match futures::future::try_join(a, b).await {
+        Err(e) => println!("an error occured; error = {:?}", e),
+        _ => println!("done!"),
+    }
+
+    Ok(())
+}
+
+async fn ping(socket: &mut UdpFramed<BytesCodec>, b_addr: SocketAddr) -> Result<(), io::Error> {
+    socket.send((Bytes::from(&b"PING"[..]), b_addr)).await?;
+
+    for _ in 0..4usize {
+        let (bytes, addr) = socket.next().map(|e| e.unwrap()).await?;
+
+        println!("[a] recv: {}", String::from_utf8_lossy(&bytes));
+
+        socket.send((Bytes::from(&b"PING"[..]), addr)).await?;
+    }
+
+    Ok(())
+}
+
+async fn pong(socket: &mut UdpFramed<BytesCodec>) -> Result<(), io::Error> {
+    let timeout = Duration::from_millis(200);
+
+    while let Ok(Some(Ok((bytes, addr)))) = time::timeout(timeout, socket.next()).await {
+        println!("[b] recv: {}", String::from_utf8_lossy(&bytes));
+
+        socket.send((Bytes::from(&b"PONG"[..]), addr)).await?;
+    }
 
-    // Spawn the sender of pongs and then wait for our pinger to finish.
-    tokio::run({
-        b.join(a)
-            .map(|_| ())
-            .map_err(|e| println!("error = {:?}", e))
-    });
     Ok(())
 }

rustfmt.toml

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

tests-build/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "tests-build"
+version = "0.1.0"
+authors = ["Tokio Contributors <[email protected]>"]
+edition = "2018"
+publish = false
+
+[features]
+full = ["tokio/full"]
+
+[dependencies]
+tokio = { path = "../tokio", optional = true }
+
+[dev-dependencies]
+trybuild = "1.0"

tests-build/README.md

@@ -0,0 +1,2 @@
+Tests the various combination of feature flags. This is broken out to a separate
+crate to work around limitations with cargo features.

tests-build/src/lib.rs

@@ -0,0 +1,2 @@
+#[cfg(feature = "tokio")]
+pub use tokio;

tests-build/tests/fail/macros_invalid_input.rs

@@ -0,0 +1,25 @@
+use tests_build::tokio;
+
+#[tokio::main]
+fn main_is_not_async() {}
+
+#[tokio::main(foo)]
+async fn main_attr_has_unknown_args() {}
+
+#[tokio::main(threadpool::bar)]
+async fn main_attr_has_path_args() {}
+
+#[tokio::test]
+fn test_is_not_async() {}
+
+#[tokio::test]
+async fn test_fn_has_args(_x: u8) {}
+
+#[tokio::test(foo)]
+async fn test_attr_has_args() {}
+
+#[tokio::test]
+#[test]
+async fn test_has_second_test_attr() {}
+
+fn main() {}

tests-build/tests/fail/macros_invalid_input.stderr

@@ -0,0 +1,41 @@
+error: the async keyword is missing from the function declaration
+ --> $DIR/macros_invalid_input.rs:4:1
+  |
+4 | fn main_is_not_async() {}
+  | ^^
+
+error: Unknown attribute foo is specified; expected `basic_scheduler` or `threaded_scheduler`
+ --> $DIR/macros_invalid_input.rs:6:15
+  |
+6 | #[tokio::main(foo)]
+  |               ^^^
+
+error: Must have specified ident
+ --> $DIR/macros_invalid_input.rs:9:15
+  |
+9 | #[tokio::main(threadpool::bar)]
+  |               ^^^^^^^^^^^^^^^
+
+error: the async keyword is missing from the function declaration
+  --> $DIR/macros_invalid_input.rs:13:1
+   |
+13 | fn test_is_not_async() {}
+   | ^^
+
+error: the test function cannot accept arguments
+  --> $DIR/macros_invalid_input.rs:16:27
+   |
+16 | async fn test_fn_has_args(_x: u8) {}
+   |                           ^^^^^^
+
+error: Unknown attribute foo is specified; expected `basic_scheduler` or `threaded_scheduler`
+  --> $DIR/macros_invalid_input.rs:18:15
+   |
+18 | #[tokio::test(foo)]
+   |               ^^^
+
+error: second test attribute is supplied
+  --> $DIR/macros_invalid_input.rs:22:1
+   |
+22 | #[test]
+   | ^^^^^^^

tests-build/tests/macros.rs

@@ -0,0 +1,9 @@
+#[test]
+fn compile_fail() {
+    let t = trybuild::TestCases::new();
+
+    #[cfg(feature = "full")]
+    t.compile_fail("tests/fail/macros_invalid_input.rs");
+
+    drop(t);
+}

tests-integration/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "tests-integration"
+version = "0.1.0"
+authors = ["Tokio Contributors <[email protected]>"]
+edition = "2018"
+publish = false
+
+[dependencies]
+tokio = { path = "../tokio", features = ["full"] }
+doc-comment = "0.3.1"
+
+[dev-dependencies]
+tokio-test = { path = "../tokio-test" }
+
+futures = { version = "0.3.0", features = ["async-await"] }

tests-integration/README.md

@@ -0,0 +1 @@
+Tests that require additional components than just the `tokio` crate.

tests-integration/src/bin/test-cat.rs

@@ -0,0 +1,20 @@
+//! A cat-like utility that can be used as a subprocess to test I/O
+//! stream communication.
+
+use std::io;
+use std::io::Write;
+
+fn main() {
+    let stdin = io::stdin();
+    let mut stdout = io::stdout();
+    let mut line = String::new();
+    loop {
+        line.clear();
+        stdin.read_line(&mut line).unwrap();
+        if line.is_empty() {
+            break;
+        }
+        stdout.write_all(line.as_bytes()).unwrap();
+    }
+    stdout.flush().unwrap();
+}

tests-integration/src/lib.rs

@@ -0,0 +1,4 @@
+use doc_comment::doc_comment;
+
+// #[doc = include_str!("../../README.md")]
+doc_comment!(include_str!("../../README.md"));

tests-integration/tests/process_stdio.rs

@@ -0,0 +1,126 @@
+#![warn(rust_2018_idioms)]
+
+use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
+use tokio::process::{Child, Command};
+use tokio_test::assert_ok;
+
+use futures::future::{self, FutureExt};
+use std::env;
+use std::io;
+use std::process::{ExitStatus, Stdio};
+
+fn cat() -> Command {
+    let mut me = env::current_exe().unwrap();
+    me.pop();
+
+    if me.ends_with("deps") {
+        me.pop();
+    }
+
+    me.push("test-cat");
+
+    let mut cmd = Command::new(me);
+    cmd.stdin(Stdio::piped()).stdout(Stdio::piped());
+    cmd
+}
+
+async fn feed_cat(mut cat: Child, n: usize) -> io::Result<ExitStatus> {
+    let mut stdin = cat.stdin().take().unwrap();
+    let stdout = cat.stdout().take().unwrap();
+
+    // Produce n lines on the child's stdout.
+    let write = async {
+        for i in 0..n {
+            let bytes = format!("line {}\n", i).into_bytes();
+            stdin.write_all(&bytes).await.unwrap();
+        }
+
+        drop(stdin);
+    };
+
+    let read = async {
+        let mut reader = BufReader::new(stdout).lines();
+        let mut num_lines = 0;
+
+        // Try to read `n + 1` lines, ensuring the last one is empty
+        // (i.e. EOF is reached after `n` lines.
+        loop {
+            let data = reader
+                .next_line()
+                .await
+                .unwrap_or_else(|_| Some(String::new()))
+                .expect("failed to read line");
+
+            let num_read = data.len();
+            let done = num_lines >= n;
+
+            match (done, num_read) {
+                (false, 0) => panic!("broken pipe"),
+                (true, n) if n != 0 => panic!("extraneous data"),
+                _ => {
+                    let expected = format!("line {}", num_lines);
+                    assert_eq!(expected, data);
+                }
+            };
+
+            num_lines += 1;
+            if num_lines >= n {
+                break;
+            }
+        }
+    };
+
+    // Compose reading and writing concurrently.
+    future::join3(write, read, cat)
+        .map(|(_, _, status)| status)
+        .await
+}
+
+/// Check for the following properties when feeding stdin and
+/// consuming stdout of a cat-like process:
+///
+/// - A number of lines that amounts to a number of bytes exceeding a
+///   typical OS buffer size can be fed to the child without
+///   deadlock. This tests that we also consume the stdout
+///   concurrently; otherwise this would deadlock.
+///
+/// - We read the same lines from the child that we fed it.
+///
+/// - The child does produce EOF on stdout after the last line.
+#[tokio::test]
+async fn feed_a_lot() {
+    let child = cat().spawn().unwrap();
+    let status = feed_cat(child, 10000).await.unwrap();
+    assert_eq!(status.code(), Some(0));
+}
+
+#[tokio::test]
+async fn wait_with_output_captures() {
+    let mut child = cat().spawn().unwrap();
+    let mut stdin = child.stdin().take().unwrap();
+
+    let write_bytes = b"1234";
+
+    let future = async {
+        stdin.write_all(write_bytes).await?;
+        drop(stdin);
+        let out = child.wait_with_output();
+        out.await
+    };
+
+    let output = future.await.unwrap();
+
+    assert!(output.status.success());
+    assert_eq!(output.stdout, write_bytes);
+    assert_eq!(output.stderr.len(), 0);
+}
+
+#[tokio::test]
+async fn status_closes_any_pipes() {
+    // Cat will open a pipe between the parent and child.
+    // If `status_async` doesn't ensure the handles are closed,
+    // we would end up blocking forever (and time out).
+    let child = cat().status();
+
+    assert_ok!(child.await);
+}

tokio-async-await/Cargo.toml

@@ -1,29 +0,0 @@
-[package]
-name = "tokio-async-await"
-
-# When releasing to crates.io:
-# - Update html_root_url.
-version = "0.1.6"
-authors = ["Carl Lerche <[email protected]>"]
-license = "MIT"
-repository = "https://github.com/tokio-rs/tokio"
-homepage = "https://tokio.rs"
-documentation = "https://docs.rs/tokio-async-await/0.1.6"
-description = """
-Experimental async/await support for Tokio
-"""
-categories = ["asynchronous"]
-
-[features]
-# This feature comes with no promise of stability. Things will
-# break with each patch release. Use at your own risk.
-async-await-preview = ["futures/nightly"]
-
-[dependencies]
-futures = "0.1.23"
-tokio-io = "0.1.7"
-
-[dev-dependencies]
-bytes = "0.4.9"
-tokio = "0.1.8"
-hyper = "0.12.8"

tokio-async-await/LICENSE

@@ -1,52 +0,0 @@
-Copyright (c) 2019 Tokio Contributors
-
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
-
-Copyright (c) 2016 futures-rs authors
-
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
-

tokio-async-await/README.md

@@ -1,55 +0,0 @@
-# Tokio async/await preview
-
-This crate provides a preview of Tokio with async / await support. It is a shim
-layer on top of `tokio`.
-
-**This crate requires Rust nightly and does not provide API stability
-guarantees. You are living on the edge here.**
-
-## Usage
-
-To use this crate, you need to start with a Rust 2018 edition crate, with rustc
-1.34.0-nightly or later.
-
-Add this to your `Cargo.toml`:
-
-```toml
-# In the `[packages]` section
-edition = "2018"
-
-# In the `[dependencies]` section
-tokio = {version = "0.1.15", features = ["async-await-preview"]}
-```
-
-Then, get started. In your application, add:
-
-```rust
-// The nightly features that are commonly needed with async / await
-#![feature(await_macro, async_await, futures_api)]
-
-// This pulls in the `tokio-async-await` crate. While Rust 2018 doesn't require
-// `extern crate`, we need to pull in the macros.
-#[macro_use]
-extern crate tokio;
-
-fn main() {
-    // And we are async...
-    tokio::run_async(async {
-        println!("Hello");
-    });
-}
-```
-
-Because nightly is required, run the app with `cargo +nightly run`
-
-Check the [examples](examples) directory for more.
-
-## License
-
-This project is licensed under the [MIT license](LICENSE).
-
-### Contribution
-
-Unless you explicitly state otherwise, any contribution intentionally submitted
-for inclusion in Tokio by you, shall be licensed as MIT, without any additional
-terms or conditions.

tokio-async-await/examples/.cargo/config

@@ -1,2 +0,0 @@
-[build]
-target-dir = "../../target"

tokio-async-await/examples/Cargo.toml

@@ -1,49 +0,0 @@
-[package]
-name = "examples"
-edition = "2018"
-version = "0.1.0"
-authors = ["Carl Lerche <[email protected]>"]
-license = "MIT"
-
-# Break out of the parent workspace
-[workspace]
-
-[[bin]]
-name = "chat"
-path = "src/chat.rs"
-
-[[bin]]
-name = "echo_client"
-path = "src/echo_client.rs"
-
-[[bin]]
-name = "echo_server"
-path = "src/echo_server.rs"
-
-[[bin]]
-name = "hyper"
-path = "src/hyper.rs"
-
-[dependencies]
-tokio = { version = "0.1.0", path = "../..", features = ["async-await-preview"] }
-futures = "0.1.23"
-bytes = "0.4.9"
-hyper = "0.12.8"
-
-# Avoid using crates.io for Tokio dependencies
-[patch.crates-io]
-tokio = { path = "../.." }
-tokio-async-await  = { path = "../" }
-tokio-codec = { path = "../../tokio-codec" }
-tokio-current-thread = { path = "../../tokio-current-thread" }
-tokio-executor = { path = "../../tokio-executor" }
-tokio-fs = { path = "../../tokio-fs" }
-tokio-io = { path = "../../tokio-io" }
-tokio-reactor = { path = "../../tokio-reactor" }
-tokio-signal = { path = "../../tokio-signal" }
-tokio-tcp = { path = "../../tokio-tcp" }
-tokio-threadpool = { path = "../../tokio-threadpool" }
-tokio-timer = { path = "../../tokio-timer" }
-tokio-tls = { path = "../../tokio-tls" }
-tokio-udp = { path = "../../tokio-udp" }
-tokio-uds = { path = "../../tokio-uds" }

tokio-async-await/examples/README.md

@@ -1,5 +0,0 @@
-# Tokio async/await examples
-
-These are a separate crate in order to work around some cargo bugs. It also
-allows `[patch]` to be used in `Cargo.toml` to ensure the correct lib versions
-are being pulled in.

tokio-async-await/examples/src/chat.rs

@@ -1,135 +0,0 @@
-#![feature(await_macro, async_await, futures_api)]
-
-#[macro_use]
-extern crate tokio;
-extern crate futures; // v0.1
-
-use tokio::codec::{LinesCodec, Decoder};
-use tokio::net::{TcpListener, TcpStream};
-use tokio::prelude::*;
-
-use futures::sync::mpsc;
-
-use std::collections::HashMap;
-use std::io;
-use std::net::SocketAddr;
-use std::sync::{Arc, Mutex};
-
-/// Shorthand for the transmit half of the message channel.
-type Tx = mpsc::UnboundedSender<String>;
-
-struct Shared {
-    peers: HashMap<SocketAddr, Tx>,
-}
-
-impl Shared {
-    /// Create a new, empty, instance of `Shared`.
-    fn new() -> Self {
-        Shared {
-            peers: HashMap::new(),
-        }
-    }
-}
-
-async fn process(stream: TcpStream, state: Arc<Mutex<Shared>>) -> io::Result<()> {
-    let addr = stream.peer_addr().unwrap();
-    let mut lines = LinesCodec::new().framed(stream);
-
-    // Extract the peer's name
-    let name = match await!(lines.next()) {
-        Some(name) => name?,
-        None => {
-            // Disconnected early
-            return Ok(());
-        }
-    };
-
-    println!("`{}` is joining the chat", name);
-
-    let (tx, mut rx) = mpsc::unbounded();
-
-    // Register the socket
-    state.lock().unwrap()
-        .peers.insert(addr, tx);
-
-    // Split the `lines` handle into send and recv handles. This allows spawning
-    // separate tasks.
-    let (mut lines_tx, mut lines_rx) = lines.split();
-
-    // Spawn a task that receives all lines broadcasted to us from other peers
-    // and writes it to the client.
-    tokio::spawn_async(async move {
-        while let Some(line) = await!(rx.next()) {
-            let line = line.unwrap();
-            await!(lines_tx.send_async(line)).unwrap();
-        }
-    });
-
-    // Use the current task to read lines from the socket and broadcast them to
-    // other peers.
-    while let Some(message) = await!(lines_rx.next()) {
-        // TODO: Error handling
-        let message = message.unwrap();
-
-        let mut line = name.clone();
-        line.push_str(": ");
-        line.push_str(&message);
-        line.push_str("\r\n");
-
-        let state = state.lock().unwrap();
-
-        for (peer_addr, tx) in &state.peers {
-            if *peer_addr != addr {
-                // TODO: Error handling
-                tx.unbounded_send(line.clone()).unwrap();
-            }
-        }
-    }
-
-    // Remove the client from the shared state. Doing so will also result in the
-    // tx task to terminate.
-    state.lock().unwrap()
-        .peers.remove(&addr)
-        .expect("bug");
-
-    Ok(())
-}
-
-fn main() {
-    // Create the shared state. This is how all the peers communicate.
-    //
-    // The server task will hold a handle to this. For every new client, the
-    // `state` handle is cloned and passed into the task that processes the
-    // client connection.
-    let state = Arc::new(Mutex::new(Shared::new()));
-
-    let addr = "127.0.0.1:6142".parse().unwrap();
-
-    // Bind a TCP listener to the socket address.
-    //
-    // Note that this is the Tokio TcpListener, which is fully async.
-    let listener = TcpListener::bind(&addr).unwrap();
-
-    println!("server running on localhost:6142");
-
-    // Start the Tokio runtime.
-    tokio::run_async(async move {
-        let mut incoming = listener.incoming();
-
-        while let Some(stream) = await!(incoming.next()) {
-            let stream = match stream {
-                Ok(stream) => stream,
-                Err(_) => continue,
-            };
-
-            let state = state.clone();
-
-            tokio::spawn_async(async move {
-                if let Err(_) = await!(process(stream, state)) {
-                    eprintln!("failed to process connection");
-                }
-            });
-        }
-    });
-}
-

tokio-async-await/examples/src/echo_client.rs

@@ -1,53 +0,0 @@
-#![feature(await_macro, async_await, futures_api)]
-
-#[macro_use]
-extern crate tokio;
-
-use tokio::net::TcpStream;
-use tokio::prelude::*;
-
-use std::io;
-use std::net::SocketAddr;
-
-const MESSAGES: &[&str] = &[
-    "hello",
-    "world",
-    "one two three",
-];
-
-async fn run_client(addr: &SocketAddr) -> io::Result<()> {
-    let mut stream = await!(TcpStream::connect(addr))?;
-
-    // Buffer to read into
-    let mut buf = [0; 128];
-
-    for msg in MESSAGES {
-        println!(" > write = {:?}", msg);
-
-        // Write the message to the server
-        await!(stream.write_all_async(msg.as_bytes()))?;
-
-        // Read the message back from the server
-        await!(stream.read_exact_async(&mut buf[..msg.len()]))?;
-
-        assert_eq!(&buf[..msg.len()], msg.as_bytes());
-    }
-
-    Ok(())
-}
-
-fn main() {
-    use std::env;
-
-    let addr = env::args().nth(1).unwrap_or("127.0.0.1:8080".to_string());
-    let addr = addr.parse::<SocketAddr>().unwrap();
-
-    // Connect to the echo serveer
-
-    tokio::run_async(async move {
-        match await!(run_client(&addr)) {
-            Ok(_) => println!("done."),
-            Err(e) => eprintln!("echo client failed; error = {:?}", e),
-        }
-    });
-}

tokio-async-await/examples/src/echo_server.rs

@@ -1,45 +0,0 @@
-#![feature(await_macro, async_await, futures_api)]
-
-#[macro_use]
-extern crate tokio;
-
-use tokio::net::{TcpListener, TcpStream};
-use tokio::prelude::*;
-
-use std::net::SocketAddr;
-
-fn handle(mut stream: TcpStream) {
-    tokio::spawn_async(async move {
-        let mut buf = [0; 1024];
-
-        loop {
-            match await!(stream.read_async(&mut buf)).unwrap() {
-                0 => break, // Socket closed
-                n => {
-                    // Send the data back
-                    await!(stream.write_all_async(&buf[0..n])).unwrap();
-                }
-            }
-        }
-    });
-}
-
-fn main() {
-    use std::env;
-
-    let addr = env::args().nth(1).unwrap_or("127.0.0.1:8080".to_string());
-    let addr = addr.parse::<SocketAddr>().unwrap();
-
-    // Bind the TCP listener
-    let listener = TcpListener::bind(&addr).unwrap();
-    println!("Listening on: {}", addr);
-
-    tokio::run_async(async {
-        let mut incoming = listener.incoming();
-
-        while let Some(stream) = await!(incoming.next()) {
-            let stream = stream.unwrap();
-            handle(stream);
-        }
-    });
-}

tokio-async-await/examples/src/hyper.rs

@@ -1,33 +0,0 @@
-#![feature(await_macro, async_await, futures_api)]
-
-#[macro_use]
-extern crate tokio;
-extern crate hyper;
-
-use tokio::prelude::*;
-use hyper::Client;
-
-use std::time::Duration;
-use std::str;
-
-pub fn main() {
-    tokio::run_async(async {
-        let client = Client::new();
-
-        let uri = "http://httpbin.org/ip".parse().unwrap();
-
-        let response = await!({
-            client.get(uri)
-                .timeout(Duration::from_secs(10))
-        }).unwrap();
-
-        println!("Response: {}", response.status());
-
-        let mut body = response.into_body();
-
-        while let Some(chunk) = await!(body.next()) {
-            let chunk = chunk.unwrap();
-            println!("chunk = {}", str::from_utf8(&chunk[..]).unwrap());
-        }
-    });
-}

tokio-async-await/src/await.rs

@@ -1,16 +0,0 @@
-/// Wait for a future to complete.
-#[macro_export]
-macro_rules! await {
-    ($e:expr) => {{
-        #[allow(unused_imports)]
-        use $crate::compat::backward::IntoAwaitable as IntoAwaitableBackward;
-        #[allow(unused_imports)]
-        use $crate::compat::forward::IntoAwaitable as IntoAwaitableForward;
-        use $crate::std_await;
-
-        #[allow(unused_mut)]
-        let mut e = $e;
-        let e = e.into_awaitable();
-        std_await!(e)
-    }};
-}

tokio-async-await/src/compat/backward.rs

@@ -1,83 +0,0 @@
-use futures::{Future, Poll};
-
-use std::future::Future as StdFuture;
-use std::pin::Pin;
-use std::ptr;
-use std::task::{Poll as StdPoll, RawWaker, RawWakerVTable, Waker};
-
-/// Convert an 0.3 `Future` to an 0.1 `Future`.
-#[derive(Debug)]
-pub struct Compat<T>(Pin<Box<T>>);
-
-impl<T> Compat<T> {
-    /// Create a new `Compat` backed by `future`.
-    pub fn new(future: T) -> Compat<T> {
-        Compat(Box::pin(future))
-    }
-}
-
-/// Convert a value into one that can be used with `await!`.
-pub trait IntoAwaitable {
-    type Awaitable;
-
-    fn into_awaitable(self) -> Self::Awaitable;
-}
-
-impl<T> IntoAwaitable for T
-where
-    T: StdFuture,
-{
-    type Awaitable = Self;
-
-    fn into_awaitable(self) -> Self {
-        self
-    }
-}
-
-impl<T, Item, Error> Future for Compat<T>
-where
-    T: StdFuture<Output = Result<Item, Error>>,
-{
-    type Item = Item;
-    type Error = Error;
-
-    fn poll(&mut self) -> Poll<Item, Error> {
-        use futures::Async::*;
-
-        let waker = noop_waker();
-
-        let res = self.0.as_mut().poll(&waker);
-
-        match res {
-            StdPoll::Ready(Ok(val)) => Ok(Ready(val)),
-            StdPoll::Ready(Err(err)) => Err(err),
-            StdPoll::Pending => Ok(NotReady),
-        }
-    }
-}
-
-// ===== NoopWaker =====
-
-fn noop_raw_waker() -> RawWaker {
-    RawWaker::new(ptr::null(), &NOOP_WAKER_VTABLE)
-}
-
-fn noop_waker() -> Waker {
-    unsafe { Waker::new_unchecked(noop_raw_waker()) }
-}
-
-unsafe fn clone_raw(_data: *const ()) -> RawWaker {
-    noop_raw_waker()
-}
-
-unsafe fn drop_raw(_data: *const ()) {}
-
-unsafe fn wake(_data: *const ()) {
-    unimplemented!("async-await-preview currently only supports futures 0.1. Use the compatibility layer of futures 0.3 instead, if you want to use futures 0.3.");
-}
-
-const NOOP_WAKER_VTABLE: RawWakerVTable = RawWakerVTable {
-    clone: clone_raw,
-    drop: drop_raw,
-    wake,
-};

tokio-async-await/src/compat/forward.rs

@@ -1,67 +0,0 @@
-use futures::{Async, Future};
-
-use std::future::Future as StdFuture;
-use std::pin::Pin;
-use std::task::{Poll as StdPoll, Waker};
-
-/// Converts an 0.1 `Future` into an 0.3 `Future`.
-#[derive(Debug)]
-pub struct Compat<T>(T);
-
-pub(crate) fn convert_poll<T, E>(poll: Result<Async<T>, E>) -> StdPoll<Result<T, E>> {
-    use futures::Async::{NotReady, Ready};
-
-    match poll {
-        Ok(Ready(val)) => StdPoll::Ready(Ok(val)),
-        Ok(NotReady) => StdPoll::Pending,
-        Err(err) => StdPoll::Ready(Err(err)),
-    }
-}
-
-pub(crate) fn convert_poll_stream<T, E>(
-    poll: Result<Async<Option<T>>, E>,
-) -> StdPoll<Option<Result<T, E>>> {
-    use futures::Async::{NotReady, Ready};
-
-    match poll {
-        Ok(Ready(Some(val))) => StdPoll::Ready(Some(Ok(val))),
-        Ok(Ready(None)) => StdPoll::Ready(None),
-        Ok(NotReady) => StdPoll::Pending,
-        Err(err) => StdPoll::Ready(Some(Err(err))),
-    }
-}
-
-/// Convert a value into one that can be used with `await!`.
-pub trait IntoAwaitable {
-    type Awaitable;
-
-    /// Convert `self` into a value that can be used with `await!`.
-    fn into_awaitable(self) -> Self::Awaitable;
-}
-
-impl<T: Future + Unpin> IntoAwaitable for T {
-    type Awaitable = Compat<T>;
-
-    fn into_awaitable(self) -> Self::Awaitable {
-        Compat(self)
-    }
-}
-
-impl<T> StdFuture for Compat<T>
-where
-    T: Future + Unpin,
-{
-    type Output = Result<T::Item, T::Error>;
-
-    fn poll(mut self: Pin<&mut Self>, _waker: &Waker) -> StdPoll<Self::Output> {
-        use futures::Async::{NotReady, Ready};
-
-        // TODO: wire in cx
-
-        match self.0.poll() {
-            Ok(Ready(val)) => StdPoll::Ready(Ok(val)),
-            Ok(NotReady) => StdPoll::Pending,
-            Err(e) => StdPoll::Ready(Err(e)),
-        }
-    }
-}

tokio-async-await/src/compat/mod.rs

@@ -1,4 +0,0 @@
-#![doc(hidden)]
-
-pub mod backward;
-pub mod forward;

tokio-async-await/src/io/flush.rs

@@ -1,30 +0,0 @@
-use tokio_io::AsyncWrite;
-
-use std::future::Future;
-use std::io;
-use std::pin::Pin;
-use std::task::{Poll, Waker};
-
-/// A future used to fully flush an I/O object.
-#[derive(Debug)]
-pub struct Flush<'a, T: ?Sized + 'a> {
-    writer: &'a mut T,
-}
-
-// Pin is never projected to fields
-impl<'a, T: ?Sized> Unpin for Flush<'a, T> {}
-
-impl<'a, T: AsyncWrite + ?Sized> Flush<'a, T> {
-    pub(super) fn new(writer: &'a mut T) -> Flush<'a, T> {
-        Flush { writer }
-    }
-}
-
-impl<'a, T: AsyncWrite + ?Sized> Future for Flush<'a, T> {
-    type Output = io::Result<()>;
-
-    fn poll(mut self: Pin<&mut Self>, _wx: &Waker) -> Poll<Self::Output> {
-        use crate::compat::forward::convert_poll;
-        convert_poll(self.writer.poll_flush())
-    }
-}

tokio-async-await/src/io/mod.rs

@@ -1,192 +0,0 @@
-//! Use I/O with `async` / `await`.
-
-mod flush;
-mod read;
-mod read_exact;
-mod write;
-mod write_all;
-
-pub use self::flush::Flush;
-pub use self::read::Read;
-pub use self::read_exact::ReadExact;
-pub use self::write::Write;
-pub use self::write_all::WriteAll;
-
-use tokio_io::{AsyncRead, AsyncWrite};
-
-/// An extension trait which adds utility methods to `AsyncRead` types.
-pub trait AsyncReadExt: AsyncRead {
-    /// Tries to read some bytes directly into the given `buf` in an
-    /// asynchronous manner, returning a future.
-    ///
-    /// The returned future will resolve to the number of bytes read once the read
-    /// operation is completed.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(async_await, await_macro, futures_api)]
-    /// tokio::run_async(async {
-    /// // The extension trait can also be imported with
-    /// // `use tokio::prelude::*`.
-    /// use tokio::prelude::AsyncReadExt;
-    /// use std::io::Cursor;
-    ///
-    /// let mut reader = Cursor::new([1, 2, 3, 4]);
-    /// let mut output = [0u8; 5];
-    ///
-    /// let bytes = await!(reader.read_async(&mut output[..])).unwrap();
-    ///
-    /// // This is only guaranteed to be 4 because `&[u8]` is a synchronous
-    /// // reader. In a real system you could get anywhere from 1 to
-    /// // `output.len()` bytes in a single read.
-    /// assert_eq!(bytes, 4);
-    /// assert_eq!(output, [1, 2, 3, 4, 0]);
-    /// });
-    /// ```
-    fn read_async<'a>(&'a mut self, buf: &'a mut [u8]) -> Read<'a, Self> {
-        Read::new(self, buf)
-    }
-
-    /// Creates a future which will read exactly enough bytes to fill `buf`,
-    /// returning an error if end of file (EOF) is hit sooner.
-    ///
-    /// The returned future will resolve once the read operation is completed.
-    ///
-    /// In the case of an error the buffer and the object will be discarded, with
-    /// the error yielded.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(async_await, await_macro, futures_api)]
-    /// tokio::run_async(async {
-    /// // The extension trait can also be imported with
-    /// // `use tokio::prelude::*`.
-    /// use tokio::prelude::AsyncReadExt;
-    /// use std::io::Cursor;
-    ///
-    /// let mut reader = Cursor::new([1, 2, 3, 4]);
-    /// let mut output = [0u8; 4];
-    ///
-    /// await!(reader.read_exact_async(&mut output)).unwrap();
-    ///
-    /// assert_eq!(output, [1, 2, 3, 4]);
-    /// });
-    /// ```
-    ///
-    /// ## EOF is hit before `buf` is filled
-    ///
-    /// ```
-    /// #![feature(async_await, await_macro, futures_api)]
-    /// tokio::run_async(async {
-    /// // The extension trait can also be imported with
-    /// // `use tokio::prelude::*`.
-    /// use tokio::prelude::AsyncReadExt;
-    /// use std::io::{self, Cursor};
-    ///
-    /// let mut reader = Cursor::new([1, 2, 3, 4]);
-    /// let mut output = [0u8; 5];
-    ///
-    /// let result = await!(reader.read_exact_async(&mut output));
-    ///
-    /// assert_eq!(result.unwrap_err().kind(), io::ErrorKind::UnexpectedEof);
-    /// });
-    /// ```
-    fn read_exact_async<'a>(&'a mut self, buf: &'a mut [u8]) -> ReadExact<'a, Self> {
-        ReadExact::new(self, buf)
-    }
-}
-
-/// An extension trait which adds utility methods to `AsyncWrite` types.
-pub trait AsyncWriteExt: AsyncWrite {
-    /// Write data into this object.
-    ///
-    /// Creates a future that will write the entire contents of the buffer `buf` into
-    /// this `AsyncWrite`.
-    ///
-    /// The returned future will not complete until all the data has been written.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(async_await, await_macro, futures_api)]
-    /// tokio::run_async(async {
-    /// // The extension trait can also be imported with
-    /// // `use tokio::prelude::*`.
-    /// use tokio::prelude::AsyncWriteExt;
-    /// use std::io::Cursor;
-    ///
-    /// let mut buf = [0u8; 5];
-    /// let mut writer = Cursor::new(&mut buf[..]);
-    ///
-    /// let n = await!(writer.write_async(&[1, 2, 3, 4])).unwrap();
-    ///
-    /// assert_eq!(writer.into_inner()[..n], [1, 2, 3, 4, 0][..n]);
-    /// });
-    /// ```
-    fn write_async<'a>(&'a mut self, buf: &'a [u8]) -> Write<'a, Self> {
-        Write::new(self, buf)
-    }
-
-    /// Write an entire buffer into this object.
-    ///
-    /// Creates a future that will write the entire contents of the buffer `buf` into
-    /// this `AsyncWrite`.
-    ///
-    /// The returned future will not complete until all the data has been written.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(async_await, await_macro, futures_api)]
-    /// tokio::run_async(async {
-    /// // The extension trait can also be imported with
-    /// // `use tokio::prelude::*`.
-    /// use tokio::prelude::AsyncWriteExt;
-    /// use std::io::Cursor;
-    ///
-    /// let mut buf = [0u8; 5];
-    /// let mut writer = Cursor::new(&mut buf[..]);
-    ///
-    /// await!(writer.write_all_async(&[1, 2, 3, 4])).unwrap();
-    ///
-    /// assert_eq!(writer.into_inner(), [1, 2, 3, 4, 0]);
-    /// });
-    /// ```
-    fn write_all_async<'a>(&'a mut self, buf: &'a [u8]) -> WriteAll<'a, Self> {
-        WriteAll::new(self, buf)
-    }
-
-    /// Creates a future which will entirely flush this `AsyncWrite`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(async_await, await_macro, futures_api)]
-    /// tokio::run_async(async {
-    /// // The extension trait can also be imported with
-    /// // `use tokio::prelude::*`.
-    /// use tokio::prelude::AsyncWriteExt;
-    /// use std::io::{BufWriter, Cursor};
-    ///
-    /// let mut output = [0u8; 5];
-    ///
-    /// {
-    ///     let mut writer = Cursor::new(&mut output[..]);
-    ///     let mut buffered = BufWriter::new(writer);
-    ///     await!(buffered.write_all_async(&[1, 2])).unwrap();
-    ///     await!(buffered.write_all_async(&[3, 4])).unwrap();
-    ///     await!(buffered.flush_async()).unwrap();
-    /// }
-    ///
-    /// assert_eq!(output, [1, 2, 3, 4, 0]);
-    /// });
-    /// ```
-    fn flush_async<'a>(&mut self) -> Flush<Self> {
-        Flush::new(self)
-    }
-}
-
-impl<T: AsyncRead + ?Sized> AsyncReadExt for T {}
-impl<T: AsyncWrite + ?Sized> AsyncWriteExt for T {}

tokio-async-await/src/io/read.rs

@@ -1,34 +0,0 @@
-use tokio_io::AsyncRead;
-
-use std::future::Future;
-use std::task::{self, Poll};
-
-use std::io;
-use std::pin::Pin;
-
-/// A future which can be used to read bytes.
-#[derive(Debug)]
-pub struct Read<'a, T: ?Sized + 'a> {
-    reader: &'a mut T,
-    buf: &'a mut [u8],
-}
-
-// Pinning is never projected to fields
-impl<'a, T: ?Sized> Unpin for Read<'a, T> {}
-
-impl<'a, T: AsyncRead + ?Sized> Read<'a, T> {
-    pub(super) fn new(reader: &'a mut T, buf: &'a mut [u8]) -> Read<'a, T> {
-        Read { reader, buf }
-    }
-}
-
-impl<'a, T: AsyncRead + ?Sized> Future for Read<'a, T> {
-    type Output = io::Result<usize>;
-
-    fn poll(mut self: Pin<&mut Self>, _waker: &task::Waker) -> Poll<Self::Output> {
-        use crate::compat::forward::convert_poll;
-
-        let this = &mut *self;
-        convert_poll(this.reader.poll_read(this.buf))
-    }
-}

tokio-async-await/src/io/read_exact.rs

@@ -1,52 +0,0 @@
-use tokio_io::AsyncRead;
-
-use std::future::Future;
-use std::task::{self, Poll};
-
-use std::io;
-use std::mem;
-use std::pin::Pin;
-
-/// A future which can be used to read exactly enough bytes to fill a buffer.
-#[derive(Debug)]
-pub struct ReadExact<'a, T: ?Sized + 'a> {
-    reader: &'a mut T,
-    buf: &'a mut [u8],
-}
-
-// Pinning is never projected to fields
-impl<'a, T: ?Sized> Unpin for ReadExact<'a, T> {}
-
-impl<'a, T: AsyncRead + ?Sized> ReadExact<'a, T> {
-    pub(super) fn new(reader: &'a mut T, buf: &'a mut [u8]) -> ReadExact<'a, T> {
-        ReadExact { reader, buf }
-    }
-}
-
-fn eof() -> io::Error {
-    io::Error::new(io::ErrorKind::UnexpectedEof, "early eof")
-}
-
-impl<'a, T: AsyncRead + ?Sized> Future for ReadExact<'a, T> {
-    type Output = io::Result<()>;
-
-    fn poll(mut self: Pin<&mut Self>, _waker: &task::Waker) -> Poll<Self::Output> {
-        use crate::compat::forward::convert_poll;
-
-        let this = &mut *self;
-
-        while !this.buf.is_empty() {
-            let n = try_ready!(convert_poll(this.reader.poll_read(this.buf)));
-
-            {
-                let (_, rest) = mem::replace(&mut this.buf, &mut []).split_at_mut(n);
-                this.buf = rest;
-            }
-            if n == 0 {
-                return Poll::Ready(Err(eof()));
-            }
-        }
-
-        Poll::Ready(Ok(()))
-    }
-}

tokio-async-await/src/io/write.rs

@@ -1,34 +0,0 @@
-use tokio_io::AsyncWrite;
-
-use std::future::Future;
-use std::task::{self, Poll};
-
-use std::io;
-use std::pin::Pin;
-
-/// A future used to write data.
-#[derive(Debug)]
-pub struct Write<'a, T: 'a + ?Sized> {
-    writer: &'a mut T,
-    buf: &'a [u8],
-}
-
-// Pinning is never projected to fields
-impl<'a, T: ?Sized> Unpin for Write<'a, T> {}
-
-impl<'a, T: AsyncWrite + ?Sized> Write<'a, T> {
-    pub(super) fn new(writer: &'a mut T, buf: &'a [u8]) -> Write<'a, T> {
-        Write { writer, buf }
-    }
-}
-
-impl<'a, T: AsyncWrite + ?Sized> Future for Write<'a, T> {
-    type Output = io::Result<usize>;
-
-    fn poll(mut self: Pin<&mut Self>, _waker: &task::Waker) -> Poll<io::Result<usize>> {
-        use crate::compat::forward::convert_poll;
-
-        let this = &mut *self;
-        convert_poll(this.writer.poll_write(this.buf))
-    }
-}

tokio-async-await/src/io/write_all.rs

@@ -1,53 +0,0 @@
-use tokio_io::AsyncWrite;
-
-use std::future::Future;
-use std::task::{self, Poll};
-
-use std::io;
-use std::mem;
-use std::pin::Pin;
-
-/// A future used to write the entire contents of a buffer.
-#[derive(Debug)]
-pub struct WriteAll<'a, T: ?Sized + 'a> {
-    writer: &'a mut T,
-    buf: &'a [u8],
-}
-
-// Pinning is never projected to fields
-impl<'a, T: ?Sized> Unpin for WriteAll<'a, T> {}
-
-impl<'a, T: AsyncWrite + ?Sized> WriteAll<'a, T> {
-    pub(super) fn new(writer: &'a mut T, buf: &'a [u8]) -> WriteAll<'a, T> {
-        WriteAll { writer, buf }
-    }
-}
-
-fn zero_write() -> io::Error {
-    io::Error::new(io::ErrorKind::WriteZero, "zero-length write")
-}
-
-impl<'a, T: AsyncWrite + ?Sized> Future for WriteAll<'a, T> {
-    type Output = io::Result<()>;
-
-    fn poll(mut self: Pin<&mut Self>, _waker: &task::Waker) -> Poll<io::Result<()>> {
-        use crate::compat::forward::convert_poll;
-
-        let this = &mut *self;
-
-        while !this.buf.is_empty() {
-            let n = try_ready!(convert_poll(this.writer.poll_write(this.buf)));
-
-            {
-                let (_, rest) = mem::replace(&mut this.buf, &[]).split_at(n);
-                this.buf = rest;
-            }
-
-            if n == 0 {
-                return Poll::Ready(Err(zero_write()));
-            }
-        }
-
-        Poll::Ready(Ok(()))
-    }
-}

tokio-async-await/src/lib.rs

@@ -1,35 +0,0 @@
-#![cfg(feature = "async-await-preview")]
-#![feature(rust_2018_preview, async_await, await_macro, futures_api)]
-#![doc(html_root_url = "https://docs.rs/tokio-async-await/0.1.6")]
-#![deny(missing_docs, missing_debug_implementations)]
-#![cfg_attr(test, deny(warnings))]
-
-//! A preview of Tokio w/ `async` / `await` support.
-
-extern crate futures;
-extern crate tokio_io;
-
-/// Extracts the successful type of a `Poll<Result<T, E>>`.
-///
-/// This macro bakes in propagation of `Pending` and `Err` signals by returning early.
-macro_rules! try_ready {
-    ($x:expr) => {
-        match $x {
-            std::task::Poll::Ready(Ok(x)) => x,
-            std::task::Poll::Ready(Err(e)) => return std::task::Poll::Ready(Err(e.into())),
-            std::task::Poll::Pending => return std::task::Poll::Pending,
-        }
-    };
-}
-
-#[macro_use]
-mod await;
-pub mod compat;
-pub mod io;
-pub mod sink;
-pub mod stream;
-
-// Rename the `await` macro in `std`. This is used by the redefined
-// `await` macro in this crate.
-#[doc(hidden)]
-pub use std::await as std_await;

tokio-async-await/src/sink/mod.rs

@@ -1,24 +0,0 @@
-//! Use sinks with `async` / `await`.
-
-mod send;
-
-pub use self::send::Send;
-
-use futures::Sink;
-
-/// An extension trait which adds utility methods to `Sink` types.
-pub trait SinkExt: Sink {
-    /// Send an item into the sink.
-    ///
-    /// Note that, **because of the flushing requirement, it is usually better
-    /// to batch together items to send via `send_all`, rather than flushing
-    /// between each item.**
-    fn send_async(&mut self, item: Self::SinkItem) -> Send<Self>
-    where
-        Self: Sized + Unpin,
-    {
-        Send::new(self, item)
-    }
-}
-
-impl<T: Sink> SinkExt for T {}

tokio-async-await/src/sink/send.rs

@@ -1,53 +0,0 @@
-use futures::Sink;
-
-use std::future::Future;
-use std::task::{self, Poll};
-
-use std::pin::Pin;
-
-/// Future for the `SinkExt::send_async` combinator, which sends a value to a
-/// sink and then waits until the sink has fully flushed.
-#[derive(Debug)]
-pub struct Send<'a, T: Sink + 'a + ?Sized> {
-    sink: &'a mut T,
-    item: Option<T::SinkItem>,
-}
-
-impl<T: Sink + Unpin + ?Sized> Unpin for Send<'_, T> {}
-
-impl<'a, T: Sink + Unpin + ?Sized> Send<'a, T> {
-    pub(super) fn new(sink: &'a mut T, item: T::SinkItem) -> Self {
-        Send {
-            sink,
-            item: Some(item),
-        }
-    }
-}
-
-impl<T: Sink + Unpin + ?Sized> Future for Send<'_, T> {
-    type Output = Result<(), T::SinkError>;
-
-    fn poll(mut self: Pin<&mut Self>, _waker: &task::Waker) -> Poll<Self::Output> {
-        use crate::compat::forward::convert_poll;
-        use futures::AsyncSink::{NotReady, Ready};
-
-        if let Some(item) = self.item.take() {
-            match self.sink.start_send(item) {
-                Ok(Ready) => {}
-                Ok(NotReady(val)) => {
-                    self.item = Some(val);
-                    return Poll::Pending;
-                }
-                Err(err) => {
-                    return Poll::Ready(Err(err));
-                }
-            }
-        }
-
-        // we're done sending the item, but want to block on flushing the
-        // sink
-        try_ready!(convert_poll(self.sink.poll_complete()));
-
-        Poll::Ready(Ok(()))
-    }
-}

tokio-async-await/src/stream/mod.rs

@@ -1,38 +0,0 @@
-//! Use streams with `async` / `await`.
-
-mod next;
-
-pub use self::next::Next;
-
-use futures::Stream;
-
-/// An extension trait which adds utility methods to `Stream` types.
-pub trait StreamExt: Stream {
-    /// Creates a future that resolves to the next item in the stream.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(await_macro, async_await)]
-    /// tokio::run_async(async {
-    /// // The extension trait can also be imported with
-    /// // `use tokio::prelude::*`.
-    /// use tokio::prelude::{stream, StreamExt};
-    ///
-    /// let mut stream = stream::iter_ok::<_, ()>(1..3);
-    ///
-    /// assert_eq!(await!(stream.next()), Some(Ok(1)));
-    /// assert_eq!(await!(stream.next()), Some(Ok(2)));
-    /// assert_eq!(await!(stream.next()), Some(Ok(3)));
-    /// assert_eq!(await!(stream.next()), None);
-    /// });
-    /// ```
-    fn next(&mut self) -> Next<Self>
-    where
-        Self: Sized + Unpin,
-    {
-        Next::new(self)
-    }
-}
-
-impl<T: Stream> StreamExt for T {}

tokio-async-await/src/stream/next.rs

@@ -1,29 +0,0 @@
-use futures::Stream;
-
-use std::future::Future;
-use std::pin::Pin;
-use std::task::{Poll, Waker};
-
-/// A future of the next element of a stream.
-#[derive(Debug)]
-pub struct Next<'a, T: 'a> {
-    stream: &'a mut T,
-}
-
-impl<'a, T: Stream + Unpin> Unpin for Next<'a, T> {}
-
-impl<'a, T: Stream + Unpin> Next<'a, T> {
-    pub(super) fn new(stream: &'a mut T) -> Next<'a, T> {
-        Next { stream }
-    }
-}
-
-impl<'a, T: Stream + Unpin> Future for Next<'a, T> {
-    type Output = Option<Result<T::Item, T::Error>>;
-
-    fn poll(mut self: Pin<&mut Self>, _waker: &Waker) -> Poll<Self::Output> {
-        use crate::compat::forward::convert_poll_stream;
-
-        convert_poll_stream(self.stream.poll())
-    }
-}

tokio-buf/CHANGELOG.md

@@ -1,3 +0,0 @@
-# 0.1.0 (February 23, 2019)
-
-* Initial release

tokio-buf/Cargo.toml

@@ -1,29 +0,0 @@
-[package]
-name = "tokio-buf"
-
-# When releasing to crates.io:
-# - Update html_root_url.
-# - Update doc url
-#   - Cargo.toml
-#   - README.md
-# - Update CHANGELOG.md.
-# - Create "v0.1.x" git tag.
-version = "0.1.0"
-authors = ["Carl Lerche <[email protected]>"]
-license = "MIT"
-repository = "https://github.com/tokio-rs/tokio"
-homepage = "https://tokio.rs"
-documentation = "https://docs.rs/tokio-buf/0.1.0/tokio_buf"
-description = """
-Asynchronous stream of byte buffers
-"""
-categories = ["asynchronous"]
-
-[dependencies]
-bytes = "0.4.10"
-either = { version =  "1.5", optional = true}
-futures = "0.1.23"
-
-[features]
-default = ["util"]
-util = ["bytes/either", "either"]

tokio-buf/README.md

@@ -1,35 +0,0 @@
-# tokio-buf
-
-Asynchronous stream of byte buffers
-
-[Documenation](https://docs.rs/tokio-buf)
-
-## Usage
-
-First, add this to your `Cargo.toml`:
-
-```toml
-[dependencies]
-tokio-buf = "0.1.0"
-```
-
-Next, add this to your crate:
-
-```rust
-extern crate tokio_buf;
-```
-
-You can find extensive documentation and examples about how to use this crate
-online at [https://tokio.rs](https://tokio.rs). The [API
-documentation](https://docs.rs/tokio-buf) is also a great place to get started
-for the nitty-gritty.
-
-## License
-
-This project is licensed under the [MIT license](LICENSE).
-
-### Contribution
-
-Unless you explicitly state otherwise, any contribution intentionally submitted
-for inclusion in Tokio by you, shall be licensed as MIT, without any additional
-terms or conditions.

tokio-buf/src/lib.rs

@@ -1,99 +0,0 @@
-#![doc(html_root_url = "https://docs.rs/tokio-buf/0.1.0")]
-#![deny(missing_docs, missing_debug_implementations, unreachable_pub)]
-#![cfg_attr(test, deny(warnings))]
-
-//! Asynchronous stream of bytes.
-//!
-//! This crate contains the `BufStream` trait and a number of combinators for
-//! this trait. The trait is similar to `Stream` in the `futures` library, but
-//! instead of yielding arbitrary values, it only yields types that implement
-//! `Buf` (i.e, byte collections).
-
-extern crate bytes;
-#[cfg(feature = "util")]
-extern crate either;
-#[allow(unused)]
-#[macro_use]
-extern crate futures;
-
-mod never;
-mod size_hint;
-mod str;
-mod u8;
-#[cfg(feature = "util")]
-pub mod util;
-
-pub use self::size_hint::SizeHint;
-#[doc(inline)]
-#[cfg(feature = "util")]
-pub use util::BufStreamExt;
-
-use bytes::Buf;
-use futures::Poll;
-
-/// An asynchronous stream of bytes.
-///
-/// `BufStream` asynchronously yields values implementing `Buf`, i.e. byte
-/// buffers.
-pub trait BufStream {
-    /// Values yielded by the `BufStream`.
-    ///
-    /// Each item is a sequence of bytes representing a chunk of the total
-    /// `ByteStream`.
-    type Item: Buf;
-
-    /// The error type this `BufStream` might generate.
-    type Error;
-
-    /// Attempt to pull out the next buffer of this stream, registering the
-    /// current task for wakeup if the value is not yet available, and returning
-    /// `None` if the stream is exhausted.
-    ///
-    /// # Return value
-    ///
-    /// There are several possible return values, each indicating a distinct
-    /// stream state:
-    ///
-    /// - `Ok(Async::NotReady)` means that this stream's next value is not ready
-    /// yet. Implementations will ensure that the current task will be notified
-    /// when the next value may be ready.
-    ///
-    /// - `Ok(Async::Ready(Some(buf)))` means that the stream has successfully
-    /// produced a value, `buf`, and may produce further values on subsequent
-    /// `poll_buf` calls.
-    ///
-    /// - `Ok(Async::Ready(None))` means that the stream has terminated, and
-    /// `poll_buf` should not be invoked again.
-    ///
-    /// # Panics
-    ///
-    /// Once a stream is finished, i.e. `Ready(None)` has been returned, further
-    /// calls to `poll_buf` may result in a panic or other "bad behavior".
-    fn poll_buf(&mut self) -> Poll<Option<Self::Item>, Self::Error>;
-
-    /// Returns the bounds on the remaining length of the stream.
-    ///
-    /// The size hint allows the caller to perform certain optimizations that
-    /// are dependent on the byte stream size. For example, `collect` uses the
-    /// size hint to pre-allocate enough capacity to store the entirety of the
-    /// data received from the byte stream.
-    ///
-    /// When `SizeHint::upper()` returns `Some` with a value equal to
-    /// `SizeHint::lower()`, this represents the exact number of bytes that will
-    /// be yielded by the `BufStream`.
-    ///
-    /// # Implementation notes
-    ///
-    /// While not enforced, implementations are expected to respect the values
-    /// returned from `SizeHint`. Any deviation is considered an implementation
-    /// bug. Consumers may rely on correctness in order to use the value as part
-    /// of protocol impelmentations. For example, an HTTP library may use the
-    /// size hint to set the `content-length` header.
-    ///
-    /// However, `size_hint` must not be trusted to omit bounds checks in unsafe
-    /// code. An incorrect implementation of `size_hint()` must not lead to
-    /// memory safety violations.
-    fn size_hint(&self) -> SizeHint {
-        SizeHint::default()
-    }
-}

tokio-buf/src/never.rs

@@ -1,22 +0,0 @@
-use std::{error, fmt};
-
-/// An error that can never occur
-pub enum Never {}
-
-impl fmt::Debug for Never {
-    fn fmt(&self, _f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {}
-    }
-}
-
-impl fmt::Display for Never {
-    fn fmt(&self, _f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {}
-    }
-}
-
-impl error::Error for Never {
-    fn description(&self) -> &str {
-        match *self {}
-    }
-}

tokio-buf/src/size_hint.rs

@@ -1,56 +0,0 @@
-use std::u64;
-
-/// A `BufStream` size hint
-///
-/// The default implementation returns:
-///
-/// * 0 for `available`
-/// * 0 for `lower`
-/// * `None` for `upper`.
-#[derive(Debug, Default, Clone)]
-pub struct SizeHint {
-    lower: u64,
-    upper: Option<u64>,
-}
-
-impl SizeHint {
-    /// Returns a new `SizeHint` with default values
-    pub fn new() -> SizeHint {
-        SizeHint::default()
-    }
-
-    /// Returns the lower bound of data that the `BufStream` will yield before
-    /// completing.
-    pub fn lower(&self) -> u64 {
-        self.lower
-    }
-
-    /// Set the value of the `lower` hint.
-    ///
-    /// # Panics
-    ///
-    /// The function panics if `value` is less than `upper`.
-    pub fn set_lower(&mut self, value: u64) {
-        assert!(value <= self.upper.unwrap_or(u64::MAX));
-        self.lower = value;
-    }
-
-    /// Returns the upper bound of data the `BufStream` will yield before
-    /// completing, or `None` if the value is unknown.
-    pub fn upper(&self) -> Option<u64> {
-        self.upper
-    }
-
-    /// Set the value of the `upper` hint value.
-    ///
-    /// # Panics
-    ///
-    /// This function panics if `value` is less than `lower`.
-    pub fn set_upper(&mut self, value: u64) {
-        // There is no need to check `available` as that is guaranteed to be
-        // less than or equal to `lower`.
-        assert!(value >= self.lower, "`value` is less than than `lower`");
-
-        self.upper = Some(value);
-    }
-}

tokio-buf/src/str.rs

@@ -1,39 +0,0 @@
-use never::Never;
-use BufStream;
-
-use futures::Poll;
-
-use std::io;
-use std::mem;
-
-impl BufStream for String {
-    type Item = io::Cursor<Vec<u8>>;
-    type Error = Never;
-
-    fn poll_buf(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
-        if self.is_empty() {
-            return Ok(None.into());
-        }
-
-        let bytes = mem::replace(self, Default::default()).into_bytes();
-        let buf = io::Cursor::new(bytes);
-
-        Ok(Some(buf).into())
-    }
-}
-
-impl BufStream for &'static str {
-    type Item = io::Cursor<&'static [u8]>;
-    type Error = Never;
-
-    fn poll_buf(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
-        if self.is_empty() {
-            return Ok(None.into());
-        }
-
-        let bytes = mem::replace(self, Default::default()).as_bytes();
-        let buf = io::Cursor::new(bytes);
-
-        Ok(Some(buf).into())
-    }
-}

tokio-buf/src/u8.rs

@@ -1,66 +0,0 @@
-use bytes::{Bytes, BytesMut};
-use futures::Poll;
-use never::Never;
-use std::io;
-use BufStream;
-
-impl BufStream for Vec<u8> {
-    type Item = io::Cursor<Vec<u8>>;
-    type Error = Never;
-
-    fn poll_buf(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
-        if self.is_empty() {
-            return Ok(None.into());
-        }
-
-        poll_bytes(self)
-    }
-}
-
-impl BufStream for &'static [u8] {
-    type Item = io::Cursor<&'static [u8]>;
-    type Error = Never;
-
-    fn poll_buf(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
-        if self.is_empty() {
-            return Ok(None.into());
-        }
-
-        poll_bytes(self)
-    }
-}
-
-impl BufStream for Bytes {
-    type Item = io::Cursor<Bytes>;
-    type Error = Never;
-
-    fn poll_buf(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
-        if self.is_empty() {
-            return Ok(None.into());
-        }
-
-        poll_bytes(self)
-    }
-}
-
-impl BufStream for BytesMut {
-    type Item = io::Cursor<BytesMut>;
-    type Error = Never;
-
-    fn poll_buf(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
-        if self.is_empty() {
-            return Ok(None.into());
-        }
-
-        poll_bytes(self)
-    }
-}
-
-fn poll_bytes<T: Default>(buf: &mut T) -> Poll<Option<io::Cursor<T>>, Never> {
-    use std::mem;
-
-    let bytes = mem::replace(buf, Default::default());
-    let buf = io::Cursor::new(bytes);
-
-    Ok(Some(buf).into())
-}

tokio-buf/src/util/chain.rs

@@ -1,46 +0,0 @@
-use BufStream;
-
-use either::Either;
-use futures::Poll;
-
-/// A buf stream that sequences two buf streams together.
-///
-/// `Chain` values are produced by the `chain` function on `BufStream`.
-#[derive(Debug)]
-pub struct Chain<T, U> {
-    left: Option<T>,
-    right: U,
-}
-
-impl<T, U> Chain<T, U> {
-    pub(crate) fn new(left: T, right: U) -> Chain<T, U> {
-        Chain {
-            left: Some(left),
-            right,
-        }
-    }
-}
-
-impl<T, U> BufStream for Chain<T, U>
-where
-    T: BufStream,
-    U: BufStream<Error = T::Error>,
-{
-    type Item = Either<T::Item, U::Item>;
-    type Error = T::Error;
-
-    fn poll_buf(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
-        if let Some(ref mut stream) = self.left {
-            let res = try_ready!(stream.poll_buf());
-
-            if res.is_some() {
-                return Ok(res.map(Either::Left).into());
-            }
-        }
-
-        self.left = None;
-
-        let res = try_ready!(self.right.poll_buf());
-        Ok(res.map(Either::Right).into())
-    }
-}

tokio-buf/src/util/collect.rs

@@ -1,101 +0,0 @@
-use super::FromBufStream;
-use BufStream;
-
-use futures::{Future, Poll};
-
-/// Consumes a buf stream, collecting the data into a single byte container.
-///
-/// `Collect` values are produced by `BufStream::collect`.
-#[derive(Debug)]
-pub struct Collect<T, U>
-where
-    T: BufStream,
-    U: FromBufStream<T::Item>,
-{
-    stream: T,
-    builder: Option<U::Builder>,
-}
-
-/// Errors returned from `Collect` future.
-#[derive(Debug)]
-pub struct CollectError<T, U> {
-    inner: Error<T, U>,
-}
-
-#[derive(Debug)]
-enum Error<T, U> {
-    Stream(T),
-    Collect(U),
-}
-
-impl<T, U> Collect<T, U>
-where
-    T: BufStream,
-    U: FromBufStream<T::Item>,
-{
-    pub(crate) fn new(stream: T) -> Collect<T, U> {
-        let builder = U::builder(&stream.size_hint());
-
-        Collect {
-            stream,
-            builder: Some(builder),
-        }
-    }
-}
-
-impl<T, U> Future for Collect<T, U>
-where
-    T: BufStream,
-    U: FromBufStream<T::Item>,
-{
-    type Item = U;
-    type Error = CollectError<T::Error, U::Error>;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        loop {
-            let res = self.stream.poll_buf().map_err(|err| {
-                let inner = Error::Stream(err);
-                CollectError { inner }
-            });
-
-            match try_ready!(res) {
-                Some(mut buf) => {
-                    let builder = self.builder.as_mut().expect("cannot poll after done");
-
-                    U::extend(builder, &mut buf, &self.stream.size_hint()).map_err(|err| {
-                        let inner = Error::Collect(err);
-                        CollectError { inner }
-                    })?;
-                }
-                None => {
-                    let builder = self.builder.take().expect("cannot poll after done");
-                    let value = U::build(builder).map_err(|err| {
-                        let inner = Error::Collect(err);
-                        CollectError { inner }
-                    })?;
-                    return Ok(value.into());
-                }
-            }
-        }
-    }
-}
-
-// ===== impl CollectError =====
-
-impl<T, U> CollectError<T, U> {
-    /// Returns `true` if the error was caused by polling the stream.
-    pub fn is_stream_err(&self) -> bool {
-        match self.inner {
-            Error::Stream(_) => true,
-            _ => false,
-        }
-    }
-
-    /// Returns `true` if the error happened while collecting the data.
-    pub fn is_collect_err(&self) -> bool {
-        match self.inner {
-            Error::Collect(_) => true,
-            _ => false,
-        }
-    }
-}

tokio-buf/src/util/from.rs

@@ -1,112 +0,0 @@
-use SizeHint;
-
-use bytes::{Buf, BufMut};
-
-use std::usize;
-
-/// Conversion from a `BufStream`.
-///
-/// By implementing `FromBufStream` for a type, you define how it will be
-/// created from a buf stream. This is common for types which describe byte
-/// storage of some kind.
-///
-/// `FromBufStream` is rarely called explicitly, and it is instead used through
-/// `BufStream`'s `collect` method.
-pub trait FromBufStream<T: Buf>: Sized {
-    /// Type that is used to build `Self` while the `BufStream` is being
-    /// consumed.
-    type Builder;
-
-    /// Error that might happen on conversion.
-    type Error;
-
-    /// Create a new, empty, builder. The provided `hint` can be used to inform
-    /// reserving capacity.
-    fn builder(hint: &SizeHint) -> Self::Builder;
-
-    /// Extend the builder with the `Buf`.
-    ///
-    /// This method is called whenever a new `Buf` value is obtained from the
-    /// buf stream.
-    ///
-    /// The provided size hint represents the state of the stream **after**
-    /// `buf` has been yielded. The lower bound represents the minimum amount of
-    /// data that will be provided after this call to `extend` returns.
-    fn extend(builder: &mut Self::Builder, buf: &mut T, hint: &SizeHint)
-        -> Result<(), Self::Error>;
-
-    /// Finalize the building of `Self`.
-    ///
-    /// Called once the buf stream is fully consumed.
-    fn build(builder: Self::Builder) -> Result<Self, Self::Error>;
-}
-
-/// Error returned from collecting into a `Vec<u8>`
-#[derive(Debug)]
-pub struct CollectVecError {
-    _p: (),
-}
-
-impl<T: Buf> FromBufStream<T> for Vec<u8> {
-    type Builder = Vec<u8>;
-    type Error = CollectVecError;
-
-    fn builder(_hint: &SizeHint) -> Vec<u8> {
-        Vec::new()
-    }
-
-    fn extend(builder: &mut Self, buf: &mut T, hint: &SizeHint) -> Result<(), Self::Error> {
-        let lower = hint.lower();
-
-        // If the lower bound is greater than `usize::MAX` then we have a
-        // problem
-        if lower > usize::MAX as u64 {
-            return Err(CollectVecError { _p: () });
-        }
-
-        let mut reserve = lower as usize;
-
-        // If `upper` is set, use this value if it is less than or equal to 64.
-        // This only really impacts the first iteration.
-        match hint.upper() {
-            Some(upper) if upper <= 64 => {
-                reserve = upper as usize;
-            }
-            _ => {}
-        }
-
-        // hint.lower() represents the minimum amount of data that will be
-        // received *after* this function call. We reserve this amount on top of
-        // the amount of data in `buf`.
-        reserve = match reserve.checked_add(buf.remaining()) {
-            Some(n) => n,
-            None => return Err(CollectVecError { _p: () }),
-        };
-
-        // Always reserve 64 bytes the first time, unless `upper` is set and is
-        // less than 64.
-        if builder.is_empty() {
-            reserve = reserve.max(match hint.upper() {
-                Some(upper) if upper < 64 => upper as usize,
-                _ => 64,
-            });
-        }
-
-        // Make sure overflow won't happen when reserving
-        if reserve.checked_add(builder.len()).is_none() {
-            return Err(CollectVecError { _p: () });
-        }
-
-        // Reserve space
-        builder.reserve(reserve);
-
-        // Copy the data
-        builder.put(buf);
-
-        Ok(())
-    }
-
-    fn build(builder: Self) -> Result<Self, Self::Error> {
-        Ok(builder)
-    }
-}

tokio-buf/src/util/limit.rs

@@ -1,76 +0,0 @@
-use BufStream;
-
-use bytes::Buf;
-use futures::Poll;
-
-/// Limits the stream to a maximum amount of data.
-#[derive(Debug)]
-pub struct Limit<T> {
-    stream: T,
-    remaining: u64,
-}
-
-/// Errors returned from `Limit`.
-#[derive(Debug)]
-pub struct LimitError<T> {
-    /// When `None`, limit was reached
-    inner: Option<T>,
-}
-
-impl<T> Limit<T> {
-    pub(crate) fn new(stream: T, amount: u64) -> Limit<T> {
-        Limit {
-            stream,
-            remaining: amount,
-        }
-    }
-}
-
-impl<T> BufStream for Limit<T>
-where
-    T: BufStream,
-{
-    type Item = T::Item;
-    type Error = LimitError<T::Error>;
-
-    fn poll_buf(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
-        use futures::Async::Ready;
-
-        if self.stream.size_hint().lower() > self.remaining {
-            return Err(LimitError { inner: None });
-        }
-
-        let res = self
-            .stream
-            .poll_buf()
-            .map_err(|err| LimitError { inner: Some(err) });
-
-        match res {
-            Ok(Ready(Some(ref buf))) => {
-                if buf.remaining() as u64 > self.remaining {
-                    self.remaining = 0;
-                    return Err(LimitError { inner: None });
-                }
-
-                self.remaining -= buf.remaining() as u64;
-            }
-            _ => {}
-        }
-
-        res
-    }
-}
-
-// ===== impl LimitError =====
-
-impl<T> LimitError<T> {
-    /// Returns `true` if the error was caused by polling the stream.
-    pub fn is_stream_err(&self) -> bool {
-        self.inner.is_some()
-    }
-
-    /// Returns `true` if the stream reached its limit.
-    pub fn is_limit_err(&self) -> bool {
-        self.inner.is_none()
-    }
-}

tokio-buf/src/util/mod.rs

@@ -1,73 +0,0 @@
-//! Types and utilities for working with `BufStream`.
-
-mod chain;
-mod collect;
-mod from;
-mod limit;
-
-pub use self::chain::Chain;
-pub use self::collect::Collect;
-pub use self::from::FromBufStream;
-pub use self::limit::Limit;
-
-pub mod error {
-    //! Error types
-
-    pub use super::collect::CollectError;
-    pub use super::from::CollectVecError;
-    pub use super::limit::LimitError;
-}
-
-use BufStream;
-
-impl<T> BufStreamExt for T where T: BufStream {}
-
-/// An extension trait for `BufStream`'s that provides a variety of convenient
-/// adapters.
-pub trait BufStreamExt: BufStream {
-    /// Takes two buf streams and creates a new buf stream over both in
-    /// sequence.
-    ///
-    /// `chain()` returns a new `BufStream` value which will first yield all
-    /// data from `self` then all data from `other`.
-    ///
-    /// In other words, it links two buf streams together, in a chain.
-    fn chain<T>(self, other: T) -> Chain<Self, T>
-    where
-        Self: Sized,
-        T: BufStream<Error = Self::Error>,
-    {
-        Chain::new(self, other)
-    }
-
-    /// Consumes all data from `self`, storing it in byte storage of type `T`.
-    ///
-    /// `collect()` returns a future that buffers all data yielded from `self`
-    /// into storage of type of `T`. The future completes once `self` yield
-    /// `None`, returning the buffered data.
-    ///
-    /// The collect future will yield an error if `self` yields an error or if
-    /// the collect operation errors. The collect error cases are dependent on
-    /// the target storage type.
-    fn collect<T>(self) -> Collect<Self, T>
-    where
-        Self: Sized,
-        T: FromBufStream<Self::Item>,
-    {
-        Collect::new(self)
-    }
-
-    /// Limit the number of bytes that the stream can yield.
-    ///
-    /// `limit()` returns a new `BufStream` value which yields all the data from
-    /// `self` while ensuring that at most `amount` bytes are yielded.
-    ///
-    /// If `self` can yield greater than `amount` bytes, the returned stream
-    /// will yield an error.
-    fn limit(self, amount: u64) -> Limit<Self>
-    where
-        Self: Sized,
-    {
-        Limit::new(self, amount)
-    }
-}

tokio-buf/tests/buf_stream.rs

@@ -1,66 +0,0 @@
-extern crate bytes;
-extern crate futures;
-extern crate tokio_buf;
-
-use bytes::Buf;
-use futures::Async::*;
-use tokio_buf::{BufStream, SizeHint};
-
-#[macro_use]
-mod support;
-
-// ===== test `SizeHint` =====
-
-#[test]
-fn size_hint() {
-    let hint = SizeHint::new();
-    assert_eq!(hint.lower(), 0);
-    assert!(hint.upper().is_none());
-
-    let mut hint = SizeHint::new();
-    hint.set_lower(100);
-    assert_eq!(hint.lower(), 100);
-    assert!(hint.upper().is_none());
-
-    let mut hint = SizeHint::new();
-    hint.set_upper(200);
-    assert_eq!(hint.lower(), 0);
-    assert_eq!(hint.upper(), Some(200));
-
-    let mut hint = SizeHint::new();
-    hint.set_lower(100);
-    hint.set_upper(100);
-    assert_eq!(hint.lower(), 100);
-    assert_eq!(hint.upper(), Some(100));
-}
-
-#[test]
-#[should_panic]
-fn size_hint_lower_bigger_than_upper() {
-    let mut hint = SizeHint::new();
-    hint.set_upper(100);
-    hint.set_lower(200);
-}
-
-#[test]
-#[should_panic]
-fn size_hint_upper_less_than_lower() {
-    let mut hint = SizeHint::new();
-    hint.set_lower(200);
-    hint.set_upper(100);
-}
-
-// ===== BufStream impelmentations for misc types =====
-
-#[test]
-fn str_buf_stream() {
-    let mut bs = "hello world".to_string();
-    assert_buf_eq!(bs.poll_buf(), "hello world");
-    assert!(bs.is_empty());
-    assert_none!(bs.poll_buf());
-
-    let mut bs = "hello world";
-    assert_buf_eq!(bs.poll_buf(), "hello world");
-    assert!(bs.is_empty());
-    assert_none!(bs.poll_buf());
-}

tokio-buf/tests/buf_stream_ext.rs

@@ -1,145 +0,0 @@
-#![cfg(feature = "ext")]
-
-extern crate bytes;
-extern crate futures;
-extern crate tokio_buf;
-
-use bytes::Buf;
-use futures::Async::*;
-use futures::Future;
-use tokio_buf::{BufStream, BufStreamExt};
-
-#[macro_use]
-mod support;
-
-use support::*;
-
-// ===== test `chain()` =====
-
-#[test]
-fn chain() {
-    // Chain one with one
-    //
-    let mut bs = one("hello").chain(one("world"));
-
-    assert_buf_eq!(bs.poll_buf(), "hello");
-    assert_buf_eq!(bs.poll_buf(), "world");
-    assert_none!(bs.poll_buf());
-
-    // Chain multi with multi
-    let mut bs = list(&["foo", "bar"]).chain(list(&["baz", "bok"]));
-
-    assert_buf_eq!(bs.poll_buf(), "foo");
-    assert_buf_eq!(bs.poll_buf(), "bar");
-    assert_buf_eq!(bs.poll_buf(), "baz");
-    assert_buf_eq!(bs.poll_buf(), "bok");
-    assert_none!(bs.poll_buf());
-
-    // Chain includes a not ready call
-    //
-    let mut bs = new_mock(&[Ok(Ready("foo")), Ok(NotReady), Ok(Ready("bar"))]).chain(one("baz"));
-
-    assert_buf_eq!(bs.poll_buf(), "foo");
-    assert_not_ready!(bs.poll_buf());
-    assert_buf_eq!(bs.poll_buf(), "bar");
-    assert_buf_eq!(bs.poll_buf(), "baz");
-    assert_none!(bs.poll_buf());
-}
-
-// ===== Test `collect()` =====
-
-#[test]
-fn collect_vec() {
-    // While unfortunate, this test makes some assumptions on vec's resizing
-    // behavior.
-    //
-    // Collect one
-    //
-    let bs = one("hello world");
-
-    let vec: Vec<u8> = bs.collect().wait().unwrap();
-
-    assert_eq!(vec, b"hello world");
-    assert_eq!(vec.capacity(), 64);
-
-    // Collect one, with size hint
-    //
-    let mut bs = one("hello world");
-    bs.size_hint.set_lower(11);
-
-    let vec: Vec<u8> = bs.collect().wait().unwrap();
-
-    assert_eq!(vec, b"hello world");
-    assert_eq!(vec.capacity(), 64);
-
-    // Collect one, with size hint
-    //
-    let mut bs = one("hello world");
-    bs.size_hint.set_lower(10);
-
-    let vec: Vec<u8> = bs.collect().wait().unwrap();
-
-    assert_eq!(vec, b"hello world");
-    assert_eq!(vec.capacity(), 64);
-
-    // Collect many
-    //
-    let bs = list(&["hello", " ", "world", ", one two three"]);
-
-    let vec: Vec<u8> = bs.collect().wait().unwrap();
-
-    assert_eq!(vec, b"hello world, one two three");
-}
-
-// ===== Test limit() =====
-
-#[test]
-fn limit() {
-    // Not limited
-
-    let res = one("hello world")
-        .limit(100)
-        .collect::<Vec<_>>()
-        .wait()
-        .unwrap();
-
-    assert_eq!(res, b"hello world");
-
-    let res = list(&["hello", " ", "world"])
-        .limit(100)
-        .collect::<Vec<_>>()
-        .wait()
-        .unwrap();
-
-    assert_eq!(res, b"hello world");
-
-    let res = list(&["hello", " ", "world"])
-        .limit(11)
-        .collect::<Vec<_>>()
-        .wait()
-        .unwrap();
-
-    assert_eq!(res, b"hello world");
-
-    // Limited
-
-    let res = one("hello world").limit(5).collect::<Vec<_>>().wait();
-
-    assert!(res.is_err());
-
-    let res = one("hello world").limit(10).collect::<Vec<_>>().wait();
-
-    assert!(res.is_err());
-
-    let mut bs = list(&["hello", " ", "world"]).limit(9);
-
-    assert_buf_eq!(bs.poll_buf(), "hello");
-    assert_buf_eq!(bs.poll_buf(), " ");
-    assert!(bs.poll_buf().is_err());
-
-    let mut bs = list(&["hello", " ", "world"]);
-    bs.size_hint.set_lower(11);
-    let mut bs = bs.limit(9);
-
-    assert!(bs.poll_buf().is_err());
-}

tokio-buf/tests/support.rs

@@ -1,132 +0,0 @@
-#![allow(unused)]
-
-extern crate bytes;
-extern crate futures;
-extern crate tokio_buf;
-
-use bytes::Buf;
-use futures::Async::*;
-use futures::Poll;
-use tokio_buf::{BufStream, SizeHint};
-
-use std::collections::VecDeque;
-use std::io::Cursor;
-
-macro_rules! assert_buf_eq {
-    ($actual:expr, $expect:expr) => {{
-        match $actual {
-            Ok(Ready(Some(val))) => {
-                assert_eq!(val.remaining(), val.bytes().len());
-                assert_eq!(val.bytes(), $expect.as_bytes());
-            }
-            Ok(Ready(None)) => panic!("expected value; BufStream yielded None"),
-            Ok(NotReady) => panic!("expected value; BufStream is not ready"),
-            Err(e) => panic!("expected value; got error = {:?}", e),
-        }
-    }};
-}
-
-macro_rules! assert_none {
-    ($actual:expr) => {
-        match $actual {
-            Ok(Ready(None)) => {}
-            actual => panic!("expected None; actual = {:?}", actual),
-        }
-    };
-}
-
-macro_rules! assert_not_ready {
-    ($actual:expr) => {
-        match $actual {
-            Ok(NotReady) => {}
-            actual => panic!("expected NotReady; actual = {:?}", actual),
-        }
-    };
-}
-
-// ===== Test utils =====
-
-pub fn one(buf: &'static str) -> Mock {
-    list(&[buf])
-}
-
-pub fn list(bufs: &[&'static str]) -> Mock {
-    let mut polls = VecDeque::new();
-
-    for &buf in bufs {
-        polls.push_back(Ok(Ready(buf.as_bytes())));
-    }
-
-    Mock {
-        polls,
-        size_hint: SizeHint::default(),
-    }
-}
-
-pub fn new_mock(values: &[Poll<&'static str, ()>]) -> Mock {
-    let mut polls = VecDeque::new();
-
-    for &v in values {
-        polls.push_back(match v {
-            Ok(Ready(v)) => Ok(Ready(v.as_bytes())),
-            Ok(NotReady) => Ok(NotReady),
-            Err(e) => Err(e),
-        });
-    }
-
-    Mock {
-        polls,
-        size_hint: SizeHint::default(),
-    }
-}
-
-#[derive(Debug)]
-pub struct Mock {
-    pub polls: VecDeque<Poll<&'static [u8], ()>>,
-    pub size_hint: SizeHint,
-}
-
-#[derive(Debug)]
-pub struct MockBuf {
-    pub data: Cursor<&'static [u8]>,
-}
-
-impl BufStream for Mock {
-    type Item = MockBuf;
-    type Error = ();
-
-    fn poll_buf(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
-        match self.polls.pop_front() {
-            Some(Ok(Ready(value))) => Ok(Ready(Some(MockBuf::new(value)))),
-            Some(Ok(NotReady)) => Ok(NotReady),
-            Some(Err(e)) => Err(e),
-            None => Ok(Ready(None)),
-        }
-    }
-
-    fn size_hint(&self) -> SizeHint {
-        self.size_hint.clone()
-    }
-}
-
-impl MockBuf {
-    fn new(data: &'static [u8]) -> MockBuf {
-        MockBuf {
-            data: Cursor::new(data),
-        }
-    }
-}
-
-impl Buf for MockBuf {
-    fn remaining(&self) -> usize {
-        self.data.remaining()
-    }
-
-    fn bytes(&self) -> &[u8] {
-        self.data.bytes()
-    }
-
-    fn advance(&mut self, cnt: usize) {
-        self.data.advance(cnt)
-    }
-}

tokio-codec/CHANGELOG.md

@@ -1,7 +0,0 @@
-# 0.1.1 (September 26, 2018)
-
-* Allow setting max line length with `LinesCodec` (#632)
-
-# 0.1.0 (June 13, 2018)
-
-* Initial release (#353)

tokio-codec/Cargo.toml

@@ -1,23 +0,0 @@
-[package]
-name = "tokio-codec"
-
-# When releasing to crates.io:
-# - Update html_root_url.
-# - Update doc URL.
-# - Update CHANGELOG.md.
-# - Create "v0.1.x" git tag.
-version = "0.1.1"
-authors = ["Carl Lerche <[email protected]>", "Bryan Burgers <[email protected]>"]
-license = "MIT"
-repository = "https://github.com/tokio-rs/tokio"
-homepage = "https://tokio.rs"
-documentation = "https://docs.rs/tokio-codec/0.1.1/tokio_codec"
-description = """
-Utilities for encoding and decoding frames.
-"""
-categories = ["asynchronous"]
-
-[dependencies]
-tokio-io = "0.1.7"
-bytes = "0.4.7"
-futures = "0.1.18"

tokio-codec/README.md

@@ -1,35 +0,0 @@
-# tokio-codec
-
-Utilities for encoding and decoding frames.
-
-[Documentation](https://docs.rs/tokio-codec)
-
-## Usage
-
-First, add this to your `Cargo.toml`:
-
-```toml
-[dependencies]
-tokio-codec = "0.1"
-```
-
-Next, add this to your crate:
-
-```rust
-extern crate tokio_codec;
-```
-
-You can find extensive documentation and examples about how to use this crate
-online at [https://tokio.rs](https://tokio.rs). The [API
-documentation](https://docs.rs/tokio-codec) is also a great place to get started
-for the nitty-gritty.
-
-## License
-
-This project is licensed under the [MIT license](LICENSE).
-
-### Contribution
-
-Unless you explicitly state otherwise, any contribution intentionally submitted
-for inclusion in Tokio by you, shall be licensed as MIT, without any additional
-terms or conditions.