Prepare for release of 0.2.0-alpha.6 (#1617)

Note that `tokio-timer` and `tokio-tls` become 0.3.0-alpha.6 (not 0.2.0)

.cirrus.yml

@@ -8,21 +8,36 @@ 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
+    # TODO: switch back to nightly
+    - sh rustup.sh -y --default-toolchain nightly-2019-08-21
     - . $HOME/.cargo/env
     - rustup target add i686-unknown-freebsd
-  cargo_cache:
-    folder: $HOME/.cargo/registry
+    - |
+      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
+
+      # Patch all crates
+      cat ci/patch.toml >> Cargo.toml
+
+      # Print `Cargo.toml` for debugging
+      echo "~~~~ Cargo.toml ~~~~"
+      cat Cargo.toml
+      echo "~~~~~~~~~~~~~~~~~~~~"
   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

@@ -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

@@ -1,131 +1,16 @@
-[package]
-name = "tokio"
-# 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.16"
-authors = ["Carl Lerche <[email protected]>"]
-license = "MIT"
-readme = "README.md"
-documentation = "https://docs.rs/tokio/0.1.16/tokio/"
-repository = "https://github.com/tokio-rs/tokio"
-homepage = "https://tokio.rs"
-description = """
-An event-driven, non-blocking I/O platform for writing asynchronous I/O
-backed applications.
-"""
-categories = ["asynchronous", "network-programming"]
-keywords = ["io", "async", "non-blocking", "futures"]
-
 [workspace]
 
 members = [
-  "./",
-  "tokio-async-await",
-  "tokio-buf",
+  "tokio",
   "tokio-codec",
-  "tokio-current-thread",
   "tokio-executor",
   "tokio-fs",
   "tokio-io",
-  "tokio-reactor",
-  "tokio-signal",
+  "tokio-macros",
+  "tokio-net",
   "tokio-sync",
-  "tokio-threadpool",
+  "tokio-test",
   "tokio-timer",
-  "tokio-tcp",
   "tokio-tls",
-  "tokio-trace",
-  "tokio-trace/tokio-trace-core",
-  "tokio-udp",
-  "tokio-uds",
+  "build-tests",
 ]
-
-[features]
-default = [
-  "codec",
-  "fs",
-  "io",
-  "reactor",
-  "rt-full",
-  "sync",
-  "tcp",
-  "timer",
-  "udp",
-  "uds",
-]
-
-codec = ["io", "tokio-codec"]
-fs = ["tokio-fs"]
-io = ["bytes", "tokio-io"]
-reactor = ["io", "mio", "tokio-reactor"]
-rt-full = [
-  "num_cpus",
-  "reactor",
-  "timer",
-  "tokio-current-thread",
-  "tokio-executor",
-  "tokio-threadpool",
-  "tokio-trace-core",
-]
-sync = ["tokio-sync"]
-tcp = ["tokio-tcp"]
-timer = ["tokio-timer"]
-udp = ["tokio-udp"]
-uds = ["tokio-uds"]
-
-# This feature comes with no promise of stability. Things will
-# break with each patch release. Use at your own risk.
-async-await-preview = [
-  "tokio-async-await/async-await-preview",
-]
-
-[badges]
-travis-ci = { repository = "tokio-rs/tokio" }
-appveyor = { repository = "carllerche/tokio", id = "s83yxhy9qeb58va7" }
-
-[dependencies]
-# Only non-optional dependency...
-futures = "0.1.20"
-
-# Everything else is optional...
-bytes = { version = "0.4", optional = true }
-num_cpus = { version = "1.8.0", optional = true }
-tokio-codec = { version = "0.1.0", path = "tokio-codec", optional = true }
-tokio-current-thread = { version = "0.1.3", path = "tokio-current-thread", optional = true }
-tokio-fs = { version = "0.1.6", path = "tokio-fs", optional = true }
-tokio-io = { version = "0.1.6", path = "tokio-io", optional = true }
-tokio-executor = { version = "0.1.5", path = "tokio-executor", optional = true }
-tokio-reactor = { version = "0.1.1", path = "tokio-reactor", optional = true }
-tokio-sync = { version = "0.1.3", path = "tokio-sync", optional = true }
-tokio-threadpool = { version = "0.1.8", path = "tokio-threadpool", optional = true }
-tokio-tcp = { version = "0.1.0", path = "tokio-tcp", optional = true }
-tokio-udp = { version = "0.1.0", path = "tokio-udp", optional = true }
-tokio-timer = { version = "0.2.8", path = "tokio-timer", optional = true }
-tokio-trace-core = { version = "0.1", path = "tokio-trace/tokio-trace-core", optional = true }
-
-# Needed until `reactor` is removed from `tokio`.
-mio = { version = "0.6.14", optional = true }
-
-# Needed for async/await preview support
-tokio-async-await = { version = "0.1.0", path = "tokio-async-await", optional = true }
-
-[target.'cfg(unix)'.dependencies]
-tokio-uds = { version = "0.2.1", path = "tokio-uds", optional = true }
-
-[dev-dependencies]
-env_logger = { version = "0.5", default-features = false }
-flate2 = { version = "1", features = ["tokio"] }
-futures-cpupool = "0.1"
-http = "0.1"
-httparse = "1.0"
-libc = "0.2"
-num_cpus = "1.0"
-serde = "1.0"
-serde_derive = "1.0"
-serde_json = "1.0"
-time = "0.1"

README.md

@@ -1,5 +1,7 @@
 # Tokio
 
+ **NOTE**: Tokio's [`master`](https://github.com/tokio-rs/tokio) is currently undergoing heavy development. This branch and the alpha releases will see API breaking changes and there are currently significant performance regressions that still need to be fixed before the final release. Use the [`v0.1.x`](https://github.com/tokio-rs/tokio/tree/v0.1.x) branch for stable releases.
+
 A runtime for writing reliable, asynchronous, and slim applications with
 the Rust programming language. It is:
 
@@ -20,21 +22,17 @@ the Rust programming language. It is:
 [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
 
 [Website](https://tokio.rs) |
-[Guides](https://tokio.rs/docs/getting-started/hello-world/) |
-[API Docs](https://docs.rs/tokio/0.1.16/tokio) |
+[Guides](https://tokio.rs/docs/) |
+[API Docs](https://docs.rs/tokio/latest/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/
-
 ## Overview
 
 Tokio is an event-driven, non-blocking I/O platform for writing
@@ -42,63 +40,65 @@ 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/tokio/net/index.html
-[reactor]: https://docs.rs/tokio/0.1/tokio/reactor/index.html
-[scheduler]: https://tokio-rs.github.io/tokio/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;
 use tokio::net::TcpListener;
+use tokio::prelude::*;
+use std::net::SocketAddr;
 
-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 addr = "127.0.0.1:8080".parse::<SocketAddr>()?;
+    let mut listener = TcpListener::bind(&addr).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) => {
+                        println!("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 {
+                    println!("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](tokio/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
 
@@ -107,6 +107,8 @@ First, see if the answer to your question can be found in the [Guides] or the
 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.
 
+[Guides]: https://tokio.rs/docs/
+[API documentation]: https://docs.rs/tokio/latest/tokio
 [chat]: https://gitter.im/tokio-rs/tokio
 [issue]: https://github.com/tokio-rs/tokio/issues/new
 
@@ -126,46 +128,47 @@ have greater guarantees of stability.
 
 The crates included as part of Tokio are:
 
-* [`tokio-async-await`]: Experimental `async` / `await` support.
-
-* [`tokio-codec`]: Utilities for encoding and decoding protocol frames.
-
-* [`tokio-current-thread`]: Schedule the execution of futures on the current
-  thread.
-
-* [`tokio-executor`]: Task execution related traits and utilities.
+* [`tokio-executor`]: Task executors and related utilities. Includes a
+  single-threaded executor and a multi-threaded, work-stealing, executor.
 
 * [`tokio-fs`]: Filesystem (and standard in / out) APIs.
 
+* [`tokio-codec`]: Utilities for encoding and decoding protocol frames.
+
 * [`tokio-io`]: Asynchronous I/O related traits and utilities.
 
-* [`tokio-reactor`]: Event loop that drives I/O resources (like TCP and UDP
-  sockets).
+* [`tokio-macros`]: Macros for usage with Tokio.
 
-* [`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-net`]: Event loop that drives I/O resources as well as TCP, UDP, and
+  unix domain socket apis.
 
 * [ `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-macros`]: tokio-macros
+[`tokio-net`]: tokio-net
 [`tokio-timer`]: tokio-timer
-[`tokio-udp`]: tokio-udp
-[`tokio-uds`]: tokio-uds
+
+## Related Projects
+
+In addition to the crates in this repository, the Tokio project also maintains
+several other libraries, including:
+
+* [`tracing`] (formerly `tokio-trace`): A framework for application-level
+  tracing and async-aware diagnostics.
+
+* [`mio`]: A low-level, cross-platform abstraction over OS I/O APIs that powers
+  `tokio`.
+
+* [`bytes`]: Utilities for working with bytes, including efficient byte buffers.
+
+[`tracing`]: https://github.com/tokio-rs/tracing
+[`mio`]: https://github.com/tokio-rs/mio
+[`bytes`]: https://github.com/tokio-rs/bytes
 
 ## Supported Rust Versions
 

azure-pipelines.yml

@@ -1,115 +1,131 @@
-trigger: ["master"]
-pr: ["master"]
+trigger: ["master", "std-future"]
+pr: ["master", "std-future"]
+
+variables:
+  RUSTFLAGS: -Dwarnings
 
 jobs:
 # Check formatting
 - template: ci/azure-rustfmt.yml
   parameters:
+    rust: beta
     name: rustfmt
 
+# Apply clippy lints to all crates
+- template: ci/azure-clippy.yml
+  parameters:
+    rust: beta
+    name: clippy
+
 # Test top level crate
 - template: ci/azure-test-stable.yml
   parameters:
     name: test_tokio
+    rust: beta
     displayName: Test tokio
     cross: true
-    crates:
-      - tokio
-
-# 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
-- template: ci/azure-test-stable.yml
-  parameters:
-    name: test_linux
-    displayName: Test sub crates - Any
-    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
+        - net
+        - sync
         - tcp
         - timer
         - udp
         - uds
-      tokio-buf:
-        - util
 
-# Check async / await
-- template: ci/azure-cargo-check.yml
+# Test crates that are platform specific
+- template: ci/azure-test-stable.yml
   parameters:
-    name: async_await
-    displayName: Async / Await
-    rust: nightly-2019-02-28
-    noDefaultFeatures: ''
-    benches: true
+    name: test_sub_cross
+    displayName: Test sub crates (cross) -
+    cross: true
+    rust: beta
     crates:
-      tokio:
-        - async-await-preview
+      tokio-fs: []
+      tokio-net:
+        - process
+        - signal
+        - tcp
+        - udp
+        - uds
+
+# Test crates that are NOT platform specific
+- template: ci/azure-test-stable.yml
+  parameters:
+    name: test_linux
+    displayName: Test sub crates -
+    rust: beta
+    crates:
+      tokio-codec: []
+      tokio-executor:
+        - current-thread
+        - threadpool
+      tokio-io:
+        - util
+      tokio-sync:
+        - async-traits
+      tokio-macros: []
+      tokio-timer:
+        - async-traits
+      tokio-test: []
+
+# Test compilation failure
+- template: ci/azure-test-stable.yml
+  parameters:
+    name: test_features
+    displayName: Test feature flags
+    rust: beta
+    crates:
+      build-tests:
+        - tokio-executor
+        - tokio-net
+        - executor-without-current-thread
+        - macros-invalid-input
+        - net-no-features
+        - net-with-tcp
+        - net-with-udp
+        - net-with-uds
+        - tokio-no-features
+        - tokio-with-net
 
 # Try cross compiling
 - template: ci/azure-cross-compile.yml
   parameters:
-    name: cross_32bit_linux
-    target: i686-unknown-linux-gnu
+    name: cross
+    rust: beta
 
-# This represents the minimum Rust version supported by
-# Tokio. Updating this should be done in a dedicated PR and
-# cannot be greater than two 0.x releases prior to the
-# current stable.
+# # This represents the minimum Rust version supported by
+# # Tokio. Updating this should be done in a dedicated PR and
+# # cannot be greater than two 0.x releases prior to the
+# # current stable.
+# #
+# # Tests are not run as tests may require newer versions of
+# # rust.
+# - template: ci/azure-check-minrust.yml
+#   parameters:
+#     name: minrust
+#     rust_version: 1.34.0
 #
-# Tests are not run as tests may require newer versions of
-# rust.
-- template: ci/azure-check-minrust.yml
-  parameters:
-    name: minrust
-    rust_version: 1.26.0
-
-- template: ci/azure-tsan.yml
-  parameters:
-    name: tsan
+# - template: ci/azure-tsan.yml
+#   parameters:
+#     name: tsan
+#     rust: beta
 
 - template: ci/azure-deploy-docs.yml
   parameters:
+    rust: beta
     dependsOn:
       - rustfmt
+      - clippy
       - test_tokio
       - test_sub_cross
       - test_linux
-      - features
-      - async_await
-      - cross_32bit_linux
-      - minrust
-      - tsan
+      - test_features
+#      - test_nightly
+      - cross
+#      - minrust
+#      - tsan

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
+

build-tests/Cargo.toml

@@ -0,0 +1,27 @@
+[package]
+name = "build-tests"
+version = "0.1.0"
+authors = ["Tokio Contributors <[email protected]>"]
+edition = "2018"
+publish = false
+
+[features]
+executor-without-current-thread = ["tokio-executor"]
+macros-invalid-input = ["tokio/rt-full"]
+net-no-features = ["tokio-net"]
+net-with-tcp = ["tokio-net/tcp"]
+net-with-udp = ["tokio-net/udp"]
+net-with-uds = ["tokio-net/uds"]
+net-with-process = ["tokio-net/process"]
+tokio-no-features = ["tokio"]
+tokio-with-net = ["tokio/net"]
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+tokio-executor = { path = "../tokio-executor", optional = true }
+tokio-net = { path = "../tokio-net", optional = true }
+tokio = { path = "../tokio", optional = true, default-features = false }
+
+[dev-dependencies]
+trybuild = "1.0"

build-tests/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.

build-tests/src/lib.rs

@@ -0,0 +1,8 @@
+#[cfg(feature = "tokio-executor")]
+pub use tokio_executor;
+
+#[cfg(feature = "tokio-net")]
+pub use tokio_net;
+
+#[cfg(feature = "tokio")]
+pub use tokio;

build-tests/tests/fail/executor_without_current_thread.rs

@@ -0,0 +1,3 @@
+use build_tests::tokio_executor::current_thread;
+
+fn main() {}

build-tests/tests/fail/executor_without_current_thread.stderr

@@ -0,0 +1,7 @@
+error[E0432]: unresolved import `build_tests::tokio_executor::current_thread`
+ --> $DIR/executor_without_current_thread.rs:1:5
+  |
+1 | use build_tests::tokio_executor::current_thread;
+  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `current_thread` in `tokio_executor`
+
+For more information about this error, try `rustc --explain E0432`.

build-tests/tests/fail/macros_invalid_input.rs

@@ -0,0 +1,28 @@
+use build_tests::tokio;
+
+#[tokio::main]
+fn main_is_not_async() {}
+
+#[tokio::main]
+async fn main_fn_has_args(_x: u8) {}
+
+#[tokio::main(foo)]
+async fn main_attr_has_unknown_args() {}
+
+#[tokio::main(multi_thread::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() {}

build-tests/tests/fail/macros_invalid_input.stderr

@@ -0,0 +1,47 @@
+error: the async keyword is missing from the function declaration
+ --> $DIR/macros_invalid_input.rs:4:1
+  |
+4 | fn main_is_not_async() {}
+  | ^^
+
+error: the main function cannot accept arguments
+ --> $DIR/macros_invalid_input.rs:7:27
+  |
+7 | async fn main_fn_has_args(_x: u8) {}
+  |                           ^^^^^^
+
+error: Unknown attribute foo is specified
+ --> $DIR/macros_invalid_input.rs:9:15
+  |
+9 | #[tokio::main(foo)]
+  |               ^^^
+
+error: Must have specified ident
+  --> $DIR/macros_invalid_input.rs:12:15
+   |
+12 | #[tokio::main(multi_thread::bar)]
+   |               ^^^^^^^^^^^^^^^^^
+
+error: the async keyword is missing from the function declaration
+  --> $DIR/macros_invalid_input.rs:16:1
+   |
+16 | fn test_is_not_async() {}
+   | ^^
+
+error: the test function cannot accept arguments
+  --> $DIR/macros_invalid_input.rs:19:27
+   |
+19 | async fn test_fn_has_args(_x: u8) {}
+   |                           ^^^^^^
+
+error: unexpected token
+  --> $DIR/macros_invalid_input.rs:21:15
+   |
+21 | #[tokio::test(foo)]
+   |               ^^^
+
+error: second test attribute is supplied
+  --> $DIR/macros_invalid_input.rs:25:1
+   |
+25 | #[test]
+   | ^^^^^^^

build-tests/tests/fail/net_without_tcp_missing_tcp.rs

@@ -0,0 +1,4 @@
+use build_tests::tokio_net::tcp;
+
+fn main() {}
+

build-tests/tests/fail/net_without_tcp_missing_tcp.stderr

@@ -0,0 +1,7 @@
+error[E0432]: unresolved import `build_tests::tokio_net::tcp`
+ --> $DIR/net_without_tcp_missing_tcp.rs:1:5
+  |
+1 | use build_tests::tokio_net::tcp;
+  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `tcp` in `tokio_net`
+
+For more information about this error, try `rustc --explain E0432`.

build-tests/tests/fail/net_without_udp_missing_udp.rs

@@ -0,0 +1,4 @@
+use build_tests::tokio_net::udp;
+
+fn main() {}
+

build-tests/tests/fail/net_without_udp_missing_udp.stderr

@@ -0,0 +1,7 @@
+error[E0432]: unresolved import `build_tests::tokio_net::udp`
+ --> $DIR/net_without_udp_missing_udp.rs:1:5
+  |
+1 | use build_tests::tokio_net::udp;
+  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `udp` in `tokio_net`
+
+For more information about this error, try `rustc --explain E0432`.

build-tests/tests/fail/net_without_uds_missing_uds.rs

@@ -0,0 +1,4 @@
+use build_tests::tokio_net::uds;
+
+fn main() {}
+

build-tests/tests/fail/net_without_uds_missing_uds.stderr

@@ -0,0 +1,7 @@
+error[E0432]: unresolved import `build_tests::tokio_net::uds`
+ --> $DIR/net_without_uds_missing_uds.rs:1:5
+  |
+1 | use build_tests::tokio_net::uds;
+  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `uds` in `tokio_net`
+
+For more information about this error, try `rustc --explain E0432`.

build-tests/tests/fail/tokio_without_net_missing_net.rs

@@ -0,0 +1,3 @@
+use build_tests::tokio::net;
+
+fn main() {}

build-tests/tests/fail/tokio_without_net_missing_net.stderr

@@ -0,0 +1,7 @@
+error[E0432]: unresolved import `build_tests::tokio::net`
+ --> $DIR/tokio_without_net_missing_net.rs:1:5
+  |
+1 | use build_tests::tokio::net;
+  |     ^^^^^^^^^^^^^^^^^^^^^^^ no `net` in `tokio`
+
+For more information about this error, try `rustc --explain E0432`.

build-tests/tests/features.rs

@@ -0,0 +1,62 @@
+#![allow(unused_imports)]
+
+#[test]
+#[cfg(feature = "tokio-net")]
+fn net_default() {
+    use build_tests::tokio_net::driver::{set_default, Handle, Reactor, Registration};
+    use build_tests::tokio_net::util::PollEvented;
+}
+
+#[test]
+#[cfg(feature = "net-with-tcp")]
+fn net_with_tcp() {
+    use build_tests::tokio_net::tcp;
+}
+
+#[test]
+#[cfg(feature = "net-with-udp")]
+fn net_with_udp() {
+    use build_tests::tokio_net::udp;
+}
+
+#[test]
+#[cfg(feature = "net-with-uds")]
+fn net_with_uds() {
+    use build_tests::tokio_net::uds;
+}
+
+#[test]
+#[cfg(feature = "net-with-process")]
+fn net_with_process() {
+    use build_tests::tokio_net::process;
+}
+
+#[test]
+#[cfg(feature = "tokio-with-net")]
+fn tokio_with_net() {
+    // net is present
+    use build_tests::tokio::net;
+}
+
+#[test]
+fn compile_fail() {
+    let t = trybuild::TestCases::new();
+
+    #[cfg(feature = "executor-without-current-thread")]
+    t.compile_fail("tests/fail/executor_without_current_thread.rs");
+
+    #[cfg(feature = "macros-invalid-input")]
+    t.compile_fail("tests/fail/macros_invalid_input.rs");
+
+    #[cfg(feature = "net-no-features")]
+    {
+        t.compile_fail("tests/fail/net_without_tcp_missing_tcp.rs");
+        t.compile_fail("tests/fail/net_without_udp_missing_udp.rs");
+        t.compile_fail("tests/fail/net_without_uds_missing_uds.rs");
+    }
+
+    #[cfg(feature = "tokio-no-features")]
+    t.compile_fail("tests/fail/tokio_without_net_missing_net.rs");
+
+    drop(t);
+}

ci/azure-cargo-check.yml

@@ -11,17 +11,19 @@ jobs:
     parameters:
       rust_version: ${{ parameters.rust }}
 
+  - template: azure-is-release.yml
+
   - ${{ each crate in parameters.crates }}:
     - ${{ each feature in crate.value }}:
-      - ${{ if eq(crate.key, 'tokio') }}:
-        - script: cargo check ${{ parameters.noDefaultFeatures }} --features ${{ feature }}
-          displayName: Check features = ${{ feature }}
+      - script: cargo check ${{ parameters.noDefaultFeatures }} --features ${{ feature }}
+        displayName: Check `${{ crate.key }}`, features = ${{ feature }}
+        workingDirectory: $(Build.SourcesDirectory)/${{ crate.key }}
+        condition: and(succeeded(), not(variables['isRelease']))
 
-      - ${{ if not(eq(crate.key, 'tokio')) }}:
-        - script: cargo check ${{ parameters.noDefaultFeatures }} --features ${{ feature }}
-          displayName: Check `${{ crate.key }}`, features = ${{ feature }}
-          workingDirectory: $(Build.SourcesDirectory)/${{ crate.key }}
+  - template: azure-patch-crates.yml
 
-  - ${{ if parameters.benches }}:
-    - script: cargo check --benches --all
-      displayName: Check benchmarks
+  - ${{ each crate in parameters.crates }}:
+    - ${{ each feature in crate.value }}:
+      - script: cargo check ${{ parameters.noDefaultFeatures }} --features ${{ feature }}
+        displayName: Check `${{ crate.key }}`, features = ${{ feature }}
+        workingDirectory: $(Build.SourcesDirectory)/${{ crate.key }}

ci/azure-check-minrust.yml

@@ -8,5 +8,7 @@ jobs:
     parameters:
       rust_version: ${{ parameters.rust_version }}
 
+  - template: azure-patch-crates.yml
+
   - script: cargo check --all
     displayName: cargo check --all

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
+      displayName: cargo clippy --all

ci/azure-cross-compile.yml

@@ -1,21 +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-unknown-linux-gnueabi
   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
 
-  - script: cargo check --all --exclude tokio-tls --target ${{ parameters.target }}
+  # Always patch
+  - template: azure-patch-crates.yml
+
+  - 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 --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 --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

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

ci/azure-patch-crates.yml

@@ -0,0 +1,16 @@
+steps:
+  - script: |
+      set -e
+
+      # Remove any existing patch statements
+      mv Cargo.toml Cargo.toml.bck
+      sed -n '/\[patch.crates-io\]/q;p' Cargo.toml.bck > Cargo.toml
+
+      # Patch all crates
+      cat ci/patch.toml >> Cargo.toml
+
+      # Print `Cargo.toml` for debugging
+      echo "~~~~ Cargo.toml ~~~~"
+      cat Cargo.toml
+      echo "~~~~~~~~~~~~~~~~~~~~"
+    displayName: Patch Cargo.toml

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-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,20 +17,45 @@ jobs:
   steps:
   - template: azure-install-rust.yml
     parameters:
-      rust_version: stable
+      # rust_version: stable
+      rust_version: ${{ parameters.rust }}
+
+  - template: azure-is-release.yml
 
   - ${{ each crate in parameters.crates }}:
-    - ${{ if eq(crate, 'tokio') }}:
-      - script: cargo test
-        env:
-          LOOM_MAX_DURATION: 10
-          CI: 'True'
-        displayName: cargo test
+    # Run with default crate features
+    - script: cargo test
+      env:
+        LOOM_MAX_PREEMPTIONS: 2
+        CI: 'True'
+      displayName: ${{ crate.key }} - cargo test
+      workingDirectory: $(Build.SourcesDirectory)/${{ crate.key }}
 
-    - ${{ if not(eq(crate, 'tokio')) }}:
-      - script: cargo test
+    # Run with each specified feature
+    - ${{ each feature in crate.value }}:
+      - script: cargo test --no-default-features --features ${{ feature }}
         env:
-          LOOM_MAX_DURATION: 10
+          LOOM_MAX_PREEMPTIONS: 2
           CI: 'True'
-        displayName: cargo test -p ${{ crate }}
-        workingDirectory: $(Build.SourcesDirectory)/${{ crate }}
+        displayName: ${{ crate.key }} - cargo test --features ${{ feature }}
+        workingDirectory: $(Build.SourcesDirectory)/${{ crate.key }}
+
+  - template: azure-patch-crates.yml
+
+  - ${{ each crate in parameters.crates }}:
+    # Run with default crate features
+    - script: cargo test
+      env:
+        LOOM_MAX_PREEMPTIONS: 2
+        CI: 'True'
+      displayName: ${{ crate.key }} - cargo test
+      workingDirectory: $(Build.SourcesDirectory)/${{ crate.key }}
+
+    # Run with each specified feature
+    - ${{ each feature in crate.value }}:
+      - script: cargo test --no-default-features --features ${{ feature }}
+        env:
+          LOOM_MAX_PREEMPTIONS: 2
+          CI: 'True'
+        displayName: ${{ crate.key }} - cargo test --features ${{ feature }}
+        workingDirectory: $(Build.SourcesDirectory)/${{ crate.key }}

ci/azure-tsan.yml

@@ -6,16 +6,18 @@ jobs:
       Timer:
         cmd: cargo test -p tokio-timer --test hammer
       Threadpool:
-        cmd: cargo test -p tokio-threadpool --tests
+        cmd: cargo test -p tokio-executor --tests --features threadpool
   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: |
         set -e
+
         # Make sure the benchmarks compile
         export ASAN_OPTIONS="detect_odr_violation=0 detect_leaks=0"
         export TSAN_OPTIONS="suppressions=`pwd`/ci/tsan"

ci/patch.toml

@@ -0,0 +1,13 @@
+# Patch dependencies to run all tests against versions of the crate in the
+# repository.
+[patch.crates-io]
+tokio = { path = "tokio" }
+tokio-codec = { path = "tokio-codec" }
+tokio-executor = { path = "tokio-executor" }
+tokio-fs = { path = "tokio-fs" }
+tokio-io = { path = "tokio-io" }
+tokio-macros = { path = "tokio-macros" }
+tokio-net = { path = "tokio-net" }
+tokio-sync = { path = "tokio-sync" }
+tokio-timer = { path = "tokio-timer" }
+tokio-tls = { path = "tokio-tls" }

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/README.md

@@ -1,60 +0,0 @@
-## 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!

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

@@ -1,473 +0,0 @@
-//! A chat server that broadcasts a message to all connections.
-//!
-//! This example is explicitly more verbose than it has to be. This is to
-//! illustrate more concepts.
-//!
-//! A chat server for telnet clients. After a telnet client connects, the first
-//! line should contain the client's name. After that, all lines sent by a
-//! client are broadcasted to all other connected clients.
-//!
-//! Because the client is telnet, lines are delimited by "\r\n".
-//!
-//! You can test this out by running:
-//!
-//!     cargo run --example chat
-//!
-//! And then in another terminal run:
-//!
-//!     telnet localhost 6142
-//!
-//! You can run the `telnet` command in any number of additional windows.
-//!
-//! 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 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 std::collections::HashMap;
-use std::net::SocketAddr;
-use std::sync::{Arc, Mutex};
-
-/// Shorthand for the transmit half of the message channel.
-type Tx = mpsc::UnboundedSender<Bytes>;
-
-/// Shorthand for the receive half of the message channel.
-type Rx = mpsc::UnboundedReceiver<Bytes>;
-
-/// Data that is shared between all peers in the chat server.
-///
-/// This is the set of `Tx` handles for all connected clients. Whenever a
-/// message is received from a client, it is broadcasted to all peers by
-/// iterating over the `peers` entries and sending a copy of the message on each
-/// `Tx`.
-struct Shared {
-    peers: HashMap<SocketAddr, Tx>,
-}
-
-/// 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>>,
-
-    /// 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 {
-    /// Create a new, empty, instance of `Shared`.
-    fn new() -> Self {
-        Shared {
-            peers: HashMap::new(),
-        }
-    }
-}
-
-impl Peer {
-    /// Create a new instance of `Peer`.
-    fn new(name: BytesMut, state: Arc<Mutex<Shared>>, lines: Lines) -> Peer {
-        // Get the client socket address
-        let addr = lines.socket.peer_addr().unwrap();
-
-        // Create a channel for this peer
-        let (tx, rx) = mpsc::unbounded();
-
-        // Add an entry for this `Peer` in the shared state map.
-        state.lock().unwrap().peers.insert(addr, tx);
-
-        Peer {
-            name,
-            lines,
-            state,
-            rx,
-            addr,
-        }
-    }
-}
-
-/// 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;
-
-    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)
-    }
-}
-
-impl Drop for Peer {
-    fn drop(&mut self) {
-        self.state.lock().unwrap().peers.remove(&self.addr);
-    }
-}
-
-impl Lines {
-    /// Create a new `Lines` codec backed by the socket
-    fn new(socket: TcpStream) -> Self {
-        Lines {
-            socket,
-            rd: BytesMut::new(),
-            wr: BytesMut::new(),
-        }
-    }
-
-    /// 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);
-        }
-
-        Ok(Async::Ready(()))
-    }
-
-    /// 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);
-
-            // Read data into the buffer.
-            let n = try_ready!(self.socket.read_buf(&mut self.rd));
-
-            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)
-        })
-        // 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()));
-
-    let addr = "127.0.0.1:6142".parse()?;
-
-    // Bind a TCP listener to the socket address.
-    //
-    // Note that this is the Tokio TcpListener, which is fully async.
-    let listener = TcpListener::bind(&addr)?;
-
-    // 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);
-        });
-
-    println!("server running on localhost:6142");
-
-    // 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

@@ -1,257 +0,0 @@
-//! An example of hooking up stdin/stdout to either a TCP or UDP stream.
-//!
-//! This example will connect to a socket address specified in the argument list
-//! and then forward all data read on stdin to the server, printing out all data
-//! received on stdout. An optional `--udp` argument can be passed to specify
-//! that the connection should be made over UDP instead of TCP, translating each
-//! line entered on stdin to a UDP packet to be sent to the remote address.
-//!
-//! Note that this is not currently optimized for performance, especially
-//! around buffer management. Rather it's intended to show an example of
-//! working with a client.
-//!
-//! This example can be quite useful when interacting with the other examples in
-//! 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)]
-
-extern crate bytes;
-extern crate futures;
-extern crate tokio;
-extern crate tokio_io;
-
-use std::env;
-use std::io::{self, Read, Write};
-use std::net::SocketAddr;
-use std::thread;
-
-use futures::sync::mpsc;
-use tokio::prelude::*;
-
-fn main() -> Result<(), Box<std::error::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") {
-        Some(i) => {
-            args.remove(i);
-            false
-        }
-        None => true,
-    };
-
-    // 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 = 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"));
-
-    // 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))?
-    } else {
-        udp::connect(&addr, Box::new(stdin_rx))?
-    };
-
-    // 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 tokio::net::TcpStream;
-    use tokio::prelude::*;
-
-    use bytes::BytesMut;
-    use codec::Bytes;
-
-    use std::error::Error;
-    use std::io;
-    use std::net::SocketAddr;
-
-    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>> {
-        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
-            })
-            .flatten_stream(),
-        );
-        Ok(stream)
-    }
-}
-
-mod udp {
-    use std::error::Error;
-    use std::io;
-    use std::net::SocketAddr;
-
-    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>> {
-        // 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()?
-        } else {
-            "[::]:0".parse()?
-        };
-        let udp = match UdpSocket::bind(&addr_to_bind) {
-            Ok(udp) => udp,
-            Err(_) => Err("failed to bind socket")?,
-        };
-
-        // 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();
-
-        // 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(())
-            });
-
-        // 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
-            }
-        });
-
-        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.rs

@@ -1,115 +0,0 @@
-//! A "hello world" echo server with Tokio
-//!
-//! This server will create a TCP listener, accept connections in a loop, and
-//! write back everything that's read off of each TCP connection.
-//!
-//! Because the Tokio runtime uses a thread pool, each TCP connection is
-//! processed concurrently with all other TCP connections across multiple
-//! threads.
-//!
-//! To see this server in action, you can run this in one terminal:
-//!
-//!     cargo run --example echo
-//!
-//! and in another terminal you can run:
-//!
-//!     cargo run --example connect 127.0.0.1:8080
-//!
-//! Each line you type in to the `connect` terminal should be echo'd back to
-//! you! If you open up multiple terminals running the `connect` example you
-//! should be able to see them all make progress simultaneously.
-
-#![deny(warnings)]
-
-extern crate tokio;
-
-use tokio::io;
-use tokio::net::TcpListener;
-use tokio::prelude::*;
-
-use std::env;
-use std::net::SocketAddr;
-
-fn main() -> Result<(), Box<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>()?;
-
-    // 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)?;
-    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);
-
-            // 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),
-                }
-
-                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)
-        });
-
-    // 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

@@ -1,58 +0,0 @@
-//! Hello world server.
-//!
-//! A simple client that opens a TCP stream, writes "hello world\n", and closes
-//! the connection.
-//!
-//! You can test this out by running:
-//!
-//!     ncat -l 6142
-//!
-//! And then in another terminal run:
-//!
-//!     cargo run --example hello_world
-
-#![deny(warnings)]
-
-extern crate tokio;
-
-use tokio::io;
-use tokio::net::TcpStream;
-use tokio::prelude::*;
-
-pub fn main() -> Result<(), Box<std::error::Error>> {
-    let addr = "127.0.0.1:6142".parse()?;
-
-    // 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);
-        });
-
-    // 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.");
-
-    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

@@ -1,150 +0,0 @@
-//! A "print-each-packet" server with Tokio
-//!
-//! 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.
-//!
-//! Because the Tokio runtime uses a thread pool, each TCP connection is
-//! processed concurrently with all other TCP connections across multiple
-//! threads.
-//!
-//! To see this server in action, you can run this in one terminal:
-//!
-//!     cargo run --example print\_each\_packet
-//!
-//! and in another terminal you can run:
-//!
-//!     cargo run --example connect 127.0.0.1:8080
-//!
-//! Each line you type in to the `connect` terminal should be written to terminal!
-//!
-//! Minimal js example:
-//!
-//! ```js
-//! var net = require("net");
-//!
-//! var listenPort = 8080;
-//!
-//! var server = net.createServer(function (socket) {
-//!     socket.on("data", function (bytes) {
-//!         console.log("bytes", bytes);
-//!     });
-//!
-//!     socket.on("end", function() {
-//!         console.log("Socket received FIN packet and closed connection");
-//!     });
-//!     socket.on("error", function (error) {
-//!         console.log("Socket closed with error", error);
-//!     });
-//!
-//!     socket.on("close", function (with_error) {
-//!         if (with_error) {
-//!             console.log("Socket closed with result: Err(SomeError)");
-//!         } else {
-//!             console.log("Socket closed with result: Ok(())");
-//!         }
-//!     });
-//!
-//! });
-//!
-//! server.listen(listenPort);
-//!
-//! console.log("Listening on:", listenPort);
-//! ```
-//!
-
-#![deny(warnings)]
-
-extern crate tokio;
-extern crate tokio_codec;
-
-use tokio::codec::Decoder;
-use tokio::net::TcpListener;
-use tokio::prelude::*;
-use tokio_codec::BytesCodec;
-
-use std::env;
-use std::net::SocketAddr;
-
-fn main() -> Result<(), Box<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>()?;
-
-    // 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)?;
-    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();
-
-            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.
-            //
-            // 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)
-        });
-
-    // 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

@@ -1,130 +0,0 @@
-//! A proxy that forwards data to another server and forwards that server's
-//! responses back to clients.
-//!
-//! Because the Tokio runtime uses a thread pool, each TCP connection is
-//! processed concurrently with all other TCP connections across multiple
-//! threads.
-//!
-//! You can showcase this by running this in one terminal:
-//!
-//!     cargo run --example proxy
-//!
-//! This in another terminal
-//!
-//!     cargo run --example echo
-//!
-//! And finally this in another terminal
-//!
-//!     cargo run --example connect 127.0.0.1:8081
-//!
-//! 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)]
-
-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::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>()?;
-
-    let server_addr = env::args().nth(2).unwrap_or("127.0.0.1:8080".to_string());
-    let server_addr = server_addr.parse::<SocketAddr>()?;
-
-    // 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();
-
-                // 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(())
-        });
-
-    tokio::run(done);
-    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>>);
-
-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())
-    }
-}

examples/udp-codec.rs

@@ -1,65 +0,0 @@
-//! 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
-//! 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)]
-
-extern crate env_logger;
-extern crate tokio;
-extern crate tokio_codec;
-extern crate tokio_io;
-
-use std::net::SocketAddr;
-
-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()?;
-
-    // Bind both our sockets and then figure out what ports we got.
-    let a = UdpSocket::bind(&addr)?;
-    let b = UdpSocket::bind(&addr)?;
-    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();
-
-    // 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)
-    });
-
-    // 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);
-
-    // 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(())
-}

rust-toolchain

@@ -0,0 +1 @@
+nightly-2019-08-21

rustfmt.toml

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

src/async_await.rs

@@ -1,48 +0,0 @@
-use std::future::Future as StdFuture;
-use std::pin::Pin;
-use std::task::{Poll, Waker};
-
-fn map_ok<T: StdFuture>(future: T) -> impl StdFuture<Output = Result<(), ()>> {
-    MapOk(future)
-}
-
-struct MapOk<T>(T);
-
-impl<T> MapOk<T> {
-    fn future<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut T> {
-        unsafe { Pin::map_unchecked_mut(self, |x| &mut x.0) }
-    }
-}
-
-impl<T: StdFuture> StdFuture for MapOk<T> {
-    type Output = Result<(), ()>;
-
-    fn poll(self: Pin<&mut Self>, waker: &Waker) -> Poll<Self::Output> {
-        match self.future().poll(waker) {
-            Poll::Ready(_) => Poll::Ready(Ok(())),
-            Poll::Pending => Poll::Pending,
-        }
-    }
-}
-
-/// Like `tokio::run`, but takes an `async` block
-pub fn run_async<F>(future: F)
-where
-    F: StdFuture<Output = ()> + Send + 'static,
-{
-    use tokio_async_await::compat::backward;
-    let future = backward::Compat::new(map_ok(future));
-
-    ::run(future);
-}
-
-/// Like `tokio::spawn`, but takes an `async` block
-pub fn spawn_async<F>(future: F)
-where
-    F: StdFuture<Output = ()> + Send + 'static,
-{
-    use tokio_async_await::compat::backward;
-    let future = backward::Compat::new(map_ok(future));
-
-    ::spawn(future);
-}

src/executor/current_thread/mod.rs

@@ -1,170 +0,0 @@
-#![allow(deprecated)]
-
-//! Execute many tasks concurrently on the current thread.
-//!
-//! [`CurrentThread`] is an executor that keeps tasks on the same thread that
-//! they were spawned from. This allows it to execute futures that are not
-//! `Send`.
-//!
-//! A single [`CurrentThread`] instance is able to efficiently manage a large
-//! number of tasks and will attempt to schedule all tasks fairly.
-//!
-//! All tasks that are being managed by a [`CurrentThread`] executor are able to
-//! spawn additional tasks by calling [`spawn`]. This function only works from
-//! within the context of a running [`CurrentThread`] instance.
-//!
-//! The easiest way to start a new [`CurrentThread`] executor is to call
-//! [`block_on_all`] with an initial task to seed the executor.
-//!
-//! For example:
-//!
-//! ```
-//! # extern crate tokio;
-//! # extern crate futures;
-//! # use tokio::executor::current_thread;
-//! use futures::future::lazy;
-//!
-//! // Calling execute here results in a panic
-//! // current_thread::spawn(my_future);
-//!
-//! # pub fn main() {
-//! current_thread::block_on_all(lazy(|| {
-//!     // The execution context is setup, futures may be executed.
-//!     current_thread::spawn(lazy(|| {
-//!         println!("called from the current thread executor");
-//!         Ok(())
-//!     }));
-//!
-//!     Ok::<_, ()>(())
-//! }));
-//! # }
-//! ```
-//!
-//! The `block_on_all` function will block the current thread until **all**
-//! tasks that have been spawned onto the [`CurrentThread`] instance have
-//! completed.
-//!
-//! More fine-grain control can be achieved by using [`CurrentThread`] directly.
-//!
-//! ```
-//! # extern crate tokio;
-//! # extern crate futures;
-//! # use tokio::executor::current_thread::CurrentThread;
-//! use futures::future::{lazy, empty};
-//! use std::time::Duration;
-//!
-//! // Calling execute here results in a panic
-//! // current_thread::spawn(my_future);
-//!
-//! # pub fn main() {
-//! let mut current_thread = CurrentThread::new();
-//!
-//! // Spawn a task, the task is not executed yet.
-//! current_thread.spawn(lazy(|| {
-//!     println!("Spawning a task");
-//!     Ok(())
-//! }));
-//!
-//! // Spawn a task that never completes
-//! current_thread.spawn(empty());
-//!
-//! // Run the executor, but only until the provided future completes. This
-//! // provides the opportunity to start executing previously spawned tasks.
-//! let res = current_thread.block_on(lazy(|| {
-//!     Ok::<_, ()>("Hello")
-//! })).unwrap();
-//!
-//! // Now, run the executor for *at most* 1 second. Since a task was spawned
-//! // that never completes, this function will return with an error.
-//! current_thread.run_timeout(Duration::from_secs(1)).unwrap_err();
-//! # }
-//! ```
-//!
-//! # Execution model
-//!
-//! Internally, [`CurrentThread`] maintains a queue. When one of its tasks is
-//! notified, the task gets added to the queue. The executor will pop tasks from
-//! the queue and call [`Future::poll`]. If the task gets notified while it is
-//! being executed, it won't get re-executed until all other tasks currently in
-//! the queue get polled.
-//!
-//! Before the task is polled, a thread-local variable referencing the current
-//! [`CurrentThread`] instance is set. This enables [`spawn`] to spawn new tasks
-//! onto the same executor without having to thread through a handle value.
-//!
-//! If the [`CurrentThread`] instance still has uncompleted tasks, but none of
-//! these tasks are ready to be polled, the current thread is put to sleep. When
-//! a task is notified, the thread is woken up and processing resumes.
-//!
-//! All tasks managed by [`CurrentThread`] remain on the current thread. When a
-//! task completes, it is dropped.
-//!
-//! [`spawn`]: fn.spawn.html
-//! [`block_on_all`]: fn.block_on_all.html
-//! [`CurrentThread`]: struct.CurrentThread.html
-//! [`Future::poll`]: https://docs.rs/futures/0.1/futures/future/trait.Future.html#tymethod.poll
-
-pub use tokio_current_thread::{
-    BlockError,
-    CurrentThread,
-    Entered,
-    Handle,
-    RunError,
-    RunTimeoutError,
-    TaskExecutor,
-    Turn,
-    TurnError,
-    block_on_all,
-    spawn,
-};
-
-use std::cell::Cell;
-use std::marker::PhantomData;
-
-use futures::future::{self};
-
-#[deprecated(since = "0.1.2", note = "use block_on_all instead")]
-#[doc(hidden)]
-#[derive(Debug)]
-pub struct Context<'a> {
-    cancel: Cell<bool>,
-    _p: PhantomData<&'a ()>,
-}
-
-impl<'a> Context<'a> {
-    /// Cancels *all* executing futures.
-    pub fn cancel_all_spawned(&self) {
-        self.cancel.set(true);
-    }
-}
-
-#[deprecated(since = "0.1.2", note = "use block_on_all instead")]
-#[doc(hidden)]
-pub fn run<F, R>(f: F) -> R
-    where F: FnOnce(&mut Context) -> R
-{
-    let mut context = Context {
-        cancel: Cell::new(false),
-        _p: PhantomData,
-    };
-
-    let mut current_thread = CurrentThread::new();
-
-    let ret = current_thread
-        .block_on(future::lazy(|| Ok::<_, ()>(f(&mut context))))
-        .unwrap();
-
-    if context.cancel.get() {
-        return ret;
-    }
-
-    current_thread.run().unwrap();
-    ret
-}
-
-#[deprecated(since = "0.1.2", note = "use TaskExecutor::current instead")]
-#[doc(hidden)]
-pub fn task_executor() -> TaskExecutor {
-    TaskExecutor::current()
-}
-

src/lib.rs

@@ -1,155 +0,0 @@
-#![doc(html_root_url = "https://docs.rs/tokio/0.1.16")]
-#![deny(missing_docs, warnings, missing_debug_implementations)]
-#![cfg_attr(
-    feature = "async-await-preview",
-    feature(async_await, await_macro, futures_api,)
-)]
-
-//! A runtime for writing reliable, asynchronous, and slim applications.
-//!
-//! Tokio is an event-driven, non-blocking I/O platform for writing asynchronous
-//! applications with the Rust programming language. At a high level, it
-//! provides a few major components:
-//!
-//! * A multi threaded, work-stealing based task [scheduler][runtime].
-//! * A [reactor] backed by the operating system's event queue (epoll, kqueue,
-//!   IOCP, etc...).
-//! * Asynchronous [TCP and UDP][net] sockets.
-//! * Asynchronous [filesystem][fs] operations.
-//! * [Timer][timer] API for scheduling work in the future.
-//!
-//! Tokio is built using [futures] as the abstraction for managing the
-//! complexity of asynchronous programming.
-//!
-//! Guide level documentation is found on the [website].
-//!
-//! [website]: https://tokio.rs/docs/getting-started/hello-world/
-//! [futures]: http://docs.rs/futures/0.1
-//!
-//! # Examples
-//!
-//! A simple TCP echo server:
-//!
-//! ```no_run
-//! extern crate tokio;
-//!
-//! use tokio::prelude::*;
-//! use tokio::io::copy;
-//! use tokio::net::TcpListener;
-//!
-//! 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");
-//!
-//!     // 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();
-//!
-//!             // A future that echos the data and returns how
-//!             // many bytes were copied...
-//!             let bytes_copied = copy(reader, writer);
-//!
-//!             // ... 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)
-//!             });
-//!
-//!             // Spawn the future as a concurrent task.
-//!             tokio::spawn(handle_conn)
-//!         });
-//!
-//!     // Start the Tokio runtime
-//!     tokio::run(server);
-//! }
-//! ```
-
-macro_rules! if_runtime {
-    ($($i:item)*) => ($(
-        #[cfg(any(feature = "rt-full"))]
-        $i
-    )*)
-}
-
-#[macro_use]
-extern crate futures;
-
-#[cfg(feature = "io")]
-extern crate bytes;
-#[cfg(feature = "reactor")]
-extern crate mio;
-#[cfg(feature = "rt-full")]
-extern crate num_cpus;
-#[cfg(feature = "codec")]
-extern crate tokio_codec;
-#[cfg(feature = "rt-full")]
-extern crate tokio_current_thread;
-#[cfg(feature = "fs")]
-extern crate tokio_fs;
-#[cfg(feature = "io")]
-extern crate tokio_io;
-#[cfg(feature = "reactor")]
-extern crate tokio_reactor;
-#[cfg(feature = "sync")]
-extern crate tokio_sync;
-#[cfg(feature = "tcp")]
-extern crate tokio_tcp;
-#[cfg(feature = "rt-full")]
-extern crate tokio_threadpool;
-#[cfg(feature = "timer")]
-extern crate tokio_timer;
-#[cfg(feature = "udp")]
-extern crate tokio_udp;
-
-#[cfg(feature = "async-await-preview")]
-extern crate tokio_async_await;
-
-#[cfg(all(unix, feature = "uds"))]
-extern crate tokio_uds;
-
-#[cfg(feature = "timer")]
-pub mod clock;
-#[cfg(feature = "codec")]
-pub mod codec;
-#[cfg(feature = "fs")]
-pub mod fs;
-#[cfg(feature = "io")]
-pub mod io;
-#[cfg(any(feature = "tcp", feature = "udp", feature = "uds"))]
-pub mod net;
-pub mod prelude;
-#[cfg(feature = "reactor")]
-pub mod reactor;
-#[cfg(feature = "sync")]
-pub mod sync;
-#[cfg(feature = "timer")]
-pub mod timer;
-pub mod util;
-
-if_runtime! {
-    extern crate tokio_executor;
-    extern crate tokio_trace_core;
-    pub mod executor;
-    pub mod runtime;
-
-    pub use executor::spawn;
-    pub use runtime::run;
-}
-
-// ===== Experimental async/await support =====
-
-#[cfg(feature = "async-await-preview")]
-mod async_await;
-
-#[cfg(feature = "async-await-preview")]
-pub use async_await::{run_async, spawn_async};
-
-#[cfg(feature = "async-await-preview")]
-pub use tokio_async_await::await;

src/prelude.rs

@@ -1,28 +0,0 @@
-//! A "prelude" for users of the `tokio` crate.
-//!
-//! This prelude is similar to the standard library's prelude in that you'll
-//! almost always want to import its entire contents, but unlike the standard
-//! library's prelude you'll have to do so manually:
-//!
-//! ```
-//! use tokio::prelude::*;
-//! ```
-//!
-//! The prelude may grow over time as additional items see ubiquitous use.
-
-#[cfg(feature = "io")]
-pub use tokio_io::{AsyncRead, AsyncWrite};
-
-pub use util::{FutureExt, StreamExt};
-
-pub use std::io::{Read, Write};
-
-pub use futures::{future, stream, task, Async, AsyncSink, Future, IntoFuture, Poll, Sink, Stream};
-
-#[cfg(feature = "async-await-preview")]
-#[doc(inline)]
-pub use tokio_async_await::{
-    io::{AsyncReadExt, AsyncWriteExt},
-    sink::SinkExt,
-    stream::StreamExt as StreamAsyncExt,
-};

src/reactor/poll_evented.rs

@@ -1,547 +0,0 @@
-//! Readiness tracking streams, backing I/O objects.
-//!
-//! This module contains the core type which is used to back all I/O on object
-//! in `tokio-core`. The `PollEvented` type is the implementation detail of
-//! all I/O. Each `PollEvented` manages registration with a reactor,
-//! acquisition of a token, and tracking of the readiness state on the
-//! underlying I/O primitive.
-
-#![allow(deprecated, warnings)]
-
-use std::fmt;
-use std::io::{self, Read, Write};
-use std::sync::atomic::AtomicUsize;
-use std::sync::atomic::Ordering::Relaxed;
-use std::sync::Mutex;
-
-use futures::{task, Async, Poll};
-use mio::event::Evented;
-use mio::Ready;
-use tokio_io::{AsyncRead, AsyncWrite};
-
-use reactor::{Handle, Registration};
-
-#[deprecated(since = "0.1.2", note = "PollEvented2 instead")]
-#[doc(hidden)]
-pub struct PollEvented<E> {
-    io: E,
-    inner: Inner,
-    handle: Handle,
-}
-
-struct Inner {
-    registration: Mutex<Registration>,
-
-    /// Currently visible read readiness
-    read_readiness: AtomicUsize,
-
-    /// Currently visible write readiness
-    write_readiness: AtomicUsize,
-}
-
-impl<E: fmt::Debug> fmt::Debug for PollEvented<E> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_struct("PollEvented").field("io", &self.io).finish()
-    }
-}
-
-impl<E> PollEvented<E> {
-    /// Creates a new readiness stream associated with the provided
-    /// `loop_handle` and for the given `source`.
-    pub fn new(io: E, handle: &Handle) -> io::Result<PollEvented<E>>
-    where
-        E: Evented,
-    {
-        let registration = Registration::new();
-        registration.register(&io)?;
-
-        Ok(PollEvented {
-            io: io,
-            inner: Inner {
-                registration: Mutex::new(registration),
-                read_readiness: AtomicUsize::new(0),
-                write_readiness: AtomicUsize::new(0),
-            },
-            handle: handle.clone(),
-        })
-    }
-
-    /// Tests to see if this source is ready to be read from or not.
-    ///
-    /// If this stream is not ready for a read then `Async::NotReady` will be
-    /// returned and the current task will be scheduled to receive a
-    /// notification when the stream is readable again. In other words, this
-    /// method is only safe to call from within the context of a future's task,
-    /// typically done in a `Future::poll` method.
-    ///
-    /// This is mostly equivalent to `self.poll_ready(Ready::readable())`.
-    ///
-    /// # Panics
-    ///
-    /// This function will panic if called outside the context of a future's
-    /// task.
-    pub fn poll_read(&mut self) -> Async<()> {
-        if self.poll_read2().is_ready() {
-            return ().into();
-        }
-
-        Async::NotReady
-    }
-
-    fn poll_read2(&self) -> Async<Ready> {
-        let r = self.inner.registration.lock().unwrap();
-
-        // Load the cached readiness
-        match self.inner.read_readiness.load(Relaxed) {
-            0 => {}
-            mut n => {
-                // Check what's new with the reactor.
-                if let Some(ready) = r.take_read_ready().unwrap() {
-                    n |= ready2usize(ready);
-                    self.inner.read_readiness.store(n, Relaxed);
-                }
-
-                return usize2ready(n).into();
-            }
-        }
-
-        let ready = match r.poll_read_ready().unwrap() {
-            Async::Ready(r) => r,
-            _ => return Async::NotReady,
-        };
-
-        // Cache the value
-        self.inner.read_readiness.store(ready2usize(ready), Relaxed);
-
-        ready.into()
-    }
-
-    /// Tests to see if this source is ready to be written to or not.
-    ///
-    /// If this stream is not ready for a write then `Async::NotReady` will be returned
-    /// and the current task will be scheduled to receive a notification when
-    /// the stream is writable again. In other words, this method is only safe
-    /// to call from within the context of a future's task, typically done in a
-    /// `Future::poll` method.
-    ///
-    /// This is mostly equivalent to `self.poll_ready(Ready::writable())`.
-    ///
-    /// # Panics
-    ///
-    /// This function will panic if called outside the context of a future's
-    /// task.
-    pub fn poll_write(&mut self) -> Async<()> {
-        let r = self.inner.registration.lock().unwrap();
-
-        match self.inner.write_readiness.load(Relaxed) {
-            0 => {}
-            mut n => {
-                // Check what's new with the reactor.
-                if let Some(ready) = r.take_write_ready().unwrap() {
-                    n |= ready2usize(ready);
-                    self.inner.write_readiness.store(n, Relaxed);
-                }
-
-                return ().into();
-            }
-        }
-
-        let ready = match r.poll_write_ready().unwrap() {
-            Async::Ready(r) => r,
-            _ => return Async::NotReady,
-        };
-
-        // Cache the value
-        self.inner
-            .write_readiness
-            .store(ready2usize(ready), Relaxed);
-
-        ().into()
-    }
-
-    /// Test to see whether this source fulfills any condition listed in `mask`
-    /// provided.
-    ///
-    /// The `mask` given here is a mio `Ready` set of possible events. This can
-    /// contain any events like read/write but also platform-specific events
-    /// such as hup and error. The `mask` indicates events that are interested
-    /// in being ready.
-    ///
-    /// If any event in `mask` is ready then it is returned through
-    /// `Async::Ready`. The `Ready` set returned is guaranteed to not be empty
-    /// and contains all events that are currently ready in the `mask` provided.
-    ///
-    /// If no events are ready in the `mask` provided then the current task is
-    /// scheduled to receive a notification when any of them become ready. If
-    /// the `writable` event is contained within `mask` then this
-    /// `PollEvented`'s `write` task will be blocked and otherwise the `read`
-    /// task will be blocked. This is generally only relevant if you're working
-    /// with this `PollEvented` object on multiple tasks.
-    ///
-    /// # Panics
-    ///
-    /// This function will panic if called outside the context of a future's
-    /// task.
-    pub fn poll_ready(&mut self, mask: Ready) -> Async<Ready> {
-        let mut ret = Ready::empty();
-
-        if mask.is_empty() {
-            return ret.into();
-        }
-
-        if mask.is_writable() {
-            if self.poll_write().is_ready() {
-                ret = Ready::writable();
-            }
-        }
-
-        let mask = mask - Ready::writable();
-
-        if !mask.is_empty() {
-            if let Async::Ready(v) = self.poll_read2() {
-                ret |= v & mask;
-            }
-        }
-
-        if ret.is_empty() {
-            if mask.is_writable() {
-                let _ = self.need_write();
-            }
-
-            if mask.is_readable() {
-                let _ = self.need_read();
-            }
-
-            Async::NotReady
-        } else {
-            ret.into()
-        }
-    }
-
-    /// Indicates to this source of events that the corresponding I/O object is
-    /// no longer readable, but it needs to be.
-    ///
-    /// This function, like `poll_read`, is only safe to call from the context
-    /// of a future's task (typically in a `Future::poll` implementation). It
-    /// informs this readiness stream that the underlying object is no longer
-    /// readable, typically because a "would block" error was seen.
-    ///
-    /// *All* readiness bits associated with this stream except the writable bit
-    /// will be reset when this method is called. The current task is then
-    /// scheduled to receive a notification whenever anything changes other than
-    /// the writable bit. Note that this typically just means the readable bit
-    /// is used here, but if you're using a custom I/O object for events like
-    /// hup/error this may also be relevant.
-    ///
-    /// Note that it is also only valid to call this method if `poll_read`
-    /// previously indicated that the object is readable. That is, this function
-    /// must always be paired with calls to `poll_read` previously.
-    ///
-    /// # Errors
-    ///
-    /// This function will return an error if the `Reactor` that this `PollEvented`
-    /// is associated with has gone away (been destroyed). The error means that
-    /// the ambient futures task could not be scheduled to receive a
-    /// notification and typically means that the error should be propagated
-    /// outwards.
-    ///
-    /// # Panics
-    ///
-    /// This function will panic if called outside the context of a future's
-    /// task.
-    pub fn need_read(&mut self) -> io::Result<()> {
-        self.inner.read_readiness.store(0, Relaxed);
-
-        if self.poll_read().is_ready() {
-            // Notify the current task
-            task::current().notify();
-        }
-
-        Ok(())
-    }
-
-    /// Indicates to this source of events that the corresponding I/O object is
-    /// no longer writable, but it needs to be.
-    ///
-    /// This function, like `poll_write`, is only safe to call from the context
-    /// of a future's task (typically in a `Future::poll` implementation). It
-    /// informs this readiness stream that the underlying object is no longer
-    /// writable, typically because a "would block" error was seen.
-    ///
-    /// The flag indicating that this stream is writable is unset and the
-    /// current task is scheduled to receive a notification when the stream is
-    /// then again writable.
-    ///
-    /// Note that it is also only valid to call this method if `poll_write`
-    /// previously indicated that the object is writable. That is, this function
-    /// must always be paired with calls to `poll_write` previously.
-    ///
-    /// # Errors
-    ///
-    /// This function will return an error if the `Reactor` that this `PollEvented`
-    /// is associated with has gone away (been destroyed). The error means that
-    /// the ambient futures task could not be scheduled to receive a
-    /// notification and typically means that the error should be propagated
-    /// outwards.
-    ///
-    /// # Panics
-    ///
-    /// This function will panic if called outside the context of a future's
-    /// task.
-    pub fn need_write(&mut self) -> io::Result<()> {
-        self.inner.write_readiness.store(0, Relaxed);
-
-        if self.poll_write().is_ready() {
-            // Notify the current task
-            task::current().notify();
-        }
-
-        Ok(())
-    }
-
-    /// Returns a reference to the event loop handle that this readiness stream
-    /// is associated with.
-    pub fn handle(&self) -> &Handle {
-        &self.handle
-    }
-
-    /// Returns a shared reference to the underlying I/O object this readiness
-    /// stream is wrapping.
-    pub fn get_ref(&self) -> &E {
-        &self.io
-    }
-
-    /// Returns a mutable reference to the underlying I/O object this readiness
-    /// stream is wrapping.
-    pub fn get_mut(&mut self) -> &mut E {
-        &mut self.io
-    }
-
-    /// Consumes the `PollEvented` and returns the underlying I/O object
-    pub fn into_inner(self) -> E {
-        self.io
-    }
-
-    /// Deregisters this source of events from the reactor core specified.
-    ///
-    /// This method can optionally be called to unregister the underlying I/O
-    /// object with the event loop that the `handle` provided points to.
-    /// Typically this method is not required as this automatically happens when
-    /// `E` is dropped, but for some use cases the `E` object doesn't represent
-    /// an owned reference, so dropping it won't automatically unregister with
-    /// the event loop.
-    ///
-    /// This consumes `self` as it will no longer provide events after the
-    /// method is called, and will likely return an error if this `PollEvented`
-    /// was created on a separate event loop from the `handle` specified.
-    pub fn deregister(&self) -> io::Result<()>
-    where
-        E: Evented,
-    {
-        self.inner.registration.lock().unwrap().deregister(&self.io)
-    }
-}
-
-impl<E: Read> Read for PollEvented<E> {
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        if let Async::NotReady = self.poll_read() {
-            return Err(io::ErrorKind::WouldBlock.into());
-        }
-
-        let r = self.get_mut().read(buf);
-
-        if is_wouldblock(&r) {
-            self.need_read()?;
-        }
-
-        return r;
-    }
-}
-
-impl<E: Write> Write for PollEvented<E> {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        if let Async::NotReady = self.poll_write() {
-            return Err(io::ErrorKind::WouldBlock.into());
-        }
-
-        let r = self.get_mut().write(buf);
-
-        if is_wouldblock(&r) {
-            self.need_write()?;
-        }
-
-        return r;
-    }
-
-    fn flush(&mut self) -> io::Result<()> {
-        if let Async::NotReady = self.poll_write() {
-            return Err(io::ErrorKind::WouldBlock.into());
-        }
-
-        let r = self.get_mut().flush();
-
-        if is_wouldblock(&r) {
-            self.need_write()?;
-        }
-
-        return r;
-    }
-}
-
-impl<E: Read> AsyncRead for PollEvented<E> {}
-
-impl<E: Write> AsyncWrite for PollEvented<E> {
-    fn shutdown(&mut self) -> Poll<(), io::Error> {
-        Ok(().into())
-    }
-}
-
-fn is_wouldblock<T>(r: &io::Result<T>) -> bool {
-    match *r {
-        Ok(_) => false,
-        Err(ref e) => e.kind() == io::ErrorKind::WouldBlock,
-    }
-}
-
-const READ: usize = 1 << 0;
-const WRITE: usize = 1 << 1;
-
-fn ready2usize(ready: Ready) -> usize {
-    let mut bits = 0;
-    if ready.is_readable() {
-        bits |= READ;
-    }
-    if ready.is_writable() {
-        bits |= WRITE;
-    }
-    bits | platform::ready2usize(ready)
-}
-
-fn usize2ready(bits: usize) -> Ready {
-    let mut ready = Ready::empty();
-    if bits & READ != 0 {
-        ready.insert(Ready::readable());
-    }
-    if bits & WRITE != 0 {
-        ready.insert(Ready::writable());
-    }
-    ready | platform::usize2ready(bits)
-}
-
-#[cfg(unix)]
-mod platform {
-    use mio::unix::UnixReady;
-    use mio::Ready;
-
-    const HUP: usize = 1 << 2;
-    const ERROR: usize = 1 << 3;
-    const AIO: usize = 1 << 4;
-    const LIO: usize = 1 << 5;
-
-    #[cfg(any(target_os = "dragonfly", target_os = "freebsd"))]
-    fn is_aio(ready: &Ready) -> bool {
-        UnixReady::from(*ready).is_aio()
-    }
-
-    #[cfg(not(any(target_os = "dragonfly", target_os = "freebsd")))]
-    fn is_aio(_ready: &Ready) -> bool {
-        false
-    }
-
-    #[cfg(target_os = "freebsd")]
-    fn is_lio(ready: &Ready) -> bool {
-        UnixReady::from(*ready).is_lio()
-    }
-
-    #[cfg(not(target_os = "freebsd"))]
-    fn is_lio(_ready: &Ready) -> bool {
-        false
-    }
-
-    pub fn ready2usize(ready: Ready) -> usize {
-        let ready = UnixReady::from(ready);
-        let mut bits = 0;
-        if is_aio(&ready) {
-            bits |= AIO;
-        }
-        if is_lio(&ready) {
-            bits |= LIO;
-        }
-        if ready.is_error() {
-            bits |= ERROR;
-        }
-        if ready.is_hup() {
-            bits |= HUP;
-        }
-        bits
-    }
-
-    #[cfg(any(
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "ios",
-        target_os = "macos"
-    ))]
-    fn usize2ready_aio(ready: &mut UnixReady) {
-        ready.insert(UnixReady::aio());
-    }
-
-    #[cfg(not(any(
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "ios",
-        target_os = "macos"
-    )))]
-    fn usize2ready_aio(_ready: &mut UnixReady) {
-        // aio not available here → empty
-    }
-
-    #[cfg(target_os = "freebsd")]
-    fn usize2ready_lio(ready: &mut UnixReady) {
-        ready.insert(UnixReady::lio());
-    }
-
-    #[cfg(not(target_os = "freebsd"))]
-    fn usize2ready_lio(_ready: &mut UnixReady) {
-        // lio not available here → empty
-    }
-
-    pub fn usize2ready(bits: usize) -> Ready {
-        let mut ready = UnixReady::from(Ready::empty());
-        if bits & AIO != 0 {
-            usize2ready_aio(&mut ready);
-        }
-        if bits & LIO != 0 {
-            usize2ready_lio(&mut ready);
-        }
-        if bits & HUP != 0 {
-            ready.insert(UnixReady::hup());
-        }
-        if bits & ERROR != 0 {
-            ready.insert(UnixReady::error());
-        }
-        ready.into()
-    }
-}
-
-#[cfg(windows)]
-mod platform {
-    use mio::Ready;
-
-    pub fn all() -> Ready {
-        // No platform-specific Readinesses for Windows
-        Ready::empty()
-    }
-
-    pub fn hup() -> Ready {
-        Ready::empty()
-    }
-
-    pub fn ready2usize(_r: Ready) -> usize {
-        0
-    }
-
-    pub fn usize2ready(_r: usize) -> Ready {
-        Ready::empty()
-    }
-}

src/runtime/mod.rs

@@ -1,125 +0,0 @@
-//! A batteries included runtime for applications using Tokio.
-//!
-//! Applications using Tokio require some runtime support in order to work:
-//!
-//! * A [reactor] to drive I/O resources.
-//! * An [executor] to execute tasks that use these I/O resources.
-//! * A [timer] for scheduling work to run after a set period of time.
-//!
-//! While it is possible to setup each component manually, this involves a bunch
-//! of boilerplate.
-//!
-//! [`Runtime`] bundles all of these various runtime components into a single
-//! handle that can be started and shutdown together, eliminating the necessary
-//! boilerplate to run a Tokio application.
-//!
-//! Most applications wont need to use [`Runtime`] directly. Instead, they will
-//! use the [`run`] function, which uses [`Runtime`] under the hood.
-//!
-//! Creating a [`Runtime`] does the following:
-//!
-//! * Spawn a background thread running a [`Reactor`] instance.
-//! * Start a [`ThreadPool`] for executing futures.
-//! * Run an instance of [`Timer`] **per** thread pool worker thread.
-//!
-//! The thread pool uses a work-stealing strategy and is configured to start a
-//! worker thread for each CPU core available on the system. This tends to be
-//! the ideal setup for Tokio applications.
-//!
-//! A timer per thread pool worker thread is used to minimize the amount of
-//! synchronization that is required for working with the timer.
-//!
-//! # Usage
-//!
-//! Most applications will use the [`run`] function. This takes a future to
-//! "seed" the application, blocking the thread until the runtime becomes
-//! [idle].
-//!
-//! ```rust
-//! # extern crate tokio;
-//! # extern crate futures;
-//! # use futures::{Future, Stream};
-//! use tokio::net::TcpListener;
-//!
-//! # fn process<T>(_: T) -> Box<Future<Item = (), Error = ()> + Send> {
-//! # unimplemented!();
-//! # }
-//! # fn dox() {
-//! # let addr = "127.0.0.1:8080".parse().unwrap();
-//! let listener = TcpListener::bind(&addr).unwrap();
-//!
-//! let server = listener.incoming()
-//!     .map_err(|e| println!("error = {:?}", e))
-//!     .for_each(|socket| {
-//!         tokio::spawn(process(socket))
-//!     });
-//!
-//! tokio::run(server);
-//! # }
-//! # pub fn main() {}
-//! ```
-//!
-//! In this function, the `run` function blocks until the runtime becomes idle.
-//! See [`shutdown_on_idle`][idle] for more shutdown details.
-//!
-//! From within the context of the runtime, additional tasks are spawned using
-//! the [`tokio::spawn`] function. Futures spawned using this function will be
-//! executed on the same thread pool used by the [`Runtime`].
-//!
-//! A [`Runtime`] instance can also be used directly.
-//!
-//! ```rust
-//! # extern crate tokio;
-//! # extern crate futures;
-//! # use futures::{Future, Stream};
-//! use tokio::runtime::Runtime;
-//! use tokio::net::TcpListener;
-//!
-//! # fn process<T>(_: T) -> Box<Future<Item = (), Error = ()> + Send> {
-//! # unimplemented!();
-//! # }
-//! # fn dox() {
-//! # let addr = "127.0.0.1:8080".parse().unwrap();
-//! let listener = TcpListener::bind(&addr).unwrap();
-//!
-//! let server = listener.incoming()
-//!     .map_err(|e| println!("error = {:?}", e))
-//!     .for_each(|socket| {
-//!         tokio::spawn(process(socket))
-//!     });
-//!
-//! // Create the runtime
-//! let mut rt = Runtime::new().unwrap();
-//!
-//! // Spawn the server task
-//! rt.spawn(server);
-//!
-//! // Wait until the runtime becomes idle and shut it down.
-//! rt.shutdown_on_idle()
-//!     .wait().unwrap();
-//! # }
-//! # pub fn main() {}
-//! ```
-//!
-//! [reactor]: ../reactor/struct.Reactor.html
-//! [executor]: https://tokio.rs/docs/getting-started/runtime-model/#executors
-//! [timer]: ../timer/index.html
-//! [`Runtime`]: struct.Runtime.html
-//! [`Reactor`]: ../reactor/struct.Reactor.html
-//! [`ThreadPool`]: https://docs.rs/tokio-threadpool/0.1/tokio_threadpool/struct.ThreadPool.html
-//! [`run`]: fn.run.html
-//! [idle]: struct.Runtime.html#method.shutdown_on_idle
-//! [`tokio::spawn`]: ../executor/fn.spawn.html
-//! [`Timer`]: https://docs.rs/tokio-timer/0.2/tokio_timer/timer/struct.Timer.html
-
-pub mod current_thread;
-mod threadpool;
-
-pub use self::threadpool::{
-    Builder,
-    Runtime,
-    Shutdown,
-    TaskExecutor,
-    run,
-};
-

src/runtime/threadpool/mod.rs

@@ -1,395 +0,0 @@
-mod builder;
-mod shutdown;
-mod task_executor;
-
-pub use self::builder::Builder;
-pub use self::shutdown::Shutdown;
-pub use self::task_executor::TaskExecutor;
-
-use reactor::{Handle, Reactor};
-
-use std::io;
-use std::sync::Mutex;
-
-use tokio_executor::enter;
-use tokio_threadpool as threadpool;
-
-use futures;
-use futures::future::Future;
-
-/// Handle to the Tokio runtime.
-///
-/// The Tokio runtime includes a reactor as well as an executor for running
-/// tasks.
-///
-/// Instances of `Runtime` can be created using [`new`] or [`Builder`]. However,
-/// most users will use [`tokio::run`], which uses a `Runtime` internally.
-///
-/// See [module level][mod] documentation for more details.
-///
-/// [mod]: index.html
-/// [`new`]: #method.new
-/// [`Builder`]: struct.Builder.html
-/// [`tokio::run`]: fn.run.html
-#[derive(Debug)]
-pub struct Runtime {
-    inner: Option<Inner>,
-}
-
-#[derive(Debug)]
-struct Inner {
-    /// A handle to the reactor in the background thread.
-    reactor_handle: Handle,
-
-    // TODO: This should go away in 0.2
-    reactor: Mutex<Option<Reactor>>,
-
-    /// Task execution pool.
-    pool: threadpool::ThreadPool,
-}
-
-// ===== impl Runtime =====
-
-/// Start the Tokio runtime using the supplied future to bootstrap execution.
-///
-/// This function is used to bootstrap the execution of a Tokio application. It
-/// does the following:
-///
-/// * Start the Tokio runtime using a default configuration.
-/// * Spawn the given future onto the thread pool.
-/// * Block the current thread until the runtime shuts down.
-///
-/// Note that the function will not return immediately once `future` has
-/// completed. Instead it waits for the entire runtime to become idle.
-///
-/// See the [module level][mod] documentation for more details.
-///
-/// # Examples
-///
-/// ```rust
-/// # extern crate tokio;
-/// # extern crate futures;
-/// # use futures::{Future, Stream};
-/// use tokio::net::TcpListener;
-///
-/// # fn process<T>(_: T) -> Box<Future<Item = (), Error = ()> + Send> {
-/// # unimplemented!();
-/// # }
-/// # fn dox() {
-/// # let addr = "127.0.0.1:8080".parse().unwrap();
-/// let listener = TcpListener::bind(&addr).unwrap();
-///
-/// let server = listener.incoming()
-///     .map_err(|e| println!("error = {:?}", e))
-///     .for_each(|socket| {
-///         tokio::spawn(process(socket))
-///     });
-///
-/// tokio::run(server);
-/// # }
-/// # pub fn main() {}
-/// ```
-///
-/// # Panics
-///
-/// This function panics if called from the context of an executor.
-///
-/// [mod]: ../index.html
-pub fn run<F>(future: F)
-where F: Future<Item = (), Error = ()> + Send + 'static,
-{
-    // Check enter before creating a new Runtime...
-    let mut entered = enter().expect("nested tokio::run");
-    let mut runtime = Runtime::new().expect("failed to start new Runtime");
-    runtime.spawn(future);
-    entered
-        .block_on(runtime.shutdown_on_idle())
-        .expect("shutdown cannot error")
-}
-
-impl Runtime {
-    /// Create a new runtime instance with default configuration values.
-    ///
-    /// This results in a reactor, thread pool, and timer being initialized. The
-    /// thread pool will not spawn any worker threads until it needs to, i.e.
-    /// tasks are scheduled to run.
-    ///
-    /// Most users will not need to call this function directly, instead they
-    /// will use [`tokio::run`](fn.run.html).
-    ///
-    /// See [module level][mod] documentation for more details.
-    ///
-    /// # Examples
-    ///
-    /// Creating a new `Runtime` with default configuration values.
-    ///
-    /// ```
-    /// use tokio::runtime::Runtime;
-    /// use tokio::prelude::*;
-    ///
-    /// let rt = Runtime::new()
-    ///     .unwrap();
-    ///
-    /// // Use the runtime...
-    ///
-    /// // Shutdown the runtime
-    /// rt.shutdown_now()
-    ///     .wait().unwrap();
-    /// ```
-    ///
-    /// [mod]: index.html
-    pub fn new() -> io::Result<Self> {
-        Builder::new().build()
-    }
-
-    #[deprecated(since = "0.1.5", note = "use `reactor` instead")]
-    #[doc(hidden)]
-    pub fn handle(&self) -> &Handle {
-        #[allow(deprecated)]
-        self.reactor()
-    }
-
-    /// Return a reference to the reactor handle for this runtime instance.
-    ///
-    /// The returned handle reference can be cloned in order to get an owned
-    /// value of the handle. This handle can be used to initialize I/O resources
-    /// (like TCP or UDP sockets) that will not be used on the runtime.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use tokio::runtime::Runtime;
-    ///
-    /// let rt = Runtime::new()
-    ///     .unwrap();
-    ///
-    /// let reactor_handle = rt.reactor().clone();
-    ///
-    /// // use `reactor_handle`
-    /// ```
-    #[deprecated(since = "0.1.11", note = "there is now a reactor per worker thread")]
-    pub fn reactor(&self) -> &Handle {
-        let mut reactor = self.inner().reactor.lock().unwrap();
-        if let Some(reactor) = reactor.take() {
-            if let Ok(background) = reactor.background() {
-                background.forget();
-            }
-        }
-
-        &self.inner().reactor_handle
-    }
-
-    /// Return a handle to the runtime's executor.
-    ///
-    /// The returned handle can be used to spawn tasks that run on this runtime.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use tokio::runtime::Runtime;
-    ///
-    /// let rt = Runtime::new()
-    ///     .unwrap();
-    ///
-    /// let executor_handle = rt.executor();
-    ///
-    /// // use `executor_handle`
-    /// ```
-    pub fn executor(&self) -> TaskExecutor {
-        let inner = self.inner().pool.sender().clone();
-        TaskExecutor { inner }
-    }
-
-    /// Spawn a future onto the Tokio runtime.
-    ///
-    /// This spawns the given future onto the runtime's executor, usually a
-    /// thread pool. The thread pool is then responsible for polling the future
-    /// until it completes.
-    ///
-    /// See [module level][mod] documentation for more details.
-    ///
-    /// [mod]: index.html
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # extern crate tokio;
-    /// # extern crate futures;
-    /// # use futures::{future, Future, Stream};
-    /// use tokio::runtime::Runtime;
-    ///
-    /// # fn dox() {
-    /// // Create the runtime
-    /// let mut rt = Runtime::new().unwrap();
-    ///
-    /// // Spawn a future onto the runtime
-    /// rt.spawn(future::lazy(|| {
-    ///     println!("now running on a worker thread");
-    ///     Ok(())
-    /// }));
-    /// # }
-    /// # pub fn main() {}
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if the spawn fails. Failure occurs if the executor
-    /// is currently at capacity and is unable to spawn a new future.
-    pub fn spawn<F>(&mut self, future: F) -> &mut Self
-    where F: Future<Item = (), Error = ()> + Send + 'static,
-    {
-        self.inner_mut().pool.sender().spawn(future).unwrap();
-        self
-    }
-
-    /// Run a future to completion on the Tokio runtime.
-    ///
-    /// This runs the given future on the runtime, blocking until it is
-    /// complete, and yielding its resolved result. Any tasks or timers which
-    /// the future spawns internally will be executed on the runtime.
-    ///
-    /// This method should not be called from an asynchronous context.
-    ///
-    /// # Panics
-    ///
-    /// This function panics if the executor is at capacity, if the provided
-    /// future panics, or if called within an asynchronous execution context.
-    pub fn block_on<F, R, E>(&mut self, future: F) -> Result<R, E>
-    where
-        F: Send + 'static + Future<Item = R, Error = E>,
-        R: Send + 'static,
-        E: Send + 'static,
-    {
-        let mut entered = enter().expect("nested block_on");
-        let (tx, rx) = futures::sync::oneshot::channel();
-        self.spawn(future.then(move |r| tx.send(r).map_err(|_| unreachable!())));
-        entered.block_on(rx).unwrap()
-    }
-
-    /// Run a future to completion on the Tokio runtime, then wait for all
-    /// background futures to complete too.
-    ///
-    /// This runs the given future on the runtime, blocking until it is
-    /// complete, waiting for background futures to complete, and yielding
-    /// its resolved result. Any tasks or timers which the future spawns
-    /// internally will be executed on the runtime and waited for completion.
-    ///
-    /// This method should not be called from an asynchronous context.
-    ///
-    /// # Panics
-    ///
-    /// This function panics if the executor is at capacity, if the provided
-    /// future panics, or if called within an asynchronous execution context.
-    pub fn block_on_all<F, R, E>(mut self, future: F) -> Result<R, E>
-    where
-        F: Send + 'static + Future<Item = R, Error = E>,
-        R: Send + 'static,
-        E: Send + 'static,
-    {
-        let mut entered = enter().expect("nested block_on_all");
-        let (tx, rx) = futures::sync::oneshot::channel();
-        self.spawn(future.then(move |r| tx.send(r).map_err(|_| unreachable!())));
-        let block = rx
-            .map_err(|_| unreachable!())
-            .and_then(move |r| {
-                self.shutdown_on_idle()
-                    .map(move |()| r)
-            });
-        entered.block_on(block).unwrap()
-    }
-
-    /// Signals the runtime to shutdown once it becomes idle.
-    ///
-    /// Returns a future that completes once the shutdown operation has
-    /// completed.
-    ///
-    /// This function can be used to perform a graceful shutdown of the runtime.
-    ///
-    /// The runtime enters an idle state once **all** of the following occur.
-    ///
-    /// * The thread pool has no tasks to execute, i.e., all tasks that were
-    ///   spawned have completed.
-    /// * The reactor is not managing any I/O resources.
-    ///
-    /// See [module level][mod] documentation for more details.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use tokio::runtime::Runtime;
-    /// use tokio::prelude::*;
-    ///
-    /// let rt = Runtime::new()
-    ///     .unwrap();
-    ///
-    /// // Use the runtime...
-    ///
-    /// // Shutdown the runtime
-    /// rt.shutdown_on_idle()
-    ///     .wait().unwrap();
-    /// ```
-    ///
-    /// [mod]: index.html
-    pub fn shutdown_on_idle(mut self) -> Shutdown {
-        let inner = self.inner.take().unwrap();
-        let inner = inner.pool.shutdown_on_idle();
-        Shutdown { inner }
-    }
-
-    /// Signals the runtime to shutdown immediately.
-    ///
-    /// Returns a future that completes once the shutdown operation has
-    /// completed.
-    ///
-    /// This function will forcibly shutdown the runtime, causing any
-    /// in-progress work to become canceled. The shutdown steps are:
-    ///
-    /// * Drain any scheduled work queues.
-    /// * Drop any futures that have not yet completed.
-    /// * Drop the reactor.
-    ///
-    /// Once the reactor has dropped, any outstanding I/O resources bound to
-    /// that reactor will no longer function. Calling any method on them will
-    /// result in an error.
-    ///
-    /// See [module level][mod] documentation for more details.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use tokio::runtime::Runtime;
-    /// use tokio::prelude::*;
-    ///
-    /// let rt = Runtime::new()
-    ///     .unwrap();
-    ///
-    /// // Use the runtime...
-    ///
-    /// // Shutdown the runtime
-    /// rt.shutdown_now()
-    ///     .wait().unwrap();
-    /// ```
-    ///
-    /// [mod]: index.html
-    pub fn shutdown_now(mut self) -> Shutdown {
-        let inner = self.inner.take().unwrap();
-        Shutdown::shutdown_now(inner)
-    }
-
-    fn inner(&self) -> &Inner {
-        self.inner.as_ref().unwrap()
-    }
-
-    fn inner_mut(&mut self) -> &mut Inner {
-        self.inner.as_mut().unwrap()
-    }
-}
-
-impl Drop for Runtime {
-    fn drop(&mut self) {
-        if let Some(inner) = self.inner.take() {
-            let shutdown = Shutdown::shutdown_now(inner);
-            let _ = shutdown.wait();
-        }
-    }
-}

src/runtime/threadpool/shutdown.rs

@@ -1,36 +0,0 @@
-use super::Inner;
-use tokio_threadpool as threadpool;
-
-use std::fmt;
-
-use futures::{Future, Poll};
-
-/// A future that resolves when the Tokio `Runtime` is shut down.
-pub struct Shutdown {
-    pub(super) inner: threadpool::Shutdown,
-}
-
-impl Shutdown {
-    pub(super) fn shutdown_now(inner: Inner) -> Self {
-        let inner = inner.pool.shutdown_now();
-        Shutdown { inner }
-    }
-}
-
-impl Future for Shutdown {
-    type Item = ();
-    type Error = ();
-
-    fn poll(&mut self) -> Poll<(), ()> {
-        try_ready!(self.inner.poll());
-        Ok(().into())
-    }
-}
-
-impl fmt::Debug for Shutdown {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        fmt.debug_struct("Shutdown")
-            .field("inner", &"Box<Future<Item = (), Error = ()>>")
-            .finish()
-    }
-}

src/util/enumerate.rs

@@ -1,84 +0,0 @@
-use futures::{Async, Poll, Sink, StartSend, Stream};
-
-/// A stream combinator which combines the yields the current item
-/// plus its count starting from 0.
-///
-/// This structure is produced by the `Stream::enumerate` method.
-#[derive(Debug)]
-#[must_use = "Does nothing unless polled"]
-pub struct Enumerate<T> {
-    inner: T,
-    count: usize,
-}
-
-impl<T> Enumerate<T> {
-    pub(crate) fn new(stream: T) -> Self {
-        Self {
-            inner: stream,
-            count: 0,
-        }
-    }
-
-    /// Acquires a reference to the underlying stream that this combinator is
-    /// pulling from.
-    pub fn get_ref(&self) -> &T {
-        &self.inner
-    }
-
-    /// Acquires a mutable reference to the underlying stream that this
-    /// combinator is pulling from.
-    ///
-    /// Note that care must be taken to avoid tampering with the state of the
-    /// stream which may otherwise confuse this combinator.
-    pub fn get_mut(&mut self) -> &mut T {
-        &mut self.inner
-    }
-
-    /// Consumes this combinator, returning the underlying stream.
-    ///
-    /// Note that this may discard intermediate state of this combinator, so
-    /// care should be taken to avoid losing resources when this is called.
-    pub fn into_inner(self) -> T {
-        self.inner
-    }
-}
-
-impl<T> Stream for Enumerate<T>
-where
-    T: Stream,
-{
-    type Item = (usize, T::Item);
-    type Error = T::Error;
-
-    fn poll(&mut self) -> Poll<Option<Self::Item>, T::Error> {
-        match try_ready!(self.inner.poll()) {
-            Some(item) => {
-                let ret = Some((self.count, item));
-                self.count += 1;
-                Ok(Async::Ready(ret))
-            }
-            None => return Ok(Async::Ready(None)),
-        }
-    }
-}
-
-// Forwarding impl of Sink from the underlying stream
-impl<T> Sink for Enumerate<T>
-where
-    T: Sink,
-{
-    type SinkItem = T::SinkItem;
-    type SinkError = T::SinkError;
-
-    fn start_send(&mut self, item: T::SinkItem) -> StartSend<T::SinkItem, T::SinkError> {
-        self.inner.start_send(item)
-    }
-
-    fn poll_complete(&mut self) -> Poll<(), T::SinkError> {
-        self.inner.poll_complete()
-    }
-
-    fn close(&mut self) -> Poll<(), T::SinkError> {
-        self.inner.close()
-    }
-}

src/util/mod.rs

@@ -1,15 +0,0 @@
-//! Utilities for working with Tokio.
-//!
-//! This module contains utilities that are useful for working with Tokio.
-//! Currently, this only includes [`FutureExt`] and [`StreamExt`], but this
-//! may grow over time.
-//!
-//! [`FutureExt`]: trait.FutureExt.html
-//! [`StreamExt`]: trait.StreamExt.html
-
-mod enumerate;
-mod future;
-mod stream;
-
-pub use self::future::FutureExt;
-pub use self::stream::StreamExt;

tests/buffered.rs

@@ -1,65 +0,0 @@
-extern crate env_logger;
-extern crate futures;
-extern crate tokio;
-extern crate tokio_io;
-
-use std::io::{BufReader, BufWriter, Read, Write};
-use std::net::TcpStream;
-use std::thread;
-
-use futures::stream::Stream;
-use futures::Future;
-use tokio::net::TcpListener;
-use tokio_io::io::copy;
-
-macro_rules! t {
-    ($e:expr) => {
-        match $e {
-            Ok(e) => e,
-            Err(e) => panic!("{} failed with {:?}", stringify!($e), e),
-        }
-    };
-}
-
-#[test]
-fn echo_server() {
-    const N: usize = 1024;
-    drop(env_logger::try_init());
-
-    let srv = t!(TcpListener::bind(&t!("127.0.0.1:0".parse())));
-    let addr = t!(srv.local_addr());
-
-    let msg = "foo bar baz";
-    let t = thread::spawn(move || {
-        let mut s = t!(TcpStream::connect(&addr));
-
-        let t2 = thread::spawn(move || {
-            let mut s = t!(TcpStream::connect(&addr));
-            let mut b = vec![0; msg.len() * N];
-            t!(s.read_exact(&mut b));
-            b
-        });
-
-        let mut expected = Vec::<u8>::new();
-        for _i in 0..N {
-            expected.extend(msg.as_bytes());
-            assert_eq!(t!(s.write(msg.as_bytes())), msg.len());
-        }
-        (expected, t2)
-    });
-
-    let clients = srv.incoming().take(2).collect();
-    let copied = clients.and_then(|clients| {
-        let mut clients = clients.into_iter();
-        let a = BufReader::new(clients.next().unwrap());
-        let b = BufWriter::new(clients.next().unwrap());
-        copy(a, b)
-    });
-
-    let (amt, _, _) = t!(copied.wait());
-    let (expected, t2) = t.join().unwrap();
-    let actual = t2.join().unwrap();
-
-    assert!(expected == actual);
-    assert_eq!(amt, msg.len() as u64 * 1024);
-}

tests/clock.rs

@@ -1,64 +0,0 @@
-extern crate env_logger;
-extern crate futures;
-extern crate tokio;
-extern crate tokio_timer;
-
-use tokio::prelude::*;
-use tokio::runtime::{self, current_thread};
-use tokio::timer::*;
-use tokio_timer::clock::Clock;
-
-use std::sync::mpsc;
-use std::time::{Duration, Instant};
-
-struct MockNow(Instant);
-
-impl tokio_timer::clock::Now for MockNow {
-    fn now(&self) -> Instant {
-        self.0
-    }
-}
-
-#[test]
-fn clock_and_timer_concurrent() {
-    let _ = env_logger::try_init();
-
-    let when = Instant::now() + Duration::from_millis(5_000);
-    let clock = Clock::new_with_now(MockNow(when));
-
-    let mut rt = runtime::Builder::new().clock(clock).build().unwrap();
-
-    let (tx, rx) = mpsc::channel();
-
-    rt.spawn({
-        Delay::new(when)
-            .map_err(|e| panic!("unexpected error; err={:?}", e))
-            .and_then(move |_| {
-                assert!(Instant::now() < when);
-                tx.send(()).unwrap();
-                Ok(())
-            })
-    });
-
-    rx.recv().unwrap();
-}
-
-#[test]
-fn clock_and_timer_single_threaded() {
-    let _ = env_logger::try_init();
-
-    let when = Instant::now() + Duration::from_millis(5_000);
-    let clock = Clock::new_with_now(MockNow(when));
-
-    let mut rt = current_thread::Builder::new().clock(clock).build().unwrap();
-
-    rt.block_on({
-        Delay::new(when)
-            .map_err(|e| panic!("unexpected error; err={:?}", e))
-            .and_then(move |_| {
-                assert!(Instant::now() < when);
-                Ok(())
-            })
-    })
-    .unwrap();
-}

tests/drop-core.rs

@@ -1,42 +0,0 @@
-extern crate futures;
-extern crate tokio;
-
-use std::net;
-use std::thread;
-
-use futures::future;
-use futures::prelude::*;
-use futures::sync::oneshot;
-use tokio::net::TcpListener;
-use tokio::reactor::Reactor;
-
-#[test]
-fn tcp_doesnt_block() {
-    let core = Reactor::new().unwrap();
-    let handle = core.handle();
-    let listener = net::TcpListener::bind("127.0.0.1:0").unwrap();
-    let listener = TcpListener::from_std(listener, &handle).unwrap();
-    drop(core);
-    assert!(listener.incoming().wait().next().unwrap().is_err());
-}
-
-#[test]
-fn drop_wakes() {
-    let core = Reactor::new().unwrap();
-    let handle = core.handle();
-    let listener = net::TcpListener::bind("127.0.0.1:0").unwrap();
-    let listener = TcpListener::from_std(listener, &handle).unwrap();
-    let (tx, rx) = oneshot::channel::<()>();
-    let t = thread::spawn(move || {
-        let incoming = listener.incoming();
-        let new_socket = incoming.into_future().map_err(|_| ());
-        let drop_tx = future::lazy(|| {
-            drop(tx);
-            future::ok(())
-        });
-        assert!(new_socket.join(drop_tx).wait().is_err());
-    });
-    drop(rx.wait());
-    drop(core);
-    t.join().unwrap();
-}

tests/enumerate.rs

@@ -1,26 +0,0 @@
-extern crate futures;
-extern crate tokio;
-extern crate tokio_executor;
-extern crate tokio_timer;
-
-use futures::sync::mpsc;
-use tokio::util::StreamExt;
-
-#[test]
-fn enumerate() {
-    use futures::*;
-
-    let (mut tx, rx) = mpsc::channel(1);
-
-    std::thread::spawn(|| {
-        for i in 0..5 {
-            tx = tx.send(i * 2).wait().unwrap();
-        }
-    });
-
-    let result = rx.enumerate().collect();
-    assert_eq!(
-        result.wait(),
-        Ok(vec![(0, 0), (1, 2), (2, 4), (3, 6), (4, 8)])
-    );
-}

tests/global.rs

@@ -1,141 +0,0 @@
-extern crate env_logger;
-extern crate futures;
-extern crate tokio;
-extern crate tokio_io;
-
-use std::sync::atomic::AtomicUsize;
-use std::sync::atomic::Ordering::Relaxed;
-use std::sync::Arc;
-use std::{io, thread};
-
-use futures::prelude::*;
-use tokio::net::{TcpListener, TcpStream};
-use tokio::runtime::Runtime;
-
-macro_rules! t {
-    ($e:expr) => {
-        match $e {
-            Ok(e) => e,
-            Err(e) => panic!("{} failed with {:?}", stringify!($e), e),
-        }
-    };
-}
-
-#[test]
-fn hammer_old() {
-    let _ = env_logger::try_init();
-
-    let threads = (0..10)
-        .map(|_| {
-            thread::spawn(|| {
-                let srv = t!(TcpListener::bind(&"127.0.0.1:0".parse().unwrap()));
-                let addr = t!(srv.local_addr());
-                let mine = TcpStream::connect(&addr);
-                let theirs = srv
-                    .incoming()
-                    .into_future()
-                    .map(|(s, _)| s.unwrap())
-                    .map_err(|(s, _)| s);
-                let (mine, theirs) = t!(mine.join(theirs).wait());
-
-                assert_eq!(t!(mine.local_addr()), t!(theirs.peer_addr()));
-                assert_eq!(t!(theirs.local_addr()), t!(mine.peer_addr()));
-            })
-        })
-        .collect::<Vec<_>>();
-    for thread in threads {
-        thread.join().unwrap();
-    }
-}
-
-struct Rd(Arc<TcpStream>);
-struct Wr(Arc<TcpStream>);
-
-impl io::Read for Rd {
-    fn read(&mut self, dst: &mut [u8]) -> io::Result<usize> {
-        <&TcpStream>::read(&mut &*self.0, dst)
-    }
-}
-
-impl tokio_io::AsyncRead for Rd {}
-
-impl io::Write for Wr {
-    fn write(&mut self, src: &[u8]) -> io::Result<usize> {
-        <&TcpStream>::write(&mut &*self.0, src)
-    }
-
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-impl tokio_io::AsyncWrite for Wr {
-    fn shutdown(&mut self) -> Poll<(), io::Error> {
-        Ok(().into())
-    }
-}
-
-#[test]
-fn hammer_split() {
-    use tokio_io::io;
-
-    const N: usize = 100;
-    const ITER: usize = 10;
-
-    let _ = env_logger::try_init();
-
-    for _ in 0..ITER {
-        let srv = t!(TcpListener::bind(&"127.0.0.1:0".parse().unwrap()));
-        let addr = t!(srv.local_addr());
-
-        let cnt = Arc::new(AtomicUsize::new(0));
-
-        let mut rt = Runtime::new().unwrap();
-
-        fn split(socket: TcpStream, cnt: Arc<AtomicUsize>) {
-            let socket = Arc::new(socket);
-            let rd = Rd(socket.clone());
-            let wr = Wr(socket);
-
-            let cnt2 = cnt.clone();
-
-            let rd = io::read(rd, vec![0; 1])
-                .map(move |_| {
-                    cnt2.fetch_add(1, Relaxed);
-                })
-                .map_err(|e| panic!("read error = {:?}", e));
-
-            let wr = io::write_all(wr, b"1")
-                .map(move |_| {
-                    cnt.fetch_add(1, Relaxed);
-                })
-                .map_err(move |e| panic!("write error = {:?}", e));
-
-            tokio::spawn(rd);
-            tokio::spawn(wr);
-        }
-
-        rt.spawn({
-            let cnt = cnt.clone();
-            srv.incoming()
-                .map_err(|e| panic!("accept error = {:?}", e))
-                .take(N as u64)
-                .for_each(move |socket| {
-                    split(socket, cnt.clone());
-                    Ok(())
-                })
-        });
-
-        for _ in 0..N {
-            rt.spawn({
-                let cnt = cnt.clone();
-                TcpStream::connect(&addr)
-                    .map_err(move |e| panic!("connect error = {:?}", e))
-                    .map(move |socket| split(socket, cnt))
-            });
-        }
-
-        rt.shutdown_on_idle().wait().unwrap();
-        assert_eq!(N * 4, cnt.load(Relaxed));
-    }
-}

tests/length_delimited.rs

@@ -1,627 +0,0 @@
-extern crate bytes;
-extern crate futures;
-extern crate tokio;
-
-use tokio::codec::*;
-use tokio::io::{AsyncRead, AsyncWrite};
-
-use bytes::{BufMut, Bytes, BytesMut};
-use futures::Async::*;
-use futures::{Poll, Sink, Stream};
-
-use std::collections::VecDeque;
-use std::io;
-
-macro_rules! mock {
-    ($($x:expr,)*) => {{
-        let mut v = VecDeque::new();
-        v.extend(vec![$($x),*]);
-        Mock { calls: v }
-    }};
-}
-
-#[test]
-fn read_empty_io_yields_nothing() {
-    let mut io = FramedRead::new(mock!(), LengthDelimitedCodec::new());
-
-    assert_eq!(io.poll().unwrap(), Ready(None));
-}
-
-#[test]
-fn read_single_frame_one_packet() {
-    let mut io = FramedRead::new(
-        mock! {
-            Ok(b"\x00\x00\x00\x09abcdefghi"[..].into()),
-        },
-        LengthDelimitedCodec::new(),
-    );
-
-    assert_eq!(io.poll().unwrap(), Ready(Some(b"abcdefghi"[..].into())));
-    assert_eq!(io.poll().unwrap(), Ready(None));
-}
-
-#[test]
-fn read_single_frame_one_packet_little_endian() {
-    let mut io = length_delimited::Builder::new()
-        .little_endian()
-        .new_read(mock! {
-            Ok(b"\x09\x00\x00\x00abcdefghi"[..].into()),
-        });
-
-    assert_eq!(io.poll().unwrap(), Ready(Some(b"abcdefghi"[..].into())));
-    assert_eq!(io.poll().unwrap(), Ready(None));
-}
-
-#[test]
-fn read_single_frame_one_packet_native_endian() {
-    let data = if cfg!(target_endian = "big") {
-        b"\x00\x00\x00\x09abcdefghi"
-    } else {
-        b"\x09\x00\x00\x00abcdefghi"
-    };
-    let mut io = length_delimited::Builder::new()
-        .native_endian()
-        .new_read(mock! {
-            Ok(data[..].into()),
-        });
-
-    assert_eq!(io.poll().unwrap(), Ready(Some(b"abcdefghi"[..].into())));
-    assert_eq!(io.poll().unwrap(), Ready(None));
-}
-
-#[test]
-fn read_single_multi_frame_one_packet() {
-    let mut data: Vec<u8> = vec![];
-    data.extend_from_slice(b"\x00\x00\x00\x09abcdefghi");
-    data.extend_from_slice(b"\x00\x00\x00\x03123");
-    data.extend_from_slice(b"\x00\x00\x00\x0bhello world");
-
-    let mut io = FramedRead::new(
-        mock! {
-            Ok(data.into()),
-        },
-        LengthDelimitedCodec::new(),
-    );
-
-    assert_eq!(io.poll().unwrap(), Ready(Some(b"abcdefghi"[..].into())));
-    assert_eq!(io.poll().unwrap(), Ready(Some(b"123"[..].into())));
-    assert_eq!(io.poll().unwrap(), Ready(Some(b"hello world"[..].into())));
-    assert_eq!(io.poll().unwrap(), Ready(None));
-}
-
-#[test]
-fn read_single_frame_multi_packet() {
-    let mut io = FramedRead::new(
-        mock! {
-            Ok(b"\x00\x00"[..].into()),
-            Ok(b"\x00\x09abc"[..].into()),
-            Ok(b"defghi"[..].into()),
-        },
-        LengthDelimitedCodec::new(),
-    );
-
-    assert_eq!(io.poll().unwrap(), Ready(Some(b"abcdefghi"[..].into())));
-    assert_eq!(io.poll().unwrap(), Ready(None));
-}
-
-#[test]
-fn read_multi_frame_multi_packet() {
-    let mut io = FramedRead::new(
-        mock! {
-            Ok(b"\x00\x00"[..].into()),
-            Ok(b"\x00\x09abc"[..].into()),
-            Ok(b"defghi"[..].into()),
-            Ok(b"\x00\x00\x00\x0312"[..].into()),
-            Ok(b"3\x00\x00\x00\x0bhello world"[..].into()),
-        },
-        LengthDelimitedCodec::new(),
-    );
-
-    assert_eq!(io.poll().unwrap(), Ready(Some(b"abcdefghi"[..].into())));
-    assert_eq!(io.poll().unwrap(), Ready(Some(b"123"[..].into())));
-    assert_eq!(io.poll().unwrap(), Ready(Some(b"hello world"[..].into())));
-    assert_eq!(io.poll().unwrap(), Ready(None));
-}
-
-#[test]
-fn read_single_frame_multi_packet_wait() {
-    let mut io = FramedRead::new(
-        mock! {
-            Ok(b"\x00\x00"[..].into()),
-            Err(would_block()),
-            Ok(b"\x00\x09abc"[..].into()),
-            Err(would_block()),
-            Ok(b"defghi"[..].into()),
-            Err(would_block()),
-        },
-        LengthDelimitedCodec::new(),
-    );
-
-    assert_eq!(io.poll().unwrap(), NotReady);
-    assert_eq!(io.poll().unwrap(), NotReady);
-    assert_eq!(io.poll().unwrap(), Ready(Some(b"abcdefghi"[..].into())));
-    assert_eq!(io.poll().unwrap(), NotReady);
-    assert_eq!(io.poll().unwrap(), Ready(None));
-}
-
-#[test]
-fn read_multi_frame_multi_packet_wait() {
-    let mut io = FramedRead::new(
-        mock! {
-            Ok(b"\x00\x00"[..].into()),
-            Err(would_block()),
-            Ok(b"\x00\x09abc"[..].into()),
-            Err(would_block()),
-            Ok(b"defghi"[..].into()),
-            Err(would_block()),
-            Ok(b"\x00\x00\x00\x0312"[..].into()),
-            Err(would_block()),
-            Ok(b"3\x00\x00\x00\x0bhello world"[..].into()),
-            Err(would_block()),
-        },
-        LengthDelimitedCodec::new(),
-    );
-
-    assert_eq!(io.poll().unwrap(), NotReady);
-    assert_eq!(io.poll().unwrap(), NotReady);
-    assert_eq!(io.poll().unwrap(), Ready(Some(b"abcdefghi"[..].into())));
-    assert_eq!(io.poll().unwrap(), NotReady);
-    assert_eq!(io.poll().unwrap(), NotReady);
-    assert_eq!(io.poll().unwrap(), Ready(Some(b"123"[..].into())));
-    assert_eq!(io.poll().unwrap(), Ready(Some(b"hello world"[..].into())));
-    assert_eq!(io.poll().unwrap(), NotReady);
-    assert_eq!(io.poll().unwrap(), Ready(None));
-}
-
-#[test]
-fn read_incomplete_head() {
-    let mut io = FramedRead::new(
-        mock! {
-            Ok(b"\x00\x00"[..].into()),
-        },
-        LengthDelimitedCodec::new(),
-    );
-
-    assert!(io.poll().is_err());
-}
-
-#[test]
-fn read_incomplete_head_multi() {
-    let mut io = FramedRead::new(
-        mock! {
-            Err(would_block()),
-            Ok(b"\x00"[..].into()),
-            Err(would_block()),
-        },
-        LengthDelimitedCodec::new(),
-    );
-
-    assert_eq!(io.poll().unwrap(), NotReady);
-    assert_eq!(io.poll().unwrap(), NotReady);
-    assert!(io.poll().is_err());
-}
-
-#[test]
-fn read_incomplete_payload() {
-    let mut io = FramedRead::new(
-        mock! {
-            Ok(b"\x00\x00\x00\x09ab"[..].into()),
-            Err(would_block()),
-            Ok(b"cd"[..].into()),
-            Err(would_block()),
-        },
-        LengthDelimitedCodec::new(),
-    );
-
-    assert_eq!(io.poll().unwrap(), NotReady);
-    assert_eq!(io.poll().unwrap(), NotReady);
-    assert!(io.poll().is_err());
-}
-
-#[test]
-fn read_max_frame_len() {
-    let mut io = length_delimited::Builder::new()
-        .max_frame_length(5)
-        .new_read(mock! {
-            Ok(b"\x00\x00\x00\x09abcdefghi"[..].into()),
-        });
-
-    assert_eq!(io.poll().unwrap_err().kind(), io::ErrorKind::InvalidData);
-}
-
-#[test]
-fn read_update_max_frame_len_at_rest() {
-    let mut io = length_delimited::Builder::new().new_read(mock! {
-        Ok(b"\x00\x00\x00\x09abcdefghi"[..].into()),
-        Ok(b"\x00\x00\x00\x09abcdefghi"[..].into()),
-    });
-
-    assert_eq!(io.poll().unwrap(), Ready(Some(b"abcdefghi"[..].into())));
-    io.decoder_mut().set_max_frame_length(5);
-    assert_eq!(io.poll().unwrap_err().kind(), io::ErrorKind::InvalidData);
-}
-
-#[test]
-fn read_update_max_frame_len_in_flight() {
-    let mut io = length_delimited::Builder::new().new_read(mock! {
-        Ok(b"\x00\x00\x00\x09abcd"[..].into()),
-        Err(would_block()),
-        Ok(b"efghi"[..].into()),
-        Ok(b"\x00\x00\x00\x09abcdefghi"[..].into()),
-    });
-
-    assert_eq!(io.poll().unwrap(), NotReady);
-    io.decoder_mut().set_max_frame_length(5);
-    assert_eq!(io.poll().unwrap(), Ready(Some(b"abcdefghi"[..].into())));
-    assert_eq!(io.poll().unwrap_err().kind(), io::ErrorKind::InvalidData);
-}
-
-#[test]
-fn read_one_byte_length_field() {
-    let mut io = length_delimited::Builder::new()
-        .length_field_length(1)
-        .new_read(mock! {
-            Ok(b"\x09abcdefghi"[..].into()),
-        });
-
-    assert_eq!(io.poll().unwrap(), Ready(Some(b"abcdefghi"[..].into())));
-    assert_eq!(io.poll().unwrap(), Ready(None));
-}
-
-#[test]
-fn read_header_offset() {
-    let mut io = length_delimited::Builder::new()
-        .length_field_length(2)
-        .length_field_offset(4)
-        .new_read(mock! {
-            Ok(b"zzzz\x00\x09abcdefghi"[..].into()),
-        });
-
-    assert_eq!(io.poll().unwrap(), Ready(Some(b"abcdefghi"[..].into())));
-    assert_eq!(io.poll().unwrap(), Ready(None));
-}
-
-#[test]
-fn read_single_multi_frame_one_packet_skip_none_adjusted() {
-    let mut data: Vec<u8> = vec![];
-    data.extend_from_slice(b"xx\x00\x09abcdefghi");
-    data.extend_from_slice(b"yy\x00\x03123");
-    data.extend_from_slice(b"zz\x00\x0bhello world");
-
-    let mut io = length_delimited::Builder::new()
-        .length_field_length(2)
-        .length_field_offset(2)
-        .num_skip(0)
-        .length_adjustment(4)
-        .new_read(mock! {
-            Ok(data.into()),
-        });
-
-    assert_eq!(
-        io.poll().unwrap(),
-        Ready(Some(b"xx\x00\x09abcdefghi"[..].into()))
-    );
-    assert_eq!(io.poll().unwrap(), Ready(Some(b"yy\x00\x03123"[..].into())));
-    assert_eq!(
-        io.poll().unwrap(),
-        Ready(Some(b"zz\x00\x0bhello world"[..].into()))
-    );
-    assert_eq!(io.poll().unwrap(), Ready(None));
-}
-
-#[test]
-fn read_single_multi_frame_one_packet_length_includes_head() {
-    let mut data: Vec<u8> = vec![];
-    data.extend_from_slice(b"\x00\x0babcdefghi");
-    data.extend_from_slice(b"\x00\x05123");
-    data.extend_from_slice(b"\x00\x0dhello world");
-
-    let mut io = length_delimited::Builder::new()
-        .length_field_length(2)
-        .length_adjustment(-2)
-        .new_read(mock! {
-            Ok(data.into()),
-        });
-
-    assert_eq!(io.poll().unwrap(), Ready(Some(b"abcdefghi"[..].into())));
-    assert_eq!(io.poll().unwrap(), Ready(Some(b"123"[..].into())));
-    assert_eq!(io.poll().unwrap(), Ready(Some(b"hello world"[..].into())));
-    assert_eq!(io.poll().unwrap(), Ready(None));
-}
-
-#[test]
-fn write_single_frame_length_adjusted() {
-    let mut io = length_delimited::Builder::new()
-        .length_adjustment(-2)
-        .new_write(mock! {
-            Ok(b"\x00\x00\x00\x0b"[..].into()),
-            Ok(b"abcdefghi"[..].into()),
-            Ok(Flush),
-        });
-    assert!(io.start_send(Bytes::from("abcdefghi")).unwrap().is_ready());
-    assert!(io.poll_complete().unwrap().is_ready());
-    assert!(io.get_ref().calls.is_empty());
-}
-
-#[test]
-fn write_nothing_yields_nothing() {
-    let mut io = FramedWrite::new(mock!(), LengthDelimitedCodec::new());
-    assert!(io.poll_complete().unwrap().is_ready());
-}
-
-#[test]
-fn write_single_frame_one_packet() {
-    let mut io = FramedWrite::new(
-        mock! {
-            Ok(b"\x00\x00\x00\x09"[..].into()),
-            Ok(b"abcdefghi"[..].into()),
-            Ok(Flush),
-        },
-        LengthDelimitedCodec::new(),
-    );
-
-    assert!(io.start_send(Bytes::from("abcdefghi")).unwrap().is_ready());
-    assert!(io.poll_complete().unwrap().is_ready());
-    assert!(io.get_ref().calls.is_empty());
-}
-
-#[test]
-fn write_single_multi_frame_one_packet() {
-    let mut io = FramedWrite::new(
-        mock! {
-            Ok(b"\x00\x00\x00\x09"[..].into()),
-            Ok(b"abcdefghi"[..].into()),
-            Ok(b"\x00\x00\x00\x03"[..].into()),
-            Ok(b"123"[..].into()),
-            Ok(b"\x00\x00\x00\x0b"[..].into()),
-            Ok(b"hello world"[..].into()),
-            Ok(Flush),
-        },
-        LengthDelimitedCodec::new(),
-    );
-
-    assert!(io.start_send(Bytes::from("abcdefghi")).unwrap().is_ready());
-    assert!(io.start_send(Bytes::from("123")).unwrap().is_ready());
-    assert!(io
-        .start_send(Bytes::from("hello world"))
-        .unwrap()
-        .is_ready());
-    assert!(io.poll_complete().unwrap().is_ready());
-    assert!(io.get_ref().calls.is_empty());
-}
-
-#[test]
-fn write_single_multi_frame_multi_packet() {
-    let mut io = FramedWrite::new(
-        mock! {
-            Ok(b"\x00\x00\x00\x09"[..].into()),
-            Ok(b"abcdefghi"[..].into()),
-            Ok(Flush),
-            Ok(b"\x00\x00\x00\x03"[..].into()),
-            Ok(b"123"[..].into()),
-            Ok(Flush),
-            Ok(b"\x00\x00\x00\x0b"[..].into()),
-            Ok(b"hello world"[..].into()),
-            Ok(Flush),
-        },
-        LengthDelimitedCodec::new(),
-    );
-
-    assert!(io.start_send(Bytes::from("abcdefghi")).unwrap().is_ready());
-    assert!(io.poll_complete().unwrap().is_ready());
-    assert!(io.start_send(Bytes::from("123")).unwrap().is_ready());
-    assert!(io.poll_complete().unwrap().is_ready());
-    assert!(io
-        .start_send(Bytes::from("hello world"))
-        .unwrap()
-        .is_ready());
-    assert!(io.poll_complete().unwrap().is_ready());
-    assert!(io.get_ref().calls.is_empty());
-}
-
-#[test]
-fn write_single_frame_would_block() {
-    let mut io = FramedWrite::new(
-        mock! {
-            Err(would_block()),
-            Ok(b"\x00\x00"[..].into()),
-            Err(would_block()),
-            Ok(b"\x00\x09"[..].into()),
-            Ok(b"abcdefghi"[..].into()),
-            Ok(Flush),
-        },
-        LengthDelimitedCodec::new(),
-    );
-
-    assert!(io.start_send(Bytes::from("abcdefghi")).unwrap().is_ready());
-    assert!(!io.poll_complete().unwrap().is_ready());
-    assert!(!io.poll_complete().unwrap().is_ready());
-    assert!(io.poll_complete().unwrap().is_ready());
-
-    assert!(io.get_ref().calls.is_empty());
-}
-
-#[test]
-fn write_single_frame_little_endian() {
-    let mut io = length_delimited::Builder::new()
-        .little_endian()
-        .new_write(mock! {
-            Ok(b"\x09\x00\x00\x00"[..].into()),
-            Ok(b"abcdefghi"[..].into()),
-            Ok(Flush),
-        });
-
-    assert!(io.start_send(Bytes::from("abcdefghi")).unwrap().is_ready());
-    assert!(io.poll_complete().unwrap().is_ready());
-    assert!(io.get_ref().calls.is_empty());
-}
-
-#[test]
-fn write_single_frame_with_short_length_field() {
-    let mut io = length_delimited::Builder::new()
-        .length_field_length(1)
-        .new_write(mock! {
-            Ok(b"\x09"[..].into()),
-            Ok(b"abcdefghi"[..].into()),
-            Ok(Flush),
-        });
-
-    assert!(io.start_send(Bytes::from("abcdefghi")).unwrap().is_ready());
-    assert!(io.poll_complete().unwrap().is_ready());
-    assert!(io.get_ref().calls.is_empty());
-}
-
-#[test]
-fn write_max_frame_len() {
-    let mut io = length_delimited::Builder::new()
-        .max_frame_length(5)
-        .new_write(mock! {});
-
-    assert_eq!(
-        io.start_send(Bytes::from("abcdef")).unwrap_err().kind(),
-        io::ErrorKind::InvalidInput
-    );
-    assert!(io.get_ref().calls.is_empty());
-}
-
-#[test]
-fn write_update_max_frame_len_at_rest() {
-    let mut io = length_delimited::Builder::new().new_write(mock! {
-        Ok(b"\x00\x00\x00\x06"[..].into()),
-        Ok(b"abcdef"[..].into()),
-        Ok(Flush),
-    });
-
-    assert!(io.start_send(Bytes::from("abcdef")).unwrap().is_ready());
-    assert!(io.poll_complete().unwrap().is_ready());
-    io.encoder_mut().set_max_frame_length(5);
-    assert_eq!(
-        io.start_send(Bytes::from("abcdef")).unwrap_err().kind(),
-        io::ErrorKind::InvalidInput
-    );
-    assert!(io.get_ref().calls.is_empty());
-}
-
-#[test]
-fn write_update_max_frame_len_in_flight() {
-    let mut io = length_delimited::Builder::new().new_write(mock! {
-        Ok(b"\x00\x00\x00\x06"[..].into()),
-        Ok(b"ab"[..].into()),
-        Err(would_block()),
-        Ok(b"cdef"[..].into()),
-        Ok(Flush),
-    });
-
-    assert!(io.start_send(Bytes::from("abcdef")).unwrap().is_ready());
-    assert!(!io.poll_complete().unwrap().is_ready());
-    io.encoder_mut().set_max_frame_length(5);
-    assert!(io.poll_complete().unwrap().is_ready());
-    assert_eq!(
-        io.start_send(Bytes::from("abcdef")).unwrap_err().kind(),
-        io::ErrorKind::InvalidInput
-    );
-    assert!(io.get_ref().calls.is_empty());
-}
-
-#[test]
-fn write_zero() {
-    let mut io = length_delimited::Builder::new().new_write(mock! {});
-
-    assert!(io.start_send(Bytes::from("abcdef")).unwrap().is_ready());
-    assert_eq!(
-        io.poll_complete().unwrap_err().kind(),
-        io::ErrorKind::WriteZero
-    );
-    assert!(io.get_ref().calls.is_empty());
-}
-
-#[test]
-fn encode_overflow() {
-    // Test reproducing tokio-rs/tokio#681.
-    let mut codec = length_delimited::Builder::new().new_codec();
-    let mut buf = BytesMut::with_capacity(1024);
-
-    // Put some data into the buffer without resizing it to hold more.
-    let some_as = std::iter::repeat(b'a').take(1024).collect::<Vec<_>>();
-    buf.put_slice(&some_as[..]);
-
-    // Trying to encode the length header should resize the buffer if it won't fit.
-    codec.encode(Bytes::from("hello"), &mut buf).unwrap();
-}
-
-// ===== Test utils =====
-
-fn would_block() -> io::Error {
-    io::Error::new(io::ErrorKind::WouldBlock, "would block")
-}
-
-struct Mock {
-    calls: VecDeque<io::Result<Op>>,
-}
-
-enum Op {
-    Data(Vec<u8>),
-    Flush,
-}
-
-use self::Op::*;
-
-impl io::Read for Mock {
-    fn read(&mut self, dst: &mut [u8]) -> io::Result<usize> {
-        match self.calls.pop_front() {
-            Some(Ok(Op::Data(data))) => {
-                debug_assert!(dst.len() >= data.len());
-                dst[..data.len()].copy_from_slice(&data[..]);
-                Ok(data.len())
-            }
-            Some(Ok(_)) => panic!(),
-            Some(Err(e)) => Err(e),
-            None => Ok(0),
-        }
-    }
-}
-
-impl AsyncRead for Mock {}
-
-impl io::Write for Mock {
-    fn write(&mut self, src: &[u8]) -> io::Result<usize> {
-        match self.calls.pop_front() {
-            Some(Ok(Op::Data(data))) => {
-                let len = data.len();
-                assert!(src.len() >= len, "expect={:?}; actual={:?}", data, src);
-                assert_eq!(&data[..], &src[..len]);
-                Ok(len)
-            }
-            Some(Ok(_)) => panic!(),
-            Some(Err(e)) => Err(e),
-            None => Ok(0),
-        }
-    }
-
-    fn flush(&mut self) -> io::Result<()> {
-        match self.calls.pop_front() {
-            Some(Ok(Op::Flush)) => Ok(()),
-            Some(Ok(_)) => panic!(),
-            Some(Err(e)) => Err(e),
-            None => Ok(()),
-        }
-    }
-}
-
-impl AsyncWrite for Mock {
-    fn shutdown(&mut self) -> Poll<(), io::Error> {
-        Ok(Ready(()))
-    }
-}
-
-impl<'a> From<&'a [u8]> for Op {
-    fn from(src: &'a [u8]) -> Op {
-        Op::Data(src.into())
-    }
-}
-
-impl From<Vec<u8>> for Op {
-    fn from(src: Vec<u8>) -> Op {
-        Op::Data(src)
-    }
-}

tests/line-frames.rs

@@ -1,90 +0,0 @@
-extern crate bytes;
-extern crate env_logger;
-extern crate futures;
-extern crate tokio;
-extern crate tokio_codec;
-extern crate tokio_io;
-extern crate tokio_threadpool;
-
-use std::io;
-use std::net::Shutdown;
-
-use bytes::{BufMut, BytesMut};
-use futures::{Future, Sink, Stream};
-use tokio::net::{TcpListener, TcpStream};
-use tokio_codec::{Decoder, Encoder};
-use tokio_io::io::{read, write_all};
-use tokio_threadpool::Builder;
-
-pub struct LineCodec;
-
-impl Decoder for LineCodec {
-    type Item = BytesMut;
-    type Error = io::Error;
-
-    fn decode(&mut self, buf: &mut BytesMut) -> Result<Option<BytesMut>, io::Error> {
-        match buf.iter().position(|&b| b == b'\n') {
-            Some(i) => Ok(Some(buf.split_to(i + 1).into())),
-            None => Ok(None),
-        }
-    }
-
-    fn decode_eof(&mut self, buf: &mut BytesMut) -> io::Result<Option<BytesMut>> {
-        if buf.len() == 0 {
-            Ok(None)
-        } else {
-            let amt = buf.len();
-            Ok(Some(buf.split_to(amt)))
-        }
-    }
-}
-
-impl Encoder for LineCodec {
-    type Item = BytesMut;
-    type Error = io::Error;
-
-    fn encode(&mut self, item: BytesMut, into: &mut BytesMut) -> io::Result<()> {
-        into.put(&item[..]);
-        Ok(())
-    }
-}
-
-#[test]
-fn echo() {
-    drop(env_logger::try_init());
-
-    let pool = Builder::new().pool_size(1).build();
-
-    let listener = TcpListener::bind(&"127.0.0.1:0".parse().unwrap()).unwrap();
-    let addr = listener.local_addr().unwrap();
-    let sender = pool.sender().clone();
-    let srv = listener.incoming().for_each(move |socket| {
-        let (sink, stream) = LineCodec.framed(socket).split();
-        sender
-            .spawn(sink.send_all(stream).map(|_| ()).map_err(|_| ()))
-            .unwrap();
-        Ok(())
-    });
-
-    pool.sender()
-        .spawn(srv.map_err(|e| panic!("srv error: {}", e)))
-        .unwrap();
-
-    let client = TcpStream::connect(&addr);
-    let client = client.wait().unwrap();
-    let (client, _) = write_all(client, b"a\n").wait().unwrap();
-    let (client, buf, amt) = read(client, vec![0; 1024]).wait().unwrap();
-    assert_eq!(amt, 2);
-    assert_eq!(&buf[..2], b"a\n");
-
-    let (client, _) = write_all(client, b"\n").wait().unwrap();
-    let (client, buf, amt) = read(client, buf).wait().unwrap();
-    assert_eq!(amt, 1);
-    assert_eq!(&buf[..1], b"\n");
-
-    let (client, _) = write_all(client, b"b").wait().unwrap();
-    client.shutdown(Shutdown::Write).unwrap();
-    let (_client, buf, amt) = read(client, buf).wait().unwrap();
-    assert_eq!(amt, 1);
-    assert_eq!(&buf[..1], b"b");
-}

tests/pipe-hup.rs

@@ -1,103 +0,0 @@
-#![cfg(unix)]
-
-extern crate env_logger;
-extern crate futures;
-extern crate libc;
-extern crate mio;
-extern crate tokio;
-extern crate tokio_io;
-
-use std::fs::File;
-use std::io::{self, Write};
-use std::os::unix::io::{AsRawFd, FromRawFd};
-use std::thread;
-use std::time::Duration;
-
-use futures::Future;
-use mio::event::Evented;
-use mio::unix::{EventedFd, UnixReady};
-use mio::{PollOpt, Ready, Token};
-use tokio::reactor::{Handle, PollEvented2};
-use tokio_io::io::read_to_end;
-
-macro_rules! t {
-    ($e:expr) => {
-        match $e {
-            Ok(e) => e,
-            Err(e) => panic!("{} failed with {:?}", stringify!($e), e),
-        }
-    };
-}
-
-struct MyFile(File);
-
-impl MyFile {
-    fn new(file: File) -> MyFile {
-        unsafe {
-            let r = libc::fcntl(file.as_raw_fd(), libc::F_SETFL, libc::O_NONBLOCK);
-            assert!(r != -1, "fcntl error: {}", io::Error::last_os_error());
-        }
-        MyFile(file)
-    }
-}
-
-impl io::Read for MyFile {
-    fn read(&mut self, bytes: &mut [u8]) -> io::Result<usize> {
-        self.0.read(bytes)
-    }
-}
-
-impl Evented for MyFile {
-    fn register(
-        &self,
-        poll: &mio::Poll,
-        token: Token,
-        interest: Ready,
-        opts: PollOpt,
-    ) -> io::Result<()> {
-        let hup: Ready = UnixReady::hup().into();
-        EventedFd(&self.0.as_raw_fd()).register(poll, token, interest | hup, opts)
-    }
-    fn reregister(
-        &self,
-        poll: &mio::Poll,
-        token: Token,
-        interest: Ready,
-        opts: PollOpt,
-    ) -> io::Result<()> {
-        let hup: Ready = UnixReady::hup().into();
-        EventedFd(&self.0.as_raw_fd()).reregister(poll, token, interest | hup, opts)
-    }
-    fn deregister(&self, poll: &mio::Poll) -> io::Result<()> {
-        EventedFd(&self.0.as_raw_fd()).deregister(poll)
-    }
-}
-
-#[test]
-fn hup() {
-    drop(env_logger::try_init());
-
-    let handle = Handle::default();
-    unsafe {
-        let mut pipes = [0; 2];
-        assert!(
-            libc::pipe(pipes.as_mut_ptr()) != -1,
-            "pipe error: {}",
-            io::Error::last_os_error()
-        );
-        let read = File::from_raw_fd(pipes[0]);
-        let mut write = File::from_raw_fd(pipes[1]);
-        let t = thread::spawn(move || {
-            write.write_all(b"Hello!\n").unwrap();
-            write.write_all(b"Good bye!\n").unwrap();
-            thread::sleep(Duration::from_millis(100));
-        });
-
-        let source = PollEvented2::new_with_handle(MyFile::new(read), &handle).unwrap();
-
-        let reader = read_to_end(source, Vec::new());
-        let (_, content) = t!(reader.wait());
-        assert_eq!(&b"Hello!\nGood bye!\n"[..], &content[..]);
-        t.join().unwrap();
-    }
-}

tests/reactor.rs

@@ -1,91 +0,0 @@
-extern crate futures;
-extern crate tokio_executor;
-extern crate tokio_reactor;
-extern crate tokio_tcp;
-
-use tokio_reactor::Reactor;
-use tokio_tcp::TcpListener;
-
-use futures::executor::{spawn, Notify, Spawn};
-use futures::{Future, Stream};
-
-use std::mem;
-use std::net::TcpStream;
-use std::sync::{Arc, Mutex};
-
-#[test]
-fn test_drop_on_notify() {
-    // When the reactor receives a kernel notification, it notifies the
-    // task that holds the associated socket. If this notification results in
-    // the task being dropped, the socket will also be dropped.
-    //
-    // Previously, there was a deadlock scenario where the reactor, while
-    // notifying, held a lock and the task being dropped attempted to acquire
-    // that same lock in order to clean up state.
-    //
-    // To simulate this case, we create a fake executor that does nothing when
-    // the task is notified. This simulates an executor in the process of
-    // shutting down. Then, when the task handle is dropped, the task itself is
-    // dropped.
-
-    struct MyNotify;
-
-    type Task = Mutex<Spawn<Box<Future<Item = (), Error = ()>>>>;
-
-    impl Notify for MyNotify {
-        fn notify(&self, _: usize) {
-            // Do nothing
-        }
-
-        fn clone_id(&self, id: usize) -> usize {
-            let ptr = id as *const Task;
-            let task = unsafe { Arc::from_raw(ptr) };
-
-            mem::forget(task.clone());
-            mem::forget(task);
-
-            id
-        }
-
-        fn drop_id(&self, id: usize) {
-            let ptr = id as *const Task;
-            let _ = unsafe { Arc::from_raw(ptr) };
-        }
-    }
-
-    let addr = "127.0.0.1:0".parse().unwrap();
-    let mut reactor = Reactor::new().unwrap();
-
-    // Create a listener
-    let listener = TcpListener::bind(&addr).unwrap();
-    let addr = listener.local_addr().unwrap();
-
-    // Define a task that just drains the listener
-    let task = Box::new({
-        listener
-            .incoming()
-            .for_each(|_| Ok(()))
-            .map_err(|_| panic!())
-    }) as Box<Future<Item = (), Error = ()>>;
-
-    let task = Arc::new(Mutex::new(spawn(task)));
-    let notify = Arc::new(MyNotify);
-
-    let mut enter = tokio_executor::enter().unwrap();
-
-    tokio_reactor::with_default(&reactor.handle(), &mut enter, |_| {
-        let id = &*task as *const Task as usize;
-
-        task.lock()
-            .unwrap()
-            .poll_future_notify(&notify, id)
-            .unwrap();
-    });
-
-    drop(task);
-
-    // Establish a connection to the acceptor
-    let _s = TcpStream::connect(&addr).unwrap();
-
-    reactor.turn(None).unwrap();
-}

tests/runtime.rs

@@ -1,532 +0,0 @@
-extern crate env_logger;
-extern crate futures;
-extern crate tokio;
-
-use futures::sync::oneshot;
-use std::sync::{atomic, Arc, Mutex};
-use std::thread;
-use tokio::io;
-use tokio::net::{TcpListener, TcpStream};
-use tokio::prelude::future::lazy;
-use tokio::prelude::*;
-use tokio::runtime::Runtime;
-
-// this import is used in all child modules that have it in scope
-// from importing super::*, but the compiler doesn't realise that
-// and warns about it.
-pub use futures::future::Executor;
-
-macro_rules! t {
-    ($e:expr) => {
-        match $e {
-            Ok(e) => e,
-            Err(e) => panic!("{} failed with {:?}", stringify!($e), e),
-        }
-    };
-}
-
-fn create_client_server_future() -> Box<Future<Item = (), Error = ()> + Send> {
-    let server = t!(TcpListener::bind(&"127.0.0.1:0".parse().unwrap()));
-    let addr = t!(server.local_addr());
-    let client = TcpStream::connect(&addr);
-
-    let server = server
-        .incoming()
-        .take(1)
-        .map_err(|e| panic!("accept err = {:?}", e))
-        .for_each(|socket| {
-            tokio::spawn({
-                io::write_all(socket, b"hello")
-                    .map(|_| ())
-                    .map_err(|e| panic!("write err = {:?}", e))
-            })
-        })
-        .map(|_| ());
-
-    let client = client
-        .map_err(|e| panic!("connect err = {:?}", e))
-        .and_then(|client| {
-            // Read all
-            io::read_to_end(client, vec![])
-                .map(|_| ())
-                .map_err(|e| panic!("read err = {:?}", e))
-        });
-
-    let future = server.join(client).map(|_| ());
-    Box::new(future)
-}
-
-#[test]
-fn runtime_tokio_run() {
-    let _ = env_logger::try_init();
-
-    tokio::run(create_client_server_future());
-}
-
-#[test]
-fn runtime_single_threaded() {
-    let _ = env_logger::try_init();
-
-    let mut runtime = tokio::runtime::current_thread::Runtime::new().unwrap();
-    runtime.block_on(create_client_server_future()).unwrap();
-    runtime.run().unwrap();
-}
-
-#[test]
-fn runtime_single_threaded_block_on() {
-    let _ = env_logger::try_init();
-
-    tokio::runtime::current_thread::block_on_all(create_client_server_future()).unwrap();
-}
-
-mod runtime_single_threaded_block_on_all {
-    use super::*;
-
-    fn test<F>(spawn: F)
-    where
-        F: Fn(Box<Future<Item = (), Error = ()> + Send>),
-    {
-        let cnt = Arc::new(Mutex::new(0));
-        let c = cnt.clone();
-
-        let msg = tokio::runtime::current_thread::block_on_all(lazy(move || {
-            {
-                let mut x = c.lock().unwrap();
-                *x = 1 + *x;
-            }
-
-            // Spawn!
-            spawn(Box::new(lazy(move || {
-                {
-                    let mut x = c.lock().unwrap();
-                    *x = 1 + *x;
-                }
-                Ok::<(), ()>(())
-            })));
-
-            Ok::<_, ()>("hello")
-        }))
-        .unwrap();
-
-        assert_eq!(2, *cnt.lock().unwrap());
-        assert_eq!(msg, "hello");
-    }
-
-    #[test]
-    fn spawn() {
-        test(|f| {
-            tokio::spawn(f);
-        })
-    }
-
-    #[test]
-    fn execute() {
-        test(|f| {
-            tokio::executor::DefaultExecutor::current()
-                .execute(f)
-                .unwrap();
-        })
-    }
-}
-
-mod runtime_single_threaded_racy {
-    use super::*;
-    fn test<F>(spawn: F)
-    where
-        F: Fn(tokio::runtime::current_thread::Handle, Box<Future<Item = (), Error = ()> + Send>),
-    {
-        let (trigger, exit) = futures::sync::oneshot::channel();
-        let (handle_tx, handle_rx) = ::std::sync::mpsc::channel();
-        let jh = ::std::thread::spawn(move || {
-            let mut rt = tokio::runtime::current_thread::Runtime::new().unwrap();
-            handle_tx.send(rt.handle()).unwrap();
-
-            // don't exit until we are told to
-            rt.block_on(exit.map_err(|_| ())).unwrap();
-
-            // run until all spawned futures (incl. the "exit" signal future) have completed.
-            rt.run().unwrap();
-        });
-
-        let (tx, rx) = futures::sync::oneshot::channel();
-
-        let handle = handle_rx.recv().unwrap();
-        spawn(
-            handle,
-            Box::new(futures::future::lazy(move || {
-                tx.send(()).unwrap();
-                Ok(())
-            })),
-        );
-
-        // signal runtime thread to exit
-        trigger.send(()).unwrap();
-
-        // wait for runtime thread to exit
-        jh.join().unwrap();
-
-        assert_eq!(rx.wait().unwrap(), ());
-    }
-
-    #[test]
-    fn spawn() {
-        test(|handle, f| {
-            handle.spawn(f).unwrap();
-        })
-    }
-
-    #[test]
-    fn execute() {
-        test(|handle, f| {
-            handle.execute(f).unwrap();
-        })
-    }
-}
-
-mod runtime_multi_threaded {
-    use super::*;
-    fn test<F>(spawn: F)
-    where
-        F: Fn(&mut Runtime) + Send + 'static,
-    {
-        let _ = env_logger::try_init();
-
-        let mut runtime = tokio::runtime::Builder::new().build().unwrap();
-        spawn(&mut runtime);
-        runtime.shutdown_on_idle().wait().unwrap();
-    }
-
-    #[test]
-    fn spawn() {
-        test(|rt| {
-            rt.spawn(create_client_server_future());
-        });
-    }
-
-    #[test]
-    fn execute() {
-        test(|rt| {
-            rt.executor()
-                .execute(create_client_server_future())
-                .unwrap();
-        });
-    }
-}
-
-#[test]
-fn block_on_timer() {
-    use std::time::{Duration, Instant};
-    use tokio::timer::{Delay, Error};
-
-    fn after_1s<T>(x: T) -> Box<Future<Item = T, Error = Error> + Send>
-    where
-        T: Send + 'static,
-    {
-        Box::new(Delay::new(Instant::now() + Duration::from_millis(100)).map(move |_| x))
-    }
-
-    let mut runtime = Runtime::new().unwrap();
-    assert_eq!(runtime.block_on(after_1s(42)).unwrap(), 42);
-    runtime.shutdown_on_idle().wait().unwrap();
-}
-
-mod from_block_on {
-    use super::*;
-
-    fn test<F>(spawn: F)
-    where
-        F: Fn(Box<Future<Item = (), Error = ()> + Send>) + Send + 'static,
-    {
-        let cnt = Arc::new(Mutex::new(0));
-        let c = cnt.clone();
-
-        let mut runtime = Runtime::new().unwrap();
-        let msg = runtime
-            .block_on(lazy(move || {
-                {
-                    let mut x = c.lock().unwrap();
-                    *x = 1 + *x;
-                }
-
-                // Spawn!
-                spawn(Box::new(lazy(move || {
-                    {
-                        let mut x = c.lock().unwrap();
-                        *x = 1 + *x;
-                    }
-                    Ok::<(), ()>(())
-                })));
-
-                Ok::<_, ()>("hello")
-            }))
-            .unwrap();
-
-        runtime.shutdown_on_idle().wait().unwrap();
-        assert_eq!(2, *cnt.lock().unwrap());
-        assert_eq!(msg, "hello");
-    }
-
-    #[test]
-    fn execute() {
-        test(|f| {
-            tokio::executor::DefaultExecutor::current()
-                .execute(f)
-                .unwrap();
-        })
-    }
-
-    #[test]
-    fn spawn() {
-        test(|f| {
-            tokio::spawn(f);
-        })
-    }
-}
-
-#[test]
-fn block_waits() {
-    let (tx, rx) = oneshot::channel();
-
-    thread::spawn(|| {
-        use std::time::Duration;
-        thread::sleep(Duration::from_millis(1000));
-        tx.send(()).unwrap();
-    });
-
-    let cnt = Arc::new(Mutex::new(0));
-    let c = cnt.clone();
-
-    let mut runtime = Runtime::new().unwrap();
-    runtime
-        .block_on(rx.then(move |_| {
-            {
-                let mut x = c.lock().unwrap();
-                *x = 1 + *x;
-            }
-            Ok::<_, ()>(())
-        }))
-        .unwrap();
-
-    assert_eq!(1, *cnt.lock().unwrap());
-    runtime.shutdown_on_idle().wait().unwrap();
-}
-
-mod many {
-    use super::*;
-
-    const ITER: usize = 200;
-    fn test<F>(spawn: F)
-    where
-        F: Fn(&mut Runtime, Box<Future<Item = (), Error = ()> + Send>),
-    {
-        let cnt = Arc::new(Mutex::new(0));
-        let mut runtime = Runtime::new().unwrap();
-
-        for _ in 0..ITER {
-            let c = cnt.clone();
-            spawn(
-                &mut runtime,
-                Box::new(lazy(move || {
-                    {
-                        let mut x = c.lock().unwrap();
-                        *x = 1 + *x;
-                    }
-                    Ok::<(), ()>(())
-                })),
-            );
-        }
-
-        runtime.shutdown_on_idle().wait().unwrap();
-        assert_eq!(ITER, *cnt.lock().unwrap());
-    }
-
-    #[test]
-    fn spawn() {
-        test(|rt, f| {
-            rt.spawn(f);
-        })
-    }
-
-    #[test]
-    fn execute() {
-        test(|rt, f| {
-            rt.executor().execute(f).unwrap();
-        })
-    }
-}
-
-mod from_block_on_all {
-    use super::*;
-
-    fn test<F>(spawn: F)
-    where
-        F: Fn(Box<Future<Item = (), Error = ()> + Send>) + Send + 'static,
-    {
-        let cnt = Arc::new(Mutex::new(0));
-        let c = cnt.clone();
-
-        let runtime = Runtime::new().unwrap();
-        let msg = runtime
-            .block_on_all(lazy(move || {
-                {
-                    let mut x = c.lock().unwrap();
-                    *x = 1 + *x;
-                }
-
-                // Spawn!
-                spawn(Box::new(lazy(move || {
-                    {
-                        let mut x = c.lock().unwrap();
-                        *x = 1 + *x;
-                    }
-                    Ok::<(), ()>(())
-                })));
-
-                Ok::<_, ()>("hello")
-            }))
-            .unwrap();
-
-        assert_eq!(2, *cnt.lock().unwrap());
-        assert_eq!(msg, "hello");
-    }
-
-    #[test]
-    fn execute() {
-        test(|f| {
-            tokio::executor::DefaultExecutor::current()
-                .execute(f)
-                .unwrap();
-        })
-    }
-
-    #[test]
-    fn spawn() {
-        test(|f| {
-            tokio::spawn(f);
-        })
-    }
-}
-
-mod nested_enter {
-    use super::*;
-    use std::panic;
-    use tokio::runtime::current_thread;
-
-    fn test<F1, F2>(first: F1, nested: F2)
-    where
-        F1: Fn(Box<Future<Item = (), Error = ()> + Send>) + Send + 'static,
-        F2: Fn(Box<Future<Item = (), Error = ()> + Send>) + panic::UnwindSafe + Send + 'static,
-    {
-        let panicked = Arc::new(Mutex::new(false));
-        let panicked2 = panicked.clone();
-
-        // Since this is testing panics in other threads, printing about panics
-        // is noisy and can give the impression that the test is ignoring panics.
-        //
-        // It *is* ignoring them, but on purpose.
-        let prev_hook = panic::take_hook();
-        panic::set_hook(Box::new(|info| {
-            let s = info.to_string();
-            if s.starts_with("panicked at 'nested ")
-                || s.starts_with("panicked at 'Multiple executors at once")
-            {
-                // expected, noop
-            } else {
-                println!("{}", s);
-            }
-        }));
-
-        first(Box::new(lazy(move || {
-            panic::catch_unwind(move || nested(Box::new(lazy(|| Ok::<(), ()>(())))))
-                .expect_err("nested should panic");
-            *panicked2.lock().unwrap() = true;
-            Ok::<(), ()>(())
-        })));
-
-        panic::set_hook(prev_hook);
-
-        assert!(
-            *panicked.lock().unwrap(),
-            "nested call should have panicked"
-        );
-    }
-
-    fn threadpool_new() -> Runtime {
-        Runtime::new().expect("rt new")
-    }
-
-    #[test]
-    fn run_in_run() {
-        test(tokio::run, tokio::run);
-    }
-
-    #[test]
-    fn threadpool_block_on_in_run() {
-        test(tokio::run, |fut| {
-            let mut rt = threadpool_new();
-            rt.block_on(fut).unwrap();
-        });
-    }
-
-    #[test]
-    fn threadpool_block_on_all_in_run() {
-        test(tokio::run, |fut| {
-            let rt = threadpool_new();
-            rt.block_on_all(fut).unwrap();
-        });
-    }
-
-    #[test]
-    fn current_thread_block_on_all_in_run() {
-        test(tokio::run, |fut| {
-            current_thread::block_on_all(fut).unwrap();
-        });
-    }
-}
-
-#[test]
-fn runtime_reactor_handle() {
-    #![allow(deprecated)]
-
-    use futures::Stream;
-    use std::net::{TcpListener as StdListener, TcpStream as StdStream};
-
-    let rt = Runtime::new().unwrap();
-
-    let std_listener = StdListener::bind("127.0.0.1:0").unwrap();
-    let tk_listener = TcpListener::from_std(std_listener, rt.handle()).unwrap();
-
-    let addr = tk_listener.local_addr().unwrap();
-
-    // Spawn a thread since we are avoiding the runtime
-    let th = thread::spawn(|| for _ in tk_listener.incoming().take(1).wait() {});
-
-    let _ = StdStream::connect(&addr).unwrap();
-
-    th.join().unwrap();
-}
-
-#[test]
-fn after_start_and_before_stop_is_called() {
-    let _ = env_logger::try_init();
-
-    let after_start = Arc::new(atomic::AtomicUsize::new(0));
-    let before_stop = Arc::new(atomic::AtomicUsize::new(0));
-
-    let after_inner = after_start.clone();
-    let before_inner = before_stop.clone();
-    let runtime = tokio::runtime::Builder::new()
-        .after_start(move || {
-            after_inner.clone().fetch_add(1, atomic::Ordering::Relaxed);
-        })
-        .before_stop(move || {
-            before_inner.clone().fetch_add(1, atomic::Ordering::Relaxed);
-        })
-        .build()
-        .unwrap();
-
-    runtime.block_on_all(create_client_server_future()).unwrap();
-
-    assert!(after_start.load(atomic::Ordering::Relaxed) > 0);
-    assert!(before_stop.load(atomic::Ordering::Relaxed) > 0);
-}

tests/timer.rs

@@ -1,113 +0,0 @@
-extern crate env_logger;
-extern crate futures;
-extern crate tokio;
-extern crate tokio_io;
-
-use tokio::prelude::*;
-use tokio::timer::*;
-
-use std::sync::mpsc;
-use std::time::{Duration, Instant};
-
-#[test]
-fn timer_with_runtime() {
-    let _ = env_logger::try_init();
-
-    let when = Instant::now() + Duration::from_millis(100);
-    let (tx, rx) = mpsc::channel();
-
-    tokio::run({
-        Delay::new(when)
-            .map_err(|e| panic!("unexpected error; err={:?}", e))
-            .and_then(move |_| {
-                assert!(Instant::now() >= when);
-                tx.send(()).unwrap();
-                Ok(())
-            })
-    });
-
-    rx.recv().unwrap();
-}
-
-#[test]
-fn starving() {
-    use futures::{task, Async, Poll};
-
-    let _ = env_logger::try_init();
-
-    struct Starve(Delay, u64);
-
-    impl Future for Starve {
-        type Item = u64;
-        type Error = ();
-
-        fn poll(&mut self) -> Poll<Self::Item, ()> {
-            if self.0.poll().unwrap().is_ready() {
-                return Ok(self.1.into());
-            }
-
-            self.1 += 1;
-
-            task::current().notify();
-
-            Ok(Async::NotReady)
-        }
-    }
-
-    let when = Instant::now() + Duration::from_millis(20);
-    let starve = Starve(Delay::new(when), 0);
-
-    let (tx, rx) = mpsc::channel();
-
-    tokio::run({
-        starve.and_then(move |_ticks| {
-            assert!(Instant::now() >= when);
-            tx.send(()).unwrap();
-            Ok(())
-        })
-    });
-
-    rx.recv().unwrap();
-}
-
-#[test]
-fn deadline() {
-    use futures::future;
-
-    let _ = env_logger::try_init();
-
-    let when = Instant::now() + Duration::from_millis(20);
-    let (tx, rx) = mpsc::channel();
-
-    #[allow(deprecated)]
-    tokio::run({
-        future::empty::<(), ()>().deadline(when).then(move |res| {
-            assert!(res.is_err());
-            tx.send(()).unwrap();
-            Ok(())
-        })
-    });
-
-    rx.recv().unwrap();
-}
-
-#[test]
-fn timeout() {
-    use futures::future;
-
-    let _ = env_logger::try_init();
-
-    let (tx, rx) = mpsc::channel();
-
-    tokio::run({
-        future::empty::<(), ()>()
-            .timeout(Duration::from_millis(20))
-            .then(move |res| {
-                assert!(res.is_err());
-                tx.send(()).unwrap();
-                Ok(())
-            })
-    });
-
-    rx.recv().unwrap();
-}

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 = { version = "0.1.7", path = "../tokio-io" }
-
-[dev-dependencies]
-bytes = "0.4.9"
-tokio = { version = "0.1.8", path = ".." }
-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()
-    }
-}