prepare tokio-sync v0.1.7 release. (#1650)

When polling the task, the current waker is saved to the oneshot state.
When the handle is migrated to a new task and polled again, the waker
must be swaped from the old waker to the new waker. In some cases, there
is a potential for the old waker to leak.

This bug was caught by loom with the recently added memory leak
detection.

Backport of #1648.

.appveyor.yml

@@ -1,16 +0,0 @@
-environment:
-  matrix:
-  - TARGET: x86_64-pc-windows-msvc
-install:
-  - appveyor-retry appveyor DownloadFile https://win.rustup.rs/ -FileName rustup-init.exe
-  - rustup-init.exe -y --default-host x86_64-pc-windows-msvc
-  - set PATH=%PATH%;C:\Users\appveyor\.cargo\bin
-  - if NOT "%TARGET%" == "x86_64-pc-windows-msvc" rustup target add %TARGET%
-
-  - rustc -V
-  - cargo -V
-
-build: false
-
-test_script:
-  - cargo test --all --target %TARGET%

.cirrus.yml

@@ -0,0 +1,41 @@
+freebsd_instance:
+  image: freebsd-12-0-release-amd64
+
+# Test FreeBSD in a full VM on cirrus-ci.com.  Test the i686 target too, in the
+# same VM.  The binary will be built in 32-bit mode, but will execute on a
+# 64-bit kernel and in a 64-bit environment.  Our tests don't execute any of
+# the system's binaries, so the environment shouldn't matter.
+task:
+  name: FreeBSD 12.0
+  env:
+    LOOM_MAX_DURATION: 10
+  setup_script:
+    - pkg install -y curl
+    - curl https://sh.rustup.rs -sSf --output rustup.sh
+    - sh rustup.sh -y
+    - . $HOME/.cargo/env
+    - rustup target add i686-unknown-freebsd
+    - |
+      # 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 "~~~~~~~~~~~~~~~~~~~~"
+  cargo_cache:
+    folder: $HOME/.cargo/registry
+  test_script:
+    - . $HOME/.cargo/env
+    - cargo test --all
+    - cargo doc --all
+  i686_test_script:
+    - . $HOME/.cargo/env
+    - |
+      cargo test --all --exclude tokio-tls --exclude tokio-macros --target i686-unknown-freebsd
+  before_cache_script:
+    - rm -rf $HOME/.cargo/registry/index

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,51 @@
+<!--
+Thank you for reporting an issue.
+
+Please fill in as much of the template below as you're able.
+-->
+
+## Version
+
+<!--
+List the versions of all `tokio` crates you are using. The easiest way to get
+this information is using `cargo-tree`.
+
+`cargo install cargo-tree`
+(see install here: https://github.com/sfackler/cargo-tree)
+
+Then:
+
+`cargo tree | grep tokio`
+-->
+
+## Platform
+
+<!---
+Output of `uname -a` (UNIX), or version and 32 or 64-bit (Windows)
+-->
+
+## Subcrates
+
+<!--
+If known, please specify the affected Tokio sub crates. Otherwise, delete this
+section.
+-->
+
+## Description
+
+<!--
+
+Enter your issue details below this comment.
+
+One way to structure the description:
+
+<short summary of the bug>
+
+I tried this code:
+
+<code sample that causes the bug>
+
+I expected to see this happen: <explanation>
+
+Instead, this happened: <explanation>
+-->

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,23 @@
+<!--
+Thank you for your Pull Request. Please provide a description above and review
+the requirements below.
+
+Bug fixes and new features should include tests.
+
+Contributors guide: https://github.com/tokio-rs/tokio/blob/master/CONTRIBUTING.md
+-->
+
+## Motivation
+
+<!--
+Explain the context and why you're making that change. What is the problem
+you're trying to solve? In some cases there is not a problem and this can be
+thought of as being the motivation for your change.
+-->
+
+## Solution
+
+<!--
+Summarize the solution and provide any necessary context needed to understand
+the code change.
+-->

.travis.yml

@@ -1,56 +0,0 @@
----
-language: rust
-sudo: false
-
-matrix:
-  include:
-  - rust: 1.21.0
-  - rust: stable
-  - os: osx
-  - rust: beta
-  - rust: nightly
-  - env: TARGET=x86_64-unknown-freebsd
-
-script:
-  - |
-    set -e
-    if [[ "$TRAVIS_RUST_VERSION" == nightly ]]
-    then
-        cargo build --benches --all
-    fi
-  - |
-    set -e
-    if [[ "$TARGET" ]]
-    then
-        rustup target add $TARGET
-        cargo check --all --target $TARGET
-        cargo check --tests --all --target $TARGET
-    else
-        cargo test --all
-        cargo test --features unstable-futures
-        cargo test --manifest-path tokio-threadpool/Cargo.toml --features unstable-futures
-        cargo test --manifest-path tokio-reactor/Cargo.toml --features unstable-futures
-    fi
-
-before_deploy:
-  - cargo doc --all --no-deps
-
-deploy:
-  provider:  pages
-  skip_cleanup: true
-  github_token: $GH_TOKEN
-  target_branch: gh-pages
-  local_dir: target/doc
-  on:
-    branch: master
-    repo: tokio-rs/tokio
-    rust: stable
-    condition: $TRAVIS_OS_NAME = linux
-
-env:
-  global:
-    - secure: iwlN1zfUCp/5BAAheqIRSFIqiM9zSwfIGcVDw/V7jHveqXyNzmCs7H58/cd90WLqonqpPX0t5GF66oTjms4v0DFjgXr/k4358qeSZaV082V3baNrVpCDHeCQV0SvKsfiYxDDJGSUL1WIUP+tqqDm4+ksZQP3LnwZojkABjWz5CBNt4kX+Wz5ZbYqtQoxyuZba5UyPY2CXJtubvCVPGMJULuUpklYxXZ4dWM2olzGgVJ8rE8udhSZ4ER4JgxB0KUx3/5TwHHzgyPEsWR4bKN6JzBjIczQofXUcUXXdoZBs23H/VhCpzKcn3/oJ8btVYPzwtdj5FmVB1aVR/gjPo2bSGi/sofq+LwL/1HJXkM+kjl8m2dLLcDBKqNYNERtVA1++LhkMWAFRgGYe8v8Ryxjiue1NF5LgAIA/fjK0uI1DELTzTf/TKrM+AtPDNTvhOft4/YD+hoImjwk6nv6PBb2TiTYnc79Qf4AZ65tv1qtsAUPuw4plLaccHQAO4ldYVXn4u9c+iisJwvovs6jo06bF3U3qtdI5gXsrI9+T25TrXvYb+IREo0MHzYEM0KlPFnscEArzC3eajuSd36ARFP3lDc+gp2RPs89iJjowms0eRyepp7Cu6XO3Cd2pfAX8AqvnmttZf4Nm51ONeiBPXPXItUkJm49MCpMJywU1IZcWZg=
-
-notifications:
-  email:
-    on_success: never

CHANGELOG.md

@@ -1,30 +0,0 @@
-# 0.1.4 (March 22, 2018)
-
-* Fix build on FreeBSD (#218)
-* Shutdown the Runtime when the handle is dropped (#214)
-* Set Runtime thread name prefix for worker threads (#232)
-* Add builder for Runtime (#234)
-* Extract TCP and UDP types into separate crates (#224)
-* Optionally support futures 0.2.
-
-# 0.1.3 (March 09, 2018)
-
-* Fix `CurrentThread::turn` to block on idle (#212).
-
-# 0.1.2 (March 09, 2018)
-
-* Introduce Tokio Runtime (#141)
-* Provide `CurrentThread` for more flexible usage of current thread executor (#141).
-* Add Lio for platforms that support it (#142).
-* I/O resources now lazily bind to the reactor (#160).
-* Extract Reactor to dedicated crate (#169)
-* Add facade to sub crates and add prelude (#166).
-* Switch TCP/UDP fns to poll_ -> Poll<...> style (#175)
-
-# 0.1.1 (February 09, 2018)
-
-* Doc fixes
-
-# 0.1.0 (February 07, 2018)
-
-* Initial crate released based on [RFC](https://github.com/tokio-rs/tokio-rfcs/pull/3).

CONTRIBUTING.md

@@ -0,0 +1,387 @@
+# Contributing to Tokio
+
+:balloon: Thanks for your help improving the project! We are so happy to have
+you!
+
+There are opportunities to contribute to Tokio at any level. It doesn't matter if
+you are just getting started with Rust or are the most weathered expert, we can
+use your help.
+
+**No contribution is too small and all contributions are valued.**
+
+This guide will help you get started. **Do not let this guide intimidate you**.
+It should be considered a map to help you navigate the process.
+
+You may also get help with contributing in the [dev channel][dev], please join
+us!
+
+[dev]: https://gitter.im/tokio-rs/dev
+
+## Conduct
+
+The Tokio project adheres to the [Rust Code of Conduct][coc]. This describes
+the _minimum_ behavior expected from all contributors.
+
+[coc]: https://github.com/rust-lang/rust/blob/master/CODE_OF_CONDUCT.md
+
+## Contributing in Issues
+
+For any issue, there are fundamentally three ways an individual can contribute:
+
+1. By opening the issue for discussion: For instance, if you believe that you
+   have uncovered a bug in Tokio, creating a new issue in the tokio-rs/tokio
+   issue tracker is the way to report it.
+
+2. By helping to triage the issue: This can be done by providing
+   supporting details (a test case that demonstrates a bug), providing
+   suggestions on how to address the issue, or ensuring that the issue is tagged
+   correctly.
+
+3. By helping to resolve the issue: Typically this is done either in the form of
+   demonstrating that the issue reported is not a problem after all, or more
+   often, by opening a Pull Request that changes some bit of something in
+   Tokio in a concrete and reviewable manner.
+
+**Anybody can participate in any stage of contribution**. We urge you to
+participate in the discussion around bugs and participate in reviewing PRs.
+
+### Asking for General Help
+
+If you have reviewed existing documentation and still have questions or are
+having problems, you can open an issue asking for help.
+
+In exchange for receiving help, we ask that you contribute back a documentation
+PR that helps others avoid the problems that you encountered.
+
+### Submitting a Bug Report
+
+When opening a new issue in the Tokio issue tracker, users will be presented
+with a [basic template][template] that should be filled in. If you believe that you have
+uncovered a bug, please fill out this form, following the template to the best
+of your ability. Do not worry if you cannot answer every detail, just fill in
+what you can.
+
+The two most important pieces of information we need in order to properly
+evaluate the report is a description of the behavior you are seeing and a simple
+test case we can use to recreate the problem on our own. If we cannot recreate
+the issue, it becomes impossible for us to fix.
+
+In order to rule out the possibility of bugs introduced by userland code, test
+cases should be limited, as much as possible, to using only Tokio APIs.
+
+See [How to create a Minimal, Complete, and Verifiable example][mcve].
+
+[mcve]: https://stackoverflow.com/help/mcve
+[template]: .github/PULL_REQUEST_TEMPLATE.md
+
+### Triaging a Bug Report
+
+Once an issue has been opened, it is not uncommon for there to be discussion
+around it. Some contributors may have differing opinions about the issue,
+including whether the behavior being seen is a bug or a feature. This discussion
+is part of the process and should be kept focused, helpful, and professional.
+
+Short, clipped responses—that provide neither additional context nor supporting
+detail—are not helpful or professional. To many, such responses are simply
+annoying and unfriendly.
+
+Contributors are encouraged to help one another make forward progress as much as
+possible, empowering one another to solve issues collaboratively. If you choose
+to comment on an issue that you feel either is not a problem that needs to be
+fixed, or if you encounter information in an issue that you feel is incorrect,
+explain why you feel that way with additional supporting context, and be willing
+to be convinced that you may be wrong. By doing so, we can often reach the
+correct outcome much faster.
+
+### Resolving a Bug Report
+
+In the majority of cases, issues are resolved by opening a Pull Request. The
+process for opening and reviewing a Pull Request is similar to that of opening
+and triaging issues, but carries with it a necessary review and approval
+workflow that ensures that the proposed changes meet the minimal quality and
+functional guidelines of the Tokio project.
+
+## Pull Requests
+
+Pull Requests are the way concrete changes are made to the code, documentation,
+and dependencies in the Tokio repository.
+
+Even tiny pull requests (e.g., one character pull request fixing a typo in API
+documentation) are greatly appreciated. Before making a large change, it is
+usually a good idea to first open an issue describing the change to solicit
+feedback and guidance. This will increase the likelihood of the PR getting
+merged.
+
+### Tests
+
+If the change being proposed alters code (as opposed to only documentation for
+example), it is either adding new functionality to Tokio or it is fixing
+existing, broken functionality. In both of these cases, the pull request should
+include one or more tests to ensure that Tokio does not regress in the future.
+There are two ways to write tests: integration tests and documentation tests
+(Tokio avoids unit tests as much as possible).
+
+#### Integration tests
+
+Integration tests go in the same crate as the code they are testing. Each sub
+crate should have a `dev-dependency` on `tokio` itself. This makes all Tokio
+utilities available to use in tests, no matter the crate being tested.
+
+The best strategy for writing a new integration test is to look at existing
+integration tests in the crate and follow the style.
+
+#### Documentation tests
+
+Ideally, every API has at least one [documentation test] that demonstrates how to
+use the API. Documentation tests are run with `cargo test --doc`. This ensures
+that the example is correct and provides additional test coverage.
+
+The trick to documentation tests is striking a balance between being succinct
+for a reader to understand and actually testing the API.
+
+Same as with integration tests, when writing a documentation test, the full
+`tokio` crate is available. This is especially useful for getting access to the
+runtime to run the example.
+
+The documentation tests will be visible from both the crate specific
+documentation **and** the `tokio` facade documentation via the re-export. The
+example should be written from the point of view of a user that is using the
+`tokio` crate. As such, the example should use the API via the facade and not by
+directly referencing the crate.
+
+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;
+/// use futures::Stream;
+/// use futures::sync::mpsc;
+/// use std::time::Duration;
+///
+/// # fn main() {
+/// let (tx, rx) = mpsc::unbounded();
+/// # tx.unbounded_send(()).unwrap();
+/// # drop(tx);
+///
+/// let process = rx.for_each(|item| {
+///     // do something with `item`
+/// # drop(item);
+/// # Ok(())
+/// });
+///
+/// # tokio::runtime::current_thread::block_on_all(
+/// // Wrap the future with a `Timeout` set to expire in 10 milliseconds.
+/// process.timeout(Duration::from_millis(10))
+/// # ).unwrap();
+/// # }
+```
+
+Given that this is a *type* level documentation test and the primary way users
+of `tokio` will create an instance of `Timeout` is by using
+`FutureExt::timeout`, this is how the documentation test is structured.
+
+Lines that start with `/// #` are removed when the documentation is generated.
+They are only there to get the test to run. The `block_on_all` function is the
+easiest way to execute a future from a test.
+
+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;
+/// use std::time::Duration;
+///
+/// # fn main() {
+/// let (tx, rx) = oneshot::channel();
+/// # tx.send(()).unwrap();
+///
+/// # tokio::runtime::current_thread::block_on_all(
+/// // Wrap the future with a `Timeout` set to expire in 10 milliseconds.
+/// Timeout::new(rx, Duration::from_millis(10))
+/// # ).unwrap();
+/// # }
+```
+
+### Commits
+
+It is a recommended best practice to keep your changes as logically grouped as
+possible within individual commits. There is no limit to the number of commits
+any single Pull Request may have, and many contributors find it easier to review
+changes that are split across multiple commits.
+
+That said, if you have a number of commits that are "checkpoints" and don't
+represent a single logical change, please squash those together.
+
+Note that multiple commits often get squashed when they are landed (see the
+notes about [commit squashing]).
+
+#### Commit message guidelines
+
+A good commit message should describe what changed and why.
+
+1. The first line should:
+
+  * contain a short description of the change (preferably 50 characters or less,
+    and no more than 72 characters)
+  * be entirely in lowercase with the exception of proper nouns, acronyms, and
+    the words that refer to code, like function/variable names
+  * be prefixed with the name of the sub crate being changed (without the `tokio-`
+    prefix) and start with an imperative verb. If modifying `tokio` proper,
+    omit the crate prefix.
+
+  Examples:
+
+  * timer: introduce `Timeout` and deprecate `Deadline`
+  * export `Encoder`, `Decoder`, `Framed*` from tokio_codec
+
+2. Keep the second line blank.
+3. Wrap all other lines at 72 columns (except for long URLs).
+4. If your patch fixes an open issue, you can add a reference to it at the end
+   of the log. Use the `Fixes: #` prefix and the issue number. For other
+   references use `Refs: #`. `Refs` may include multiple issues, separated by a
+   comma.
+
+   Examples:
+
+   - `Fixes: #1337`
+   - `Refs: #1234`
+
+Sample complete commit message:
+
+```txt
+subcrate: explain the commit in one line
+
+Body of commit message is a few lines of text, explaining things
+in more detail, possibly giving some background about the issue
+being fixed, etc.
+
+The body of the commit message can be several paragraphs, and
+please do proper word-wrap and keep columns shorter than about
+72 characters or so. That way, `git log` will show things
+nicely even when it is indented.
+
+Fixes: #1337
+Refs: #453, #154
+```
+
+### Opening the Pull Request
+
+From within GitHub, opening a new Pull Request will present you with a
+[template] that should be filled out. Please try to do your best at filling out
+the details, but feel free to skip parts if you're not sure what to put.
+
+[template]: .github/PULL_REQUEST_TEMPLATE.md
+
+### Discuss and update
+
+You will probably get feedback or requests for changes to your Pull Request.
+This is a big part of the submission process so don't be discouraged! Some
+contributors may sign off on the Pull Request right away, others may have
+more detailed comments or feedback. This is a necessary part of the process
+in order to evaluate whether the changes are correct and necessary.
+
+**Any community member can review a PR and you might get conflicting feedback**.
+Keep an eye out for comments from code owners to provide guidance on conflicting
+feedback.
+
+**Once the PR is open, do not rebase the commits**. See [Commit Squashing] for
+more details.
+
+### Commit Squashing
+
+In most cases, **do not squash commits that you add to your Pull Request during
+the review process**. When the commits in your Pull Request land, they may be
+squashed into one commit per logical change. Metadata will be added to the
+commit message (including links to the Pull Request, links to relevant issues,
+and the names of the reviewers). The commit history of your Pull Request,
+however, will stay intact on the Pull Request page.
+
+## Reviewing Pull Requests
+
+**Any Tokio community member is welcome to review any pull request**.
+
+All Tokio contributors who choose to review and provide feedback on Pull
+Requests have a responsibility to both the project and the individual making the
+contribution. Reviews and feedback must be helpful, insightful, and geared
+towards improving the contribution as opposed to simply blocking it. If there
+are reasons why you feel the PR should not land, explain what those are. Do not
+expect to be able to block a Pull Request from advancing simply because you say
+"No" without giving an explanation. Be open to having your mind changed. Be open
+to working with the contributor to make the Pull Request better.
+
+Reviews that are dismissive or disrespectful of the contributor or any other
+reviewers are strictly counter to the Code of Conduct.
+
+When reviewing a Pull Request, the primary goals are for the codebase to improve
+and for the person submitting the request to succeed. **Even if a Pull Request
+does not land, the submitters should come away from the experience feeling like
+their effort was not wasted or unappreciated**. Every Pull Request from a new
+contributor is an opportunity to grow the community.
+
+### Review a bit at a time.
+
+Do not overwhelm new contributors.
+
+It is tempting to micro-optimize and make everything about relative performance,
+perfect grammar, or exact style matches. Do not succumb to that temptation.
+
+Focus first on the most significant aspects of the change:
+
+1. Does this change make sense for Tokio?
+2. Does this change make Tokio better, even if only incrementally?
+3. Are there clear bugs or larger scale issues that need attending to?
+4. Is the commit message readable and correct? If it contains a breaking change
+   is it clear enough?
+
+Note that only **incremental** improvement is needed to land a PR. This means
+that the PR does not need to be perfect, only better than the status quo. Follow
+up PRs may be opened to continue iterating.
+
+When changes are necessary, *request* them, do not *demand* them, and **do not
+assume that the submitter already knows how to add a test or run a benchmark**.
+
+Specific performance optimization techniques, coding styles and conventions
+change over time. The first impression you give to a new contributor never does.
+
+Nits (requests for small changes that are not essential) are fine, but try to
+avoid stalling the Pull Request. Most nits can typically be fixed by the Tokio
+Collaborator landing the Pull Request but they can also be an opportunity for
+the contributor to learn a bit more about the project.
+
+It is always good to clearly indicate nits when you comment: e.g.
+`Nit: change foo() to bar(). But this is not blocking.`
+
+If your comments were addressed but were not folded automatically after new
+commits or if they proved to be mistaken, please, [hide them][hiding-a-comment]
+with the appropriate reason to keep the conversation flow concise and relevant.
+
+### Be aware of the person behind the code
+
+Be aware that *how* you communicate requests and reviews in your feedback can
+have a significant impact on the success of the Pull Request. Yes, we may land
+a particular change that makes Tokio better, but the individual might just not
+want to have anything to do with Tokio ever again. The goal is not just having
+good code.
+
+### Abandoned or Stalled Pull Requests
+
+If a Pull Request appears to be abandoned or stalled, it is polite to first
+check with the contributor to see if they intend to continue the work before
+checking if they would mind if you took it over (especially if it just has nits
+left). When doing so, it is courteous to give the original contributor credit
+for the work they started (either by preserving their name and email address in
+the commit log, or by using an `Author: ` meta-data tag in the commit.
+
+_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

Cargo.toml

@@ -1,78 +1,22 @@
-[package]
-name = "tokio"
-
-# When releasing to crates.io:
-# - Update html_root_url.
-# - Update CHANGELOG.md.
-# - Create "v0.1.x" git tag.
-version = "0.1.4"
-authors = ["Carl Lerche <[email protected]>"]
-license = "MIT"
-readme = "README.md"
-repository = "https://github.com/tokio-rs/tokio"
-homepage = "https://tokio.rs"
-documentation = "https://docs.rs/tokio/0.1"
-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",
+  "tokio-buf",
+  "tokio-codec",
+  "tokio-current-thread",
   "tokio-executor",
+  "tokio-fs",
+  "tokio-futures",
   "tokio-io",
   "tokio-reactor",
+  "tokio-signal",
+  "tokio-sync",
+  "tokio-test",
   "tokio-threadpool",
+  "tokio-timer",
   "tokio-tcp",
+  "tokio-tls",
   "tokio-udp",
-  "futures2",
+  "tokio-uds",
 ]
-
-[badges]
-travis-ci = { repository = "tokio-rs/tokio" }
-appveyor = { repository = "carllerche/tokio" }
-
-[dependencies]
-tokio-io = { version = "0.1.6", path = "tokio-io" }
-tokio-executor = { version = "0.1.1", path = "tokio-executor" }
-tokio-reactor = { version = "0.1.1", path = "tokio-reactor" }
-tokio-threadpool = { version = "0.1.1", path = "tokio-threadpool" }
-tokio-tcp = { version = "0.1.0", path = "tokio-tcp" }
-tokio-udp = { version = "0.1.0", path = "tokio-udp" }
-mio = "0.6.14"
-futures = "0.1.19"
-
-# Futures 0.2 integration
-futures2 = { version = "0.1.0", path = "futures2", optional = true }
-
-[dev-dependencies]
-bytes = "0.4"
-env_logger = { version = "0.4", 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"
-
-[patch.crates-io]
-tokio-io = { path = "tokio-io" }
-
-[features]
-unstable-futures = [
-    "futures2",
-    "tokio-reactor/unstable-futures",
-    "tokio-threadpool/unstable-futures",
-    "tokio-executor/unstable-futures",
-    "tokio-tcp/unstable-futures",
-    "tokio-udp/unstable-futures"
-]
-default = []

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2018 Tokio Contributors
+Copyright (c) 2019 Tokio Contributors
 
 Permission is hereby granted, free of charge, to any
 person obtaining a copy of this software and associated

README.md

@@ -14,25 +14,26 @@ the Rust programming language. It is:
 
 [![Crates.io][crates-badge]][crates-url]
 [![MIT licensed][mit-badge]][mit-url]
-[![Travis Build Status][travis-badge]][travis-url]
-[![Appveyor Build Status][appveyor-badge]][appveyor-url]
+[![Build Status][azure-badge]][azure-url]
+[![Gitter chat][gitter-badge]][gitter-url]
 
 [crates-badge]: https://img.shields.io/crates/v/tokio.svg
 [crates-url]: https://crates.io/crates/tokio
 [mit-badge]: https://img.shields.io/badge/license-MIT-blue.svg
-[mit-url]: LICENSE-MIT
-[travis-badge]: https://travis-ci.org/tokio-rs/tokio.svg?branch=master
-[travis-url]: https://travis-ci.org/tokio-rs/tokio
-[appveyor-badge]: https://ci.appveyor.com/api/projects/status/s83yxhy9qeb58va7/branch/master?svg=true
-[appveyor-url]: https://ci.appveyor.com/project/carllerche/tokio/branch/master
+[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)
+[API Docs](https://docs.rs/tokio/0.1.20/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/tokio/
+[master-dox]: https://tokio-rs.github.io/tokio/doc/tokio/
 
 ## Overview
 
@@ -48,9 +49,9 @@ level, it provides a few major components:
 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.1/tokio/reactor/index.html
-[scheduler]: https://tokio-rs.github.io/tokio/tokio/runtime/index.html
+[net]: https://docs.rs/tokio/0.1.20/tokio/net/index.html
+[reactor]: https://docs.rs/tokio/0.1.20/tokio/reactor/index.html
+[scheduler]: https://docs.rs/tokio/0.1.20/tokio/runtime/index.html
 
 ## Example
 
@@ -97,7 +98,25 @@ fn main() {
 }
 ```
 
-More examples can be found [here](examples).
+More examples can be found [here](tokio/examples).
+
+## Getting Help
+
+First, see if the answer to your question can be found in the [Guides] or the
+[API documentation]. If the answer is not there, there is an active community in
+the [Tokio Gitter channel][chat]. We would be happy to try to answer your
+question.  Last, if that doesn't work, try opening an [issue] with the question.
+
+[chat]: https://gitter.im/tokio-rs/tokio
+[issue]: https://github.com/tokio-rs/tokio/issues/new
+
+## Contributing
+
+:balloon: Thanks for your help improving the project! We are so happy to have
+you! We have a [contributing guide][guide] to help you get involved in the Tokio
+project.
+
+[guide]: CONTRIBUTING.md
 
 ## Project layout
 
@@ -107,26 +126,74 @@ have greater guarantees of stability.
 
 The crates included as part of Tokio are:
 
+* [`tokio-current-thread`]: Schedule the execution of futures on the current
+  thread.
+
 * [`tokio-executor`]: Task execution related traits and utilities.
 
+* [`tokio-fs`]: Filesystem (and standard in / out) APIs.
+
+* [`tokio-futures`]: Experimental `std::future::Future` and `async` / `await` support.
+
+* [`tokio-codec`]: Utilities for encoding and decoding protocol frames.
+
 * [`tokio-io`]: Asynchronous I/O related traits and utilities.
 
+* [`tokio-macros`]: Macros for usage with Tokio.
+
 * [`tokio-reactor`]: Event loop that drives I/O resources (like TCP and UDP
   sockets).
 
+* [`tokio-tcp`]: TCP bindings for use with `tokio-io` and `tokio-reactor`.
+
 * [`tokio-threadpool`]: Schedules the execution of futures across a pool of
   threads.
 
-* [`tokio-tcp`]: TCP bindings for use with `tokio-io` and `tokio-reactor`.
+* [ `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-codec`]: tokio-codec
+[`tokio-current-thread`]: tokio-current-thread
 [`tokio-executor`]: tokio-executor
+[`tokio-fs`]: tokio-fs
+[`tokio-futures`]: tokio-futures
 [`tokio-io`]: tokio-io
+[`tokio-macros`]: tokio-macros
 [`tokio-reactor`]: tokio-reactor
-[`tokio-threadpool`]: tokio-threadpool
 [`tokio-tcp`]: tokio-tcp
+[`tokio-threadpool`]: tokio-threadpool
+[`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
+
+Tokio is built against the latest stable, nightly, and beta Rust releases. The
+minimum version supported is the stable release from three months before the
+current stable release version. For example, if the latest stable Rust is 1.29,
+the minimum version supported is 1.26. The current Tokio version is not
+guaranteed to build on Rust versions earlier than the minimum supported version.
 
 ## License
 

async-await/.cargo/config

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

async-await/Cargo.toml

@@ -0,0 +1,49 @@
+[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.18", 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" }
+tokio-codec = { path = "../tokio-codec" }
+tokio-current-thread = { path = "../tokio-current-thread" }
+tokio-executor = { path = "../tokio-executor" }
+tokio-fs = { path = "../tokio-fs" }
+tokio-futures  = { path = "../tokio-futures" }
+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" }

async-await/README.md

@@ -0,0 +1,5 @@
+# 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.

async-await/src/chat.rs

@@ -0,0 +1,131 @@
+#![feature(await_macro, async_await)]
+
+use tokio::await;
+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(())
+}
+
+#[tokio::main]
+async 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.
+    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");
+            }
+        });
+    }
+}
+

async-await/src/echo_client.rs

@@ -0,0 +1,50 @@
+#![feature(await_macro, async_await)]
+
+use tokio::await;
+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(())
+}
+
+#[tokio::main]
+async 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
+
+    match await!(run_client(&addr)) {
+        Ok(_) => println!("done."),
+        Err(e) => eprintln!("echo client failed; error = {:?}", e),
+    }
+}

async-await/src/echo_server.rs

@@ -0,0 +1,42 @@
+#![feature(await_macro, async_await)]
+
+use tokio::await;
+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();
+                }
+            }
+        }
+    });
+}
+
+#[tokio::main]
+async 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);
+
+    let mut incoming = listener.incoming();
+
+    while let Some(stream) = await!(incoming.next()) {
+        let stream = stream.unwrap();
+        handle(stream);
+    }
+}

async-await/src/hyper.rs

@@ -0,0 +1,29 @@
+#![feature(await_macro, async_await)]
+
+use tokio::await;
+use tokio::prelude::*;
+use hyper::Client;
+
+use std::time::Duration;
+use std::str;
+
+#[tokio::main]
+async fn main() {
+    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());
+    }
+}

async-await/tests/macros.rs

@@ -0,0 +1,22 @@
+#![feature(await_macro, async_await)]
+
+use tokio::await;
+use tokio::timer::Delay;
+use std::time::{Duration, Instant};
+
+#[tokio::test]
+async fn success_no_async() {
+    assert!(true);
+}
+
+#[tokio::test]
+#[should_panic]
+async fn fail_no_async() {
+    assert!(false);
+}
+
+#[tokio::test]
+async fn use_timer() {
+    let when = Instant::now() + Duration::from_millis(10);
+    await!(Delay::new(when));
+}

azure-pipelines.yml

@@ -0,0 +1,111 @@
+trigger: ["master", "v0.1.x"]
+pr: ["master", "v0.1.x"]
+
+jobs:
+# Check formatting
+- template: ci/azure-rustfmt.yml
+  parameters:
+    name: rustfmt
+
+# Test top level crate
+- template: ci/azure-test-stable.yml
+  parameters:
+    name: test_tokio
+    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 -
+    crates:
+      - tokio-buf
+      - tokio-codec
+      - tokio-current-thread
+      - tokio-executor
+      - tokio-io
+      - tokio-sync
+      - tokio-threadpool
+      - tokio-timer
+      - tokio-test
+
+- template: ci/azure-cargo-check.yml
+  parameters:
+    name: features
+    displayName: Check feature permtuations
+    rust: stable
+    crates:
+      tokio:
+        - codec
+        - fs
+        - io
+        - reactor
+        - rt-full
+        - tcp
+        - timer
+        - udp
+        - uds
+        - sync
+        - experimental-tracing
+      tokio-buf:
+        - util
+
+# Run async-await tests
+- template: ci/azure-test-nightly.yml
+  parameters:
+    name: test_nightly
+    displayName: Test Async / Await
+    rust: nightly-2019-04-25
+
+# Try cross compiling
+- template: ci/azure-cross-compile.yml
+  parameters:
+    name: cross_32bit_linux
+    target: i686-unknown-linux-gnu
+
+# 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.31.0
+
+- template: ci/azure-tsan.yml
+  parameters:
+    name: tsan
+
+- template: ci/azure-deploy-docs.yml
+  parameters:
+    dependsOn:
+      - rustfmt
+      - test_tokio
+      - test_sub_cross
+      - test_linux
+      - features
+      - test_nightly
+      - cross_32bit_linux
+      - minrust
+      - tsan

benches/latency.rs

@@ -1,5 +1,4 @@
 #![feature(test)]
-#![deny(warnings)]
 
 extern crate test;
 #[macro_use]
@@ -10,8 +9,8 @@ use std::io;
 use std::net::SocketAddr;
 use std::thread;
 
-use futures::sync::oneshot;
 use futures::sync::mpsc;
+use futures::sync::oneshot;
 use futures::{Future, Poll, Sink, Stream};
 use test::Bencher;
 use tokio::net::UdpSocket;
@@ -57,7 +56,6 @@ fn udp_echo_latency(b: &mut Bencher) {
     let (tx, rx) = oneshot::channel();
 
     let child = thread::spawn(move || {
-
         let socket = tokio::net::UdpSocket::bind(&any_addr).unwrap();
         tx.send(socket.local_addr().unwrap()).unwrap();
 
@@ -67,7 +65,6 @@ fn udp_echo_latency(b: &mut Bencher) {
         server.wait().unwrap();
     });
 
-
     let client = std::net::UdpSocket::bind(&any_addr).unwrap();
 
     let server_addr = rx.wait().unwrap();

benches/mio-ops.rs

@@ -1,16 +1,14 @@
 // Measure cost of different operations
 // to get a sense of performance tradeoffs
 #![feature(test)]
-#![deny(warnings)]
 
-extern crate test;
 extern crate mio;
+extern crate test;
 
 use test::Bencher;
 
 use mio::tcp::TcpListener;
-use mio::{Token, Ready, PollOpt};
-
+use mio::{PollOpt, Ready, Token};
 
 #[bench]
 fn mio_register_deregister(b: &mut Bencher) {
@@ -22,8 +20,8 @@ fn mio_register_deregister(b: &mut Bencher) {
     const CLIENT: Token = Token(1);
 
     b.iter(|| {
-        poll.register(&sock, CLIENT, Ready::readable(),
-              PollOpt::edge()).unwrap();
+        poll.register(&sock, CLIENT, Ready::readable(), PollOpt::edge())
+            .unwrap();
         poll.deregister(&sock).unwrap();
     });
 }
@@ -36,12 +34,12 @@ fn mio_reregister(b: &mut Bencher) {
     let poll = mio::Poll::new().unwrap();
 
     const CLIENT: Token = Token(1);
-    poll.register(&sock, CLIENT, Ready::readable(),
-    PollOpt::edge()).unwrap();
+    poll.register(&sock, CLIENT, Ready::readable(), PollOpt::edge())
+        .unwrap();
 
     b.iter(|| {
-        poll.reregister(&sock, CLIENT, Ready::readable(),
-        PollOpt::edge()).unwrap();
+        poll.reregister(&sock, CLIENT, Ready::readable(), PollOpt::edge())
+            .unwrap();
     });
     poll.deregister(&sock).unwrap();
 }

benches/tcp.rs

@@ -1,5 +1,4 @@
 #![feature(test)]
-#![deny(warnings)]
 
 extern crate futures;
 extern crate tokio;
@@ -11,19 +10,18 @@ pub extern crate test;
 
 mod prelude {
     pub use futures::*;
-    pub use tokio::reactor::Reactor;
     pub use tokio::net::{TcpListener, TcpStream};
-    pub use tokio::executor::current_thread;
+    pub use tokio::reactor::Reactor;
     pub use tokio_io::io::read_to_end;
 
-    pub use test::{self, Bencher};
+    pub use std::io::{self, Read, Write};
     pub use std::thread;
     pub use std::time::Duration;
-    pub use std::io::{self, Read, Write};
+    pub use test::{self, Bencher};
 }
 
 mod connect_churn {
-    use ::prelude::*;
+    use prelude::*;
 
     const NUM: usize = 300;
     const CONCURRENT: usize = 8;
@@ -37,25 +35,29 @@ mod connect_churn {
             let addr = listener.local_addr().unwrap();
 
             // Spawn a single future that accepts & drops connections
-            let serve_incomings = listener.incoming()
+            let serve_incomings = listener
+                .incoming()
                 .map_err(|e| panic!("server err: {:?}", e))
                 .for_each(|_| Ok(()));
 
             let connects = stream::iter_result((0..NUM).map(|_| {
-                Ok(TcpStream::connect(&addr)
-                    .and_then(|sock| {
-                        sock.set_linger(Some(Duration::from_secs(0))).unwrap();
-                        read_to_end(sock, vec![])
-                    }))
+                Ok(TcpStream::connect(&addr).and_then(|sock| {
+                    sock.set_linger(Some(Duration::from_secs(0))).unwrap();
+                    read_to_end(sock, vec![])
+                }))
             }));
 
-            let connects_concurrent = connects.buffer_unordered(CONCURRENT)
+            let connects_concurrent = connects
+                .buffer_unordered(CONCURRENT)
                 .map_err(|e| panic!("client err: {:?}", e))
                 .for_each(|_| Ok(()));
 
-            serve_incomings.select(connects_concurrent)
-                .map(|_| ()).map_err(|_| ())
-                .wait().unwrap();
+            serve_incomings
+                .select(connects_concurrent)
+                .map(|_| ())
+                .map_err(|_| ())
+                .wait()
+                .unwrap();
         });
     }
 
@@ -66,8 +68,7 @@ mod connect_churn {
         // Spawn reactor thread
         let server_thread = thread::spawn(move || {
             // Bind the TCP listener
-            let listener = TcpListener::bind(
-                &"127.0.0.1:0".parse().unwrap()).unwrap();
+            let listener = TcpListener::bind(&"127.0.0.1:0".parse().unwrap()).unwrap();
 
             // Get the address being listened on.
             let addr = listener.local_addr().unwrap();
@@ -76,47 +77,56 @@ mod connect_churn {
             addr_tx.send(addr).unwrap();
 
             // Spawn a single future that accepts & drops connections
-            let serve_incomings = listener.incoming()
+            let serve_incomings = listener
+                .incoming()
                 .map_err(|e| panic!("server err: {:?}", e))
                 .for_each(|_| Ok(()));
 
             // Run server
-            serve_incomings.select(shutdown_rx)
-                .map(|_| ()).map_err(|_| ())
-                .wait().unwrap();
+            serve_incomings
+                .select(shutdown_rx)
+                .map(|_| ())
+                .map_err(|_| ())
+                .wait()
+                .unwrap();
         });
 
         // Get the bind addr of the server
         let addr = addr_rx.wait().unwrap();
 
         b.iter(move || {
-            use std::sync::{Barrier, Arc};
+            use std::sync::{Arc, Barrier};
 
             // Create a barrier to coordinate threads
             let barrier = Arc::new(Barrier::new(n + 1));
 
             // Spawn worker threads
-            let threads: Vec<_> = (0..n).map(|_| {
-                let barrier = barrier.clone();
-                let addr = addr.clone();
+            let threads: Vec<_> = (0..n)
+                .map(|_| {
+                    let barrier = barrier.clone();
+                    let addr = addr.clone();
 
-                thread::spawn(move || {
-                    let connects = stream::iter_result((0..(NUM / n)).map(|_| {
-                        Ok(TcpStream::connect(&addr)
-                            .map_err(|e| panic!("connect err: {:?}", e))
-                            .and_then(|sock| {
-                                sock.set_linger(Some(Duration::from_secs(0))).unwrap();
-                                read_to_end(sock, vec![])
-                            }))
-                    }));
+                    thread::spawn(move || {
+                        let connects = stream::iter_result((0..(NUM / n)).map(|_| {
+                            Ok(TcpStream::connect(&addr)
+                                .map_err(|e| panic!("connect err: {:?}", e))
+                                .and_then(|sock| {
+                                    sock.set_linger(Some(Duration::from_secs(0))).unwrap();
+                                    read_to_end(sock, vec![])
+                                }))
+                        }));
 
-                    barrier.wait();
+                        barrier.wait();
 
-                    connects.buffer_unordered(CONCURRENT)
-                        .map_err(|e| panic!("client err: {:?}", e))
-                        .for_each(|_| Ok(())).wait().unwrap();
+                        connects
+                            .buffer_unordered(CONCURRENT)
+                            .map_err(|e| panic!("client err: {:?}", e))
+                            .for_each(|_| Ok(()))
+                            .wait()
+                            .unwrap();
+                    })
                 })
-            }).collect();
+                .collect();
 
             barrier.wait();
 
@@ -142,7 +152,7 @@ mod connect_churn {
 }
 
 mod transfer {
-    use ::prelude::*;
+    use prelude::*;
     use std::{cmp, mem};
 
     const MB: usize = 3 * 1024 * 1024;
@@ -201,7 +211,8 @@ mod transfer {
             let addr = listener.local_addr().unwrap();
 
             // Spawn a single future that accepts 1 connection, Drain it and drops
-            let server = listener.incoming()
+            let server = listener
+                .incoming()
                 .into_future() // take the first connection
                 .map_err(|(e, _other_incomings)| e)
                 .map(|(connection, _other_incomings)| connection.unwrap())
@@ -211,17 +222,17 @@ mod transfer {
                         sock: sock,
                         chunk: read_size,
                     };
-                    drain.map(|_| ()).map_err(|e| panic!("server error: {:?}", e))
+                    drain
+                        .map(|_| ())
+                        .map_err(|e| panic!("server error: {:?}", e))
                 })
                 .map_err(|e| panic!("server err: {:?}", e));
 
             let client = TcpStream::connect(&addr)
-                .and_then(move |sock| {
-                    Transfer {
-                        sock: sock,
-                        rem: MB,
-                        chunk: write_size,
-                    }
+                .and_then(move |sock| Transfer {
+                    sock: sock,
+                    rem: MB,
+                    chunk: write_size,
                 })
                 .map_err(|e| panic!("client err: {:?}", e));
 
@@ -230,7 +241,7 @@ mod transfer {
     }
 
     mod small_chunks {
-        use ::prelude::*;
+        use prelude::*;
 
         #[bench]
         fn one_thread(b: &mut Bencher) {
@@ -239,7 +250,7 @@ mod transfer {
     }
 
     mod big_chunks {
-        use ::prelude::*;
+        use prelude::*;
 
         #[bench]
         fn one_thread(b: &mut Bencher) {

ci/azure-cargo-check.yml

@@ -0,0 +1,29 @@
+parameters:
+  noDefaultFeatures: '--no-default-features'
+
+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-is-release.yml
+
+  - ${{ 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 }}
+        condition: and(succeeded(), not(variables['isRelease']))
+
+  - template: azure-patch-crates.yml
+
+  - ${{ 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

@@ -0,0 +1,14 @@
+jobs:
+- job: ${{ parameters.name }}
+  displayName: Min supported Rust version
+  pool:
+    vmImage: ubuntu-16.04
+  steps:
+  - template: azure-install-rust.yml
+    parameters:
+      rust_version: ${{ parameters.rust_version }}
+
+  - template: azure-patch-crates.yml
+
+  - script: cargo check --all
+    displayName: cargo check --all

ci/azure-cross-compile.yml

@@ -0,0 +1,27 @@
+jobs:
+- job: ${{ parameters.name }}
+  displayName: ${{ parameters.displayName }}
+  pool:
+    vmImage: ubuntu-16.04
+  steps:
+  - template: azure-install-rust.yml
+    parameters:
+      rust_version: stable
+
+  - script: sudo apt-get update
+    displayName: "apt-get update"
+
+  - script: sudo apt-get install gcc-multilib
+    displayName: "Install gcc-multilib"
+
+  - script: rustup target add ${{ parameters.target }}
+    displayName: "Add target"
+
+  # Always patch
+  - template: azure-patch-crates.yml
+
+  - script: cargo check --all --exclude tokio-tls --target ${{ parameters.target }}
+    displayName: Check source
+
+  - script: cargo check --tests --all --exclude tokio-tls --target ${{ parameters.target }}
+    displayName: Check tests

ci/azure-deploy-docs.yml

@@ -0,0 +1,38 @@
+parameters:
+  dependsOn: []
+
+jobs:
+- job: documentation
+  displayName: 'Deploy API Documentation'
+  condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/master'))
+  pool:
+    vmImage: 'Ubuntu 16.04'
+  dependsOn:
+    - ${{ parameters.dependsOn }}
+  steps:
+  - template: azure-install-rust.yml
+    parameters:
+      rust_version: stable
+  - script: |
+      cargo doc --all --no-deps
+      cp -R target/doc '$(Build.BinariesDirectory)'
+    displayName: 'Generate Documentation'
+  - script: |
+      set -e
+
+      git --version
+      ls -la
+      git init
+      git config user.name 'Deployment Bot (from Azure Pipelines)'
+      git config user.email '[email protected]'
+      git config --global credential.helper 'store --file ~/.my-credentials'
+      printf "protocol=https\nhost=github.com\nusername=carllerche\npassword=%s\n\n" "$GITHUB_TOKEN" | git credential-store --file ~/.my-credentials store
+      git remote add origin https://github.com/tokio-rs/tokio
+      git checkout -b gh-pages
+      git add .
+      git commit -m 'Deploy Tokio API documentation'
+      git push -f origin gh-pages
+    env:
+      GITHUB_TOKEN: $(githubPersonalToken)
+    workingDirectory: '$(Build.BinariesDirectory)'
+    displayName: 'Deploy Documentation'

ci/azure-install-rust.yml

@@ -0,0 +1,33 @@
+steps:
+  # Linux and macOS.
+  - script: |
+      set -e
+      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}}
+    displayName: "Install rust (*nix)"
+    condition: not(eq(variables['Agent.OS'], 'Windows_NT'))
+
+  # Windows.
+  - script: |
+      echo "windows"
+      curl -sSf -o rustup-init.exe https://win.rustup.rs
+      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}}
+    displayName: Install rust (windows)
+    condition: eq(variables['Agent.OS'], 'Windows_NT')
+
+  # All platforms.
+  - script: |
+        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

@@ -0,0 +1,16 @@
+jobs:
+# Check formatting
+- job: ${{ parameters.name }}
+  displayName: Check rustfmt
+  pool:
+    vmImage: ubuntu-16.04
+  steps:
+    - template: azure-install-rust.yml
+      parameters:
+        rust_version: stable
+    - script: |
+        rustup component add rustfmt
+      displayName: Install rustfmt
+    - script: |
+        cargo fmt --all -- --check
+      displayName: Check formatting

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

@@ -0,0 +1,41 @@
+jobs:
+- job: ${{ parameters.name }}
+  displayName: ${{ parameters.displayName }}
+  strategy:
+    matrix:
+      Linux:
+        vmImage: ubuntu-16.04
+
+      ${{ if parameters.cross }}:
+        MacOS:
+          vmImage: macOS-10.13
+        Windows:
+          vmImage: vs2017-win2016
+  pool:
+    vmImage: $(vmImage)
+
+  steps:
+  - template: azure-install-rust.yml
+    parameters:
+      rust_version: stable
+
+  - template: azure-is-release.yml
+
+  - ${{ each crate in parameters.crates }}:
+    - script: cargo test
+      env:
+        LOOM_MAX_DURATION: 10
+        CI: 'True'
+      displayName: cargo test -p ${{ crate }}
+      workingDirectory: $(Build.SourcesDirectory)/${{ crate }}
+      condition: and(succeeded(), ne(variables['isRelease'], 'true'))
+
+  - template: azure-patch-crates.yml
+
+  - ${{ each crate in parameters.crates }}:
+    - script: cargo test
+      env:
+        LOOM_MAX_DURATION: 10
+        CI: 'True'
+      displayName: cargo test -p ${{ crate }} (PATCHED)
+      workingDirectory: $(Build.SourcesDirectory)/${{ crate }}

ci/azure-tsan.yml

@@ -0,0 +1,36 @@
+jobs:
+- job: ${{ parameters.name }}
+  displayName: TSAN
+  strategy:
+    matrix:
+      Timer:
+        cmd: cargo test -p tokio-timer --test hammer
+      Threadpool:
+        cmd: cargo test -p tokio-threadpool --tests
+  pool:
+    vmImage: ubuntu-16.04
+  steps:
+  - template: azure-install-rust.yml
+    parameters:
+      rust_version: nightly-2019-07-17
+
+  - 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"
+        export RUST_BACKTRACE=1
+
+        # Run address sanitizer
+        RUSTFLAGS="-Z sanitizer=address" \
+        $(cmd) --target x86_64-unknown-linux-gnu
+
+        # Run thread sanitizer
+        RUSTFLAGS="-Z sanitizer=thread" \
+        $(cmd) --target x86_64-unknown-linux-gnu
+    displayName: TSAN / MSAN
+    env:
+      TSAN: yes
+

ci/patch.toml

@@ -0,0 +1,20 @@
+# Patch dependencies to run all tests against versions of the crate in the
+# repository.
+[patch.crates-io]
+tokio = { path = "tokio" }
+tokio-buf = { path = "tokio-buf" }
+tokio-codec = { path = "tokio-codec" }
+tokio-current-thread = { path = "tokio-current-thread" }
+tokio-executor = { path = "tokio-executor" }
+tokio-fs = { path = "tokio-fs" }
+tokio-futures = { path = "tokio-futures" }
+tokio-io = { path = "tokio-io" }
+tokio-reactor = { path = "tokio-reactor" }
+tokio-signal = { path = "tokio-signal" }
+tokio-sync = { path = "tokio-sync" }
+tokio-threadpool = { path = "tokio-threadpool" }
+tokio-timer = { path = "tokio-timer" }
+tokio-tcp = { path = "tokio-tcp" }
+tokio-tls = { path = "tokio-tls" }
+tokio-udp = { path = "tokio-udp" }
+tokio-uds = { path = "tokio-uds" }

ci/tsan

@@ -0,0 +1,44 @@
+# TSAN suppressions file for Tokio
+
+# TSAN does not understand fences and `Arc::drop` is implemented using a fence.
+# This causes many false positives.
+race:Arc*drop
+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
+
+# Probably more fences in std.
+race:__call_tls_dtors
+
+# The epoch-based GC uses fences.
+race:crossbeam_epoch
+
+# Push and steal operations in crossbeam-deque may cause data races, but such
+# data races are safe. If a data race happens, the value read by `steal` is
+# forgotten and the steal operation is then retried.
+race:crossbeam_deque*push
+race:crossbeam_deque*steal
+
+# This filters out expected data race in the Treiber stack implementations.
+# Treiber stacks are inherently racy. The pop operation will attempt to access
+# the "next" pointer on the node it is attempting to pop. However, at this
+# point it has not gained ownership of the node and another thread might beat
+# it and take ownership of the node first (touching the next pointer). The
+# original pop operation will fail due to the ABA guard, but tsan still picks
+# up the access on the next pointer.
+race:Backup::next_sleeper
+race:Backup::set_next_sleeper
+race:WorkerEntry::set_next_sleeper
+
+# This ignores a false positive caused by `thread::park()`/`thread::unpark()`.
+# See: https://github.com/rust-lang/rust/pull/54806#issuecomment-436193353
+race:pthread_cond_destroy
+
+# Recent rand dependency updates and seeding changes have introduced
+# lazy_static's and other racy code. See:
+# https://github.com/tokio-rs/tokio/pull/1358#issuecomment-516172383
+race:RandomState*::build_hasher
+race:lazy_static::
+race:c2_chacha::guts

examples/hello_world.rs

@@ -1,70 +0,0 @@
-//! Hello world server.
-//!
-//! A simple server that accepts connections, writes "hello world\n", and closes
-//! the connection.
-//!
-//! You can test this out by running:
-//!
-//!     cargo run --example hello_world
-//!
-//! And then in another terminal run:
-//!
-//!     telnet localhost 6142
-//!
-
-#![deny(warnings)]
-
-extern crate tokio;
-
-use tokio::io;
-use tokio::net::TcpListener;
-use tokio::prelude::*;
-
-pub fn main() {
-    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();
-
-    // The server task asynchronously iterates over and processes each
-    // incoming connection.
-    let server = listener.incoming().for_each(|socket| {
-        println!("accepted socket; addr={:?}", socket.peer_addr().unwrap());
-
-        let connection = io::write_all(socket, "hello world\n")
-            .then(|res| {
-                println!("wrote message; success={:?}", res.is_ok());
-                Ok(())
-            });
-
-        // Spawn a new task that processes the socket:
-        tokio::spawn(connection);
-
-        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);
-}

futures2/Cargo.toml

@@ -1,11 +0,0 @@
-[package]
-name = "futures2"
-
-version = "0.1.0"
-authors = ["Aaron Turon <[email protected]>"]
-license = "MIT/Apache-2.0"
-repository = "https://github.com/tokio-rs/tokio"
-homepage = "https://tokio.rs"
-
-[dependencies]
-futures = "=0.2.0-beta"

futures2/src/lib.rs

@@ -1,2 +0,0 @@
-extern crate futures;
-pub use futures::*;

src/executor/current_thread/mod.rs

@@ -1,730 +0,0 @@
-//! 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
-
-#![allow(deprecated)]
-
-mod scheduler;
-use self::scheduler::Scheduler;
-
-use tokio_executor::{self, Enter, SpawnError};
-use tokio_executor::park::{Park, Unpark, ParkThread};
-
-use futures::{executor, Async, Future};
-use futures::future::{self, Executor, ExecuteError, ExecuteErrorKind};
-
-use std::fmt;
-use std::cell::Cell;
-use std::marker::PhantomData;
-use std::rc::Rc;
-use std::time::{Duration, Instant};
-
-#[cfg(feature = "unstable-futures")]
-use futures2;
-
-/// Executes tasks on the current thread
-pub struct CurrentThread<P: Park = ParkThread> {
-    /// Execute futures and receive unpark notifications.
-    scheduler: Scheduler<P::Unpark>,
-
-    /// Current number of futures being executed
-    num_futures: usize,
-
-    /// Thread park handle
-    park: P,
-}
-
-/// Executes futures on the current thread.
-///
-/// All futures executed using this executor will be executed on the current
-/// thread. As such, `run` will wait for these futures to complete before
-/// returning.
-///
-/// For more details, see the [module level](index.html) documentation.
-#[derive(Debug, Clone)]
-pub struct TaskExecutor {
-    // Prevent the handle from moving across threads.
-    _p: ::std::marker::PhantomData<Rc<()>>,
-}
-
-/// Returned by the `turn` function
-#[derive(Debug)]
-pub struct Turn(());
-
-/// A `CurrentThread` instance bound to a supplied execution conext.
-pub struct Entered<'a, P: Park + 'a> {
-    executor: &'a mut CurrentThread<P>,
-    enter: &'a mut Enter,
-}
-
-#[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 ()>,
-}
-
-/// Error returned by the `run` function.
-#[derive(Debug)]
-pub struct RunError {
-    _p: (),
-}
-
-/// Error returned by the `run_timeout` function.
-#[derive(Debug)]
-pub struct RunTimeoutError {
-    timeout: bool,
-}
-
-/// Error returned by the `turn` function.
-#[derive(Debug)]
-pub struct TurnError {
-    _p: (),
-}
-
-/// Error returned by the `block_on` function.
-#[derive(Debug)]
-pub struct BlockError<T> {
-    inner: Option<T>,
-}
-
-/// This is mostly split out to make the borrow checker happy.
-struct Borrow<'a, U: 'a> {
-    scheduler: &'a mut Scheduler<U>,
-    num_futures: &'a mut usize,
-}
-
-trait SpawnLocal {
-    fn spawn_local(&mut self, future: Box<Future<Item = (), Error = ()>>);
-}
-
-struct CurrentRunner {
-    spawn: Cell<Option<*mut SpawnLocal>>,
-}
-
-/// Current thread's task runner. This is set in `TaskRunner::with`
-thread_local!(static CURRENT: CurrentRunner = CurrentRunner {
-    spawn: Cell::new(None),
-});
-
-#[deprecated(since = "0.1.2", note = "use block_on_all instead")]
-#[doc(hidden)]
-#[allow(deprecated)]
-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
-}
-
-/// Run the executor bootstrapping the execution with the provided future.
-///
-/// This creates a new [`CurrentThread`] executor, spawns the provided future,
-/// and blocks the current thread until the provided future and **all**
-/// subsequently spawned futures complete. In other words:
-///
-/// * If the provided boostrap future does **not** spawn any additional tasks,
-///   `block_on_all` returns once `future` completes.
-/// * If the provided bootstrap future **does** spawn additional tasks, then
-///   `block_on_all` returns once **all** spawned futures complete.
-///
-/// See [module level][mod] documentation for more details.
-///
-/// [`CurrentThread`]: struct.CurrentThread.html
-/// [mod]: index.html
-pub fn block_on_all<F>(future: F) -> Result<F::Item, F::Error>
-where F: Future,
-{
-    let mut current_thread = CurrentThread::new();
-
-    let ret = current_thread.block_on(future);
-    current_thread.run().unwrap();
-
-    ret.map_err(|e| e.into_inner().expect("unexpected execution error"))
-}
-
-/// Executes a future on the current thread.
-///
-/// The provided future must complete or be canceled before `run` will return.
-///
-/// Unlike [`tokio::spawn`], this function will always spawn on a
-/// `CurrentThread` executor and is able to spawn futures that are not `Send`.
-///
-/// # Panics
-///
-/// This function can only be invoked from the context of a `run` call; any
-/// other use will result in a panic.
-///
-/// [`tokio::spawn`]: ../fn.spawn.html
-pub fn spawn<F>(future: F)
-where F: Future<Item = (), Error = ()> + 'static
-{
-    TaskExecutor::current()
-        .spawn_local(Box::new(future))
-        .unwrap();
-}
-
-// ===== impl CurrentThread =====
-
-impl CurrentThread<ParkThread> {
-    /// Create a new instance of `CurrentThread`.
-    pub fn new() -> Self {
-        CurrentThread::new_with_park(ParkThread::new())
-    }
-}
-
-impl<P: Park> CurrentThread<P> {
-    /// Create a new instance of `CurrentThread` backed by the given park
-    /// handle.
-    pub fn new_with_park(park: P) -> Self {
-        let unpark = park.unpark();
-
-        CurrentThread {
-            scheduler: Scheduler::new(unpark),
-            num_futures: 0,
-            park,
-        }
-    }
-
-    /// Returns `true` if the executor is currently idle.
-    ///
-    /// An idle executor is defined by not currently having any spawned tasks.
-    pub fn is_idle(&self) -> bool {
-        self.num_futures == 0
-    }
-
-    /// Spawn the future on the executor.
-    ///
-    /// This internally queues the future to be executed once `run` is called.
-    pub fn spawn<F>(&mut self, future: F) -> &mut Self
-    where F: Future<Item = (), Error = ()> + 'static,
-    {
-        self.borrow().spawn_local(Box::new(future));
-        self
-    }
-
-    /// Synchronously waits for the provided `future` to complete.
-    ///
-    /// This function can be used to synchronously block the current thread
-    /// until the provided `future` has resolved either successfully or with an
-    /// error. The result of the future is then returned from this function
-    /// call.
-    ///
-    /// Note that this function will **also** execute any spawned futures on the
-    /// current thread, but will **not** block until these other spawned futures
-    /// have completed.
-    ///
-    /// The caller is responsible for ensuring that other spawned futures
-    /// complete execution.
-    pub fn block_on<F>(&mut self, future: F)
-        -> Result<F::Item, BlockError<F::Error>>
-    where F: Future
-    {
-        let mut enter = tokio_executor::enter().unwrap();
-        self.enter(&mut enter).block_on(future)
-    }
-
-    /// Run the executor to completion, blocking the thread until **all**
-    /// spawned futures have completed.
-    pub fn run(&mut self) -> Result<(), RunError> {
-        let mut enter = tokio_executor::enter().unwrap();
-        self.enter(&mut enter).run()
-    }
-
-    /// Run the executor to completion, blocking the thread until all
-    /// spawned futures have completed **or** `duration` time has elapsed.
-    pub fn run_timeout(&mut self, duration: Duration)
-        -> Result<(), RunTimeoutError>
-    {
-        let mut enter = tokio_executor::enter().unwrap();
-        self.enter(&mut enter).run_timeout(duration)
-    }
-
-    /// Perform a single iteration of the event loop.
-    ///
-    /// This function blocks the current thread even if the executor is idle.
-    pub fn turn(&mut self, duration: Option<Duration>)
-        -> Result<Turn, TurnError>
-    {
-        let mut enter = tokio_executor::enter().unwrap();
-        self.enter(&mut enter).turn(duration)
-    }
-
-    /// Bind `CurrentThread` instance with an execution context.
-    pub fn enter<'a>(&'a mut self, enter: &'a mut Enter) -> Entered<'a, P> {
-        Entered {
-            executor: self,
-            enter,
-        }
-    }
-
-    fn borrow(&mut self) -> Borrow<P::Unpark> {
-        Borrow {
-            scheduler: &mut self.scheduler,
-            num_futures: &mut self.num_futures,
-        }
-    }
-}
-
-impl tokio_executor::Executor for CurrentThread {
-    fn spawn(&mut self, future: Box<Future<Item = (), Error = ()> + Send>)
-        -> Result<(), SpawnError>
-    {
-        self.borrow().spawn_local(future);
-        Ok(())
-    }
-
-    #[cfg(feature = "unstable-futures")]
-    fn spawn2(&mut self, _future: Box<futures2::Future<Item = (), Error = futures2::Never> + Send>)
-        -> Result<(), futures2::executor::SpawnError>
-    {
-        panic!("Futures 0.2 integration is not available for current_thread");
-    }
-}
-
-impl<P: Park> fmt::Debug for CurrentThread<P> {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        fmt.debug_struct("CurrentThread")
-            .field("scheduler", &self.scheduler)
-            .field("num_futures", &self.num_futures)
-            .finish()
-    }
-}
-
-// ===== impl Entered =====
-
-impl<'a, P: Park> Entered<'a, P> {
-    /// Spawn the future on the executor.
-    ///
-    /// This internally queues the future to be executed once `run` is called.
-    pub fn spawn<F>(&mut self, future: F) -> &mut Self
-    where F: Future<Item = (), Error = ()> + 'static,
-    {
-        self.executor.borrow().spawn_local(Box::new(future));
-        self
-    }
-
-    /// Synchronously waits for the provided `future` to complete.
-    ///
-    /// This function can be used to synchronously block the current thread
-    /// until the provided `future` has resolved either successfully or with an
-    /// error. The result of the future is then returned from this function
-    /// call.
-    ///
-    /// Note that this function will **also** execute any spawned futures on the
-    /// current thread, but will **not** block until these other spawned futures
-    /// have completed.
-    ///
-    /// The caller is responsible for ensuring that other spawned futures
-    /// complete execution.
-    pub fn block_on<F>(&mut self, future: F)
-        -> Result<F::Item, BlockError<F::Error>>
-    where F: Future
-    {
-        let mut future = executor::spawn(future);
-        let notify = self.executor.scheduler.notify();
-
-        loop {
-            let res = self.executor.borrow().enter(self.enter, || {
-                future.poll_future_notify(&notify, 0)
-            });
-
-            match res {
-                Ok(Async::Ready(e)) => return Ok(e),
-                Err(e) => return Err(BlockError { inner: Some(e) }),
-                Ok(Async::NotReady) => {}
-            }
-
-            self.tick();
-
-            if let Err(_) = self.executor.park.park() {
-                return Err(BlockError { inner: None });
-            }
-        }
-    }
-
-    /// Run the executor to completion, blocking the thread until **all**
-    /// spawned futures have completed.
-    pub fn run(&mut self) -> Result<(), RunError> {
-        self.run_timeout2(None)
-            .map_err(|_| RunError { _p: () })
-    }
-
-    /// Run the executor to completion, blocking the thread until all
-    /// spawned futures have completed **or** `duration` time has elapsed.
-    pub fn run_timeout(&mut self, duration: Duration)
-        -> Result<(), RunTimeoutError>
-    {
-        self.run_timeout2(Some(duration))
-    }
-
-    /// Perform a single iteration of the event loop.
-    ///
-    /// This function blocks the current thread even if the executor is idle.
-    pub fn turn(&mut self, duration: Option<Duration>)
-        -> Result<Turn, TurnError>
-    {
-        if !self.tick() {
-            let res = match duration {
-                Some(duration) => self.executor.park.park_timeout(duration),
-                None => self.executor.park.park(),
-            };
-
-            if res.is_err() {
-                return Err(TurnError { _p: () });
-            }
-
-            self.tick();
-        }
-
-        Ok(Turn(()))
-    }
-
-    fn run_timeout2(&mut self, dur: Option<Duration>)
-        -> Result<(), RunTimeoutError>
-    {
-        if self.executor.is_idle() {
-            // Nothing to do
-            return Ok(());
-        }
-
-        let mut time = dur.map(|dur| (Instant::now() + dur, dur));
-
-        loop {
-            self.tick();
-
-            if self.executor.is_idle() {
-                return Ok(());
-            }
-
-            match time {
-                Some((until, rem)) => {
-                    if let Err(_) = self.executor.park.park_timeout(rem) {
-                        return Err(RunTimeoutError::new(false));
-                    }
-
-                    let now = Instant::now();
-
-                    if now >= until {
-                        return Err(RunTimeoutError::new(true));
-                    }
-
-                    time = Some((until, until - now));
-                }
-                None => {
-                    if let Err(_) = self.executor.park.park() {
-                        return Err(RunTimeoutError::new(false));
-                    }
-                }
-            }
-        }
-    }
-
-    /// Returns `true` if any futures were processed
-    fn tick(&mut self) -> bool {
-        self.executor.scheduler.tick(
-            &mut *self.enter,
-            &mut self.executor.num_futures)
-    }
-}
-
-impl<'a, P: Park> fmt::Debug for Entered<'a, P> {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        fmt.debug_struct("Entered")
-            .field("executor", &self.executor)
-            .field("enter", &self.enter)
-            .finish()
-    }
-}
-
-// ===== impl TaskExecutor =====
-
-#[deprecated(since = "0.1.2", note = "use TaskExecutor::current instead")]
-#[doc(hidden)]
-pub fn task_executor() -> TaskExecutor {
-    TaskExecutor {
-        _p: ::std::marker::PhantomData,
-    }
-}
-
-impl TaskExecutor {
-    /// Returns an executor that executes futures on the current thread.
-    ///
-    /// The user of `TaskExecutor` must ensure that when a future is submitted,
-    /// that it is done within the context of a call to `run`.
-    ///
-    /// For more details, see the [module level](index.html) documentation.
-    pub fn current() -> TaskExecutor {
-        TaskExecutor {
-            _p: ::std::marker::PhantomData,
-        }
-    }
-
-    /// Spawn a future onto the current `CurrentThread` instance.
-    pub fn spawn_local(&mut self, future: Box<Future<Item = (), Error = ()>>)
-        -> Result<(), SpawnError>
-    {
-        CURRENT.with(|current| {
-            match current.spawn.get() {
-                Some(spawn) => {
-                    unsafe { (*spawn).spawn_local(future) };
-                    Ok(())
-                }
-                None => {
-                    Err(SpawnError::shutdown())
-                }
-            }
-        })
-    }
-}
-
-impl tokio_executor::Executor for TaskExecutor {
-    fn spawn(&mut self, future: Box<Future<Item = (), Error = ()> + Send>)
-        -> Result<(), SpawnError>
-    {
-        self.spawn_local(future)
-    }
-
-    #[cfg(feature = "unstable-futures")]
-    fn spawn2(&mut self, _future: Box<futures2::Future<Item = (), Error = futures2::Never> + Send>)
-        -> Result<(), futures2::executor::SpawnError>
-    {
-        panic!("Futures 0.2 integration is not available for current_thread");
-    }
-
-    fn status(&self) -> Result<(), SpawnError> {
-        CURRENT.with(|current| {
-            if current.spawn.get().is_some() {
-                Ok(())
-            } else {
-                Err(SpawnError::shutdown())
-            }
-        })
-    }
-}
-
-impl<F> Executor<F> for TaskExecutor
-where F: Future<Item = (), Error = ()> + 'static
-{
-    fn execute(&self, future: F) -> Result<(), ExecuteError<F>> {
-        CURRENT.with(|current| {
-            match current.spawn.get() {
-                Some(spawn) => {
-                    unsafe { (*spawn).spawn_local(Box::new(future)) };
-                    Ok(())
-                }
-                None => {
-                    Err(ExecuteError::new(ExecuteErrorKind::Shutdown, future))
-                }
-            }
-        })
-    }
-}
-
-// ===== impl Context =====
-
-impl<'a> Context<'a> {
-    /// Cancels *all* executing futures.
-    pub fn cancel_all_spawned(&self) {
-        self.cancel.set(true);
-    }
-}
-
-// ===== impl Borrow =====
-
-impl<'a, U: Unpark> Borrow<'a, U> {
-    fn enter<F, R>(&mut self, _: &mut Enter, f: F) -> R
-    where F: FnOnce() -> R,
-    {
-        CURRENT.with(|current| {
-            current.set_spawn(self, || {
-                f()
-            })
-        })
-    }
-}
-
-impl<'a, U: Unpark> SpawnLocal for Borrow<'a, U> {
-    fn spawn_local(&mut self, future: Box<Future<Item = (), Error = ()>>) {
-        *self.num_futures += 1;
-        self.scheduler.schedule(future);
-    }
-}
-
-// ===== impl CurrentRunner =====
-
-impl CurrentRunner {
-    fn set_spawn<F, R>(&self, spawn: &mut SpawnLocal, f: F) -> R
-    where F: FnOnce() -> R
-    {
-        struct Reset<'a>(&'a CurrentRunner);
-
-        impl<'a> Drop for Reset<'a> {
-            fn drop(&mut self) {
-                self.0.spawn.set(None);
-            }
-        }
-
-        let _reset = Reset(self);
-
-        let spawn = unsafe { hide_lt(spawn as *mut SpawnLocal) };
-        self.spawn.set(Some(spawn));
-
-        f()
-    }
-}
-
-unsafe fn hide_lt<'a>(p: *mut (SpawnLocal + 'a)) -> *mut (SpawnLocal + 'static) {
-    use std::mem;
-    mem::transmute(p)
-}
-
-// ===== impl RunTimeoutError =====
-
-impl RunTimeoutError {
-    fn new(timeout: bool) -> Self {
-        RunTimeoutError { timeout }
-    }
-
-    /// Returns `true` if the error was caused by the operation timeing out.
-    pub fn is_timeout(&self) -> bool {
-        self.timeout
-    }
-}
-
-impl From<tokio_executor::EnterError> for RunTimeoutError {
-    fn from(_: tokio_executor::EnterError) -> Self {
-        RunTimeoutError::new(false)
-    }
-}
-
-// ===== impl BlockError =====
-
-impl<T> BlockError<T> {
-    /// Returns the error yielded by the future being blocked on
-    pub fn into_inner(self) -> Option<T> {
-        self.inner
-    }
-}
-
-impl<T> From<tokio_executor::EnterError> for BlockError<T> {
-    fn from(_: tokio_executor::EnterError) -> Self {
-        BlockError { inner: None }
-    }
-}

src/executor/mod.rs

@@ -1,239 +0,0 @@
-//! Task execution utilities.
-//!
-//! In the Tokio execution model, futures are lazy. When a future is created, no
-//! work is performed. In order for the work defined by the future to happen,
-//! the future must be submitted to an executor. A future that is submitted to
-//! an executor is called a "task".
-//!
-//! The executor executor is responsible for ensuring that [`Future::poll`] is
-//! called whenever the task is [notified]. Notification happens when the
-//! internal state of a task transitions from "not ready" to ready. For
-//! example, a socket might have received data and a call to `read` will now be
-//! able to succeed.
-//!
-//! The specific strategy used to manage the tasks is left up to the
-//! executor. There are two main flavors of executors: single-threaded and
-//! multithreaded. This module provides both.
-//!
-//! * **[`current_thread`]**: A single-threaded executor that support spawning
-//! tasks that are not `Send`. It guarantees that tasks will be executed on
-//! the same thread from which they are spawned.
-//!
-//! * **[`thread_pool`]**: A multi-threaded executor that maintains a pool of
-//! threads. Tasks are spawned to one of the threads in the pool and executed.
-//! The pool employes a [work-stealing] strategy for optimizing how tasks get
-//! spread across the available threads.
-//!
-//! # `Executor` trait.
-//!
-//! This module provides the [`Executor`] trait (re-exported from
-//! [`tokio-executor`]), which describes the API that all executors must
-//! implement.
-//!
-//! A free [`spawn`] function is provided that allows spawning futures onto the
-//! default executor (tracked via a thread-local variable) without referencing a
-//! handle. It is expected that all executors will set a value for the default
-//! executor. This value will often be set to the executor itself, but it is
-//! possible that the default executor might be set to a different executor.
-//!
-//! For example, the [`current_thread`] executor might set the default executor
-//! to a thread pool instead of itself, allowing futures to spawn new tasks onto
-//! the thread pool when those tasks are `Send`.
-//!
-//! [`Future::poll`]: https://docs.rs/futures/0.1/futures/future/trait.Future.html#tymethod.poll
-//! [notified]: https://docs.rs/futures/0.1/futures/executor/trait.Notify.html#tymethod.notify
-//! [`current_thread`]: current_thread/index.html
-//! [`thread_pool`]: thread_pool/index.html
-//! [work-stealing]: https://en.wikipedia.org/wiki/Work_stealing
-//! [`tokio-executor`]: #
-//! [`Executor`]: #
-//! [`spawn`]: #
-
-pub mod current_thread;
-
-pub mod thread_pool {
-    //! Maintains a pool of threads across which the set of spawned tasks are
-    //! executed.
-    //!
-    //! [`ThreadPool`] is an executor that uses a thread pool for executing
-    //! tasks concurrently across multiple cores. It uses a thread pool that is
-    //! optimized for use cases that involve multiplexing large number of
-    //! independent tasks that perform short(ish) amounts of computation and are
-    //! mainly waiting on I/O, i.e. the Tokio use case.
-    //!
-    //! Usually, users of [`ThreadPool`] will not create pool instances.
-    //! Instead, they will create a [`Runtime`] instance, which comes with a
-    //! pre-configured thread pool.
-    //!
-    //! At the core, [`ThreadPool`] uses a work-stealing based scheduling
-    //! strategy. When spawning a task while *external* to the thread pool
-    //! (i.e., from a thread that is not part of the thread pool), the task is
-    //! randomly assigned to a worker thread. When spawning a task while
-    //! *internal* to the thread pool, the task is assigned to the current
-    //! worker.
-    //!
-    //! Each worker maintains its own queue and first focuses on processing all
-    //! tasks in its queue. When the worker's queue is empty, the worker will
-    //! attempt to *steal* tasks from other worker queues. This strategy helps
-    //! ensure that work is evenly distributed across threads while minimizing
-    //! synchronization between worker threads.
-    //!
-    //! # Usage
-    //!
-    //! Thread pool instances are created using [`ThreadPool::new`] or
-    //! [`Builder::new`]. The first option returns a thread pool with default
-    //! configuration values. The second option allows configuring the thread
-    //! pool before instantiating it.
-    //!
-    //! Once an instance is obtained, futures may be spawned onto it using the
-    //! [`spawn`] function.
-    //!
-    //! A handle to the thread pool is obtained using [`ThreadPool::sender`].
-    //! This handle is **only** able to spawn futures onto the thread pool. It
-    //! is unable to affect the lifecycle of the thread pool in any way. This
-    //! handle can be passed into functions or stored in structs as a way to
-    //! grant the capability of spawning futures.
-    //!
-    //! # Examples
-    //!
-    //! ```rust
-    //! # extern crate tokio;
-    //! # extern crate futures;
-    //! # use tokio::executor::thread_pool::ThreadPool;
-    //! use futures::future::{Future, lazy};
-    //!
-    //! # pub fn main() {
-    //! // Create a thread pool with default configuration values
-    //! let thread_pool = ThreadPool::new();
-    //!
-    //! thread_pool.spawn(lazy(|| {
-    //!     println!("called from a worker thread");
-    //!     Ok(())
-    //! }));
-    //!
-    //! // Gracefully shutdown the threadpool
-    //! thread_pool.shutdown().wait().unwrap();
-    //! # }
-    //! ```
-    //!
-    //! [`ThreadPool`]: struct.ThreadPool.html
-    //! [`ThreadPool::new`]: struct.ThreadPool.html#method.new
-    //! [`ThreadPool::sender`]: struct.ThreadPool.html#method.sender
-    //! [`spawn`]: struct.ThreadPool.html#method.spawn
-    //! [`Builder::new`]: struct.Builder.html#method.new
-    //! [`Runtime`]: ../../runtime/struct.Runtime.html
-
-    pub use tokio_threadpool::{
-        Builder,
-        Sender,
-        Shutdown,
-        ThreadPool,
-    };
-}
-
-pub use tokio_executor::{Executor, DefaultExecutor, SpawnError};
-
-use futures::{Future, IntoFuture};
-use futures::future::{self, FutureResult};
-
-#[cfg(feature = "unstable-futures")]
-use futures2;
-
-/// Return value from the `spawn` function.
-///
-/// Currently this value doesn't actually provide any functionality. However, it
-/// provides a way to add functionality later without breaking backwards
-/// compatibility.
-///
-/// This also implements `IntoFuture` so that it can be used as the return value
-/// in a `for_each` loop.
-///
-/// See [`spawn`] for more details.
-///
-/// [`spawn`]: fn.spawn.html
-#[derive(Debug)]
-pub struct Spawn(());
-
-/// Spawns a future on the default executor.
-///
-/// In order for a future to do work, it must be spawned on an executor. The
-/// `spawn` function is the easiest way to do this. It spawns a future on the
-/// [default executor] for the current execution context (tracked using a
-/// thread-local variable).
-///
-/// The default executor is **usually** a thread pool.
-///
-/// # Examples
-///
-/// In this example, a server is started and `spawn` is used to start a new task
-/// that processes each received connection.
-///
-/// ```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() {}
-/// ```
-///
-/// [default executor]: struct.DefaultExecutor.html
-///
-/// # Panics
-///
-/// This function will panic if the default executor is not set or if spawning
-/// onto the default executor returns an error. To avoid the panic, use
-/// [`DefaultExecutor`].
-///
-/// [`DefaultExecutor`]: struct.DefaultExecutor.html
-pub fn spawn<F>(f: F) -> Spawn
-where F: Future<Item = (), Error = ()> + 'static + Send
-{
-    ::tokio_executor::spawn(f);
-    Spawn(())
-}
-
-/// Like `spawn`, but compatible with futures 0.2
-#[cfg(feature = "unstable-futures")]
-pub fn spawn2<F>(f: F) -> Spawn
-    where F: futures2::Future<Item = (), Error = futures2::Never> + 'static + Send
-{
-    ::tokio_executor::spawn2(f);
-    Spawn(())
-}
-
-impl IntoFuture for Spawn {
-    type Future = FutureResult<(), ()>;
-    type Item = ();
-    type Error = ();
-
-    fn into_future(self) -> Self::Future {
-        future::ok(())
-    }
-}
-
-#[cfg(feature = "unstable-futures")]
-impl futures2::IntoFuture for Spawn {
-    type Future = futures2::future::FutureResult<(), ()>;
-    type Item = ();
-    type Error = ();
-
-    fn into_future(self) -> Self::Future {
-        futures2::future::ok(())
-    }
-}

src/lib.rs

@@ -1,191 +0,0 @@
-//! 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][reactor] backed by the operating system's event queue (epoll, kqueue,
-//!   IOCP, etc...).
-//! * Asynchronous [TCP and UDP][net] sockets.
-//!
-//! Tokio is built using futures (provided by the [futures] crate) 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
-//!
-//! # 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);
-//! }
-//! ```
-
-#![doc(html_root_url = "https://docs.rs/tokio/0.1.4")]
-#![deny(missing_docs, warnings, missing_debug_implementations)]
-
-#[macro_use]
-extern crate futures;
-extern crate mio;
-extern crate tokio_io;
-extern crate tokio_executor;
-extern crate tokio_reactor;
-extern crate tokio_threadpool;
-extern crate tokio_tcp;
-extern crate tokio_udp;
-
-#[cfg(feature = "unstable-futures")]
-extern crate futures2;
-
-pub mod executor;
-pub mod net;
-pub mod reactor;
-pub mod runtime;
-
-pub use executor::spawn;
-#[cfg(feature = "unstable-futures")]
-pub use executor::spawn2;
-
-pub use runtime::run;
-
-pub mod io {
-    //! Asynchronous I/O.
-    //!
-    //! This module is the asynchronous version of `std::io`. Primarily, it
-    //! defines two traits, [`AsyncRead`] and [`AsyncWrite`], which extend the
-    //! `Read` and `Write` traits of the standard library.
-    //!
-    //! [`AsyncRead`] and [`AsyncWrite`] must only be implemented for
-    //! non-blocking I/O types that integrate with the futures type system. In
-    //! other words, these types must never block the thread, and instead the
-    //! current task is notified when the I/O resource is ready.
-    //!
-    //! Utilities functions are provided for working with [`AsyncRead`] /
-    //! [`AsyncWrite`] types. For example, [`copy`] asynchronously copies all
-    //! data from a source to a destination.
-    //!
-    //! Additionally, [`Read`], [`Write`], [`Error`], [`ErrorKind`], and
-    //! [`Result`] are re-exported from `std::io` for ease of use.
-    //!
-    //! [`AsyncRead`]: trait.AsyncRead.html
-    //! [`AsyncWrite`]: trait.AsyncWrite.html
-    //! [`copy`]: fn.copy.html
-    //! [`Read`]: trait.Read.html
-    //! [`Write`]: trait.Write.html
-    //! [`Error`]: struct.Error.html
-    //! [`ErrorKind`]: enum.ErrorKind.html
-    //! [`Result`]: type.Result.html
-
-    pub use tokio_io::{
-        AsyncRead,
-        AsyncWrite,
-    };
-
-    // Utils
-    pub use tokio_io::io::{
-        copy,
-        Copy,
-        flush,
-        Flush,
-        lines,
-        Lines,
-        read_exact,
-        ReadExact,
-        read_to_end,
-        ReadToEnd,
-        read_until,
-        ReadUntil,
-        shutdown,
-        Shutdown,
-        write_all,
-        WriteAll,
-    };
-
-    // Re-export io::Error so that users don't have to deal
-    // with conflicts when `use`ing `futures::io` and `std::io`.
-    pub use ::std::io::{
-        Error,
-        ErrorKind,
-        Result,
-        Read,
-        Write,
-    };
-}
-
-pub mod prelude {
-    //! 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.
-
-    pub use tokio_io::{
-        AsyncRead,
-        AsyncWrite,
-    };
-
-    pub use ::std::io::{
-        Read,
-        Write,
-    };
-
-    pub use futures::{
-        Future,
-        future,
-        Stream,
-        stream,
-        Sink,
-        IntoFuture,
-        Async,
-        AsyncSink,
-        Poll,
-        task,
-    };
-}

src/net.rs

@@ -1,41 +0,0 @@
-//! TCP/UDP bindings for `tokio`.
-//!
-//! This module contains the TCP/UDP networking types, similar to the standard
-//! library, which can be used to implement networking protocols.
-//!
-//! # TCP
-//!
-//! Connecting to an address, via TCP, can be done using [`TcpStream`]'s
-//! [`connect`] method, which returns [`ConnectFuture`]. `ConnectFuture`
-//! implements a future which returns a `TcpStream`.
-//!
-//! To listen on an address [`TcpListener`] can be used. `TcpListener`'s
-//! [`incoming`][incoming_method] method can be used to accept new connections.
-//! It return the [`Incoming`] struct, which implements a stream which returns
-//! `TcpStream`s.
-//!
-//! [`TcpStream`]: struct.TcpStream.html
-//! [`connect`]: struct.TcpStream.html#method.connect
-//! [`ConnectFuture`]: struct.ConnectFuture.html
-//! [`TcpListener`]: struct.TcpListener.html
-//! [incoming_method]: struct.TcpListener.html#method.incoming
-//! [`Incoming`]: struct.Incoming.html
-//!
-//! # UDP
-//!
-//! The main struct for UDP is the [`UdpSocket`], which represents a UDP socket.
-//! Reading and writing to it can be done using futures, which return the
-//! [`RecvDgram`] and [`SendDgram`] structs respectively.
-//!
-//! For convience it's also possible to convert raw datagrams into higher-level
-//! frames.
-//!
-//! [`UdpSocket`]: struct.UdpSocket.html
-//! [`RecvDgram`]: struct.RecvDgram.html
-//! [`SendDgram`]: struct.SendDgram.html
-//! [`UdpFramed`]: struct.UdpFramed.html
-//! [`framed`]: struct.UdpSocket.html#method.framed
-
-pub use tokio_tcp::{TcpStream, ConnectFuture};
-pub use tokio_tcp::{TcpListener, Incoming};
-pub use tokio_udp::{UdpSocket, UdpFramed, SendDgram, RecvDgram};

src/runtime/builder.rs

@@ -1,107 +0,0 @@
-use runtime::{Inner, Runtime};
-
-use reactor::Reactor;
-
-use std::io;
-
-use tokio_threadpool::Builder as ThreadPoolBuilder;
-
-
-
-/// Builds Tokio Runtime with custom configuration values.
-///
-/// Methods can be chanined in order to set the configuration values. The
-/// Runtime is constructed by calling [`build`].
-///
-/// New instances of `Builder` are obtained via [`Builder::new`].
-///
-/// See function level documentation for details on the various configuration
-/// settings.
-///
-/// [`build`]: #method.build
-/// [`Builder::new`]: #method.new
-///
-/// # Examples
-///
-/// ```
-/// # extern crate tokio;
-/// # extern crate tokio_threadpool;
-/// # use tokio::runtime::Builder;
-///
-/// # pub fn main() {
-/// // create and configure ThreadPool
-/// let mut threadpool_builder = tokio_threadpool::Builder::new();
-/// threadpool_builder
-///     .name_prefix("my-runtime-worker-")
-///     .pool_size(4);
-///
-/// // build Runtime
-/// let runtime = Builder::new()
-///     .threadpool_builder(threadpool_builder)
-///     .build();
-/// // ... call runtime.run(...)
-/// # let _ = runtime;
-/// # }
-/// ```
-#[derive(Debug)]
-pub struct Builder {
-    /// Thread pool specific builder
-    threadpool_builder: ThreadPoolBuilder,
-}
-
-impl Builder {
-    /// Returns a new runtime builder initialized with default configuration
-    /// values.
-    ///
-    /// Configuration methods can be chained on the return value.
-    pub fn new() -> Builder {
-        let mut threadpool_builder = ThreadPoolBuilder::new();
-        threadpool_builder.name_prefix("tokio-runtime-worker-");
-
-        Builder { threadpool_builder }
-    }
-
-    /// Set builder to set up the thread pool instance.
-    pub fn threadpool_builder(&mut self, val: ThreadPoolBuilder) -> &mut Self {
-        self.threadpool_builder = val;
-        self
-    }
-
-    /// Create the configured `Runtime`.
-    ///
-    /// The returned `ThreadPool` instance is ready to spawn tasks.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # extern crate tokio;
-    /// # use tokio::runtime::Builder;
-    /// # pub fn main() {
-    /// let runtime = Builder::new().build();
-    /// // ... call runtime.run(...)
-    /// # let _ = runtime;
-    /// # }
-    /// ```
-    pub fn build(&mut self) -> io::Result<Runtime> {
-        // Spawn a reactor on a background thread.
-        let reactor = Reactor::new()?.background()?;
-
-        // Get a handle to the reactor.
-        let handle = reactor.handle().clone();
-
-        let pool = self.threadpool_builder
-            .around_worker(move |w, enter| {
-                ::tokio_reactor::with_default(&handle, enter, |_| {
-                    w.run();
-                });
-            })
-            .build();
-
-        Ok(Runtime {
-            inner: Some(Inner {
-                reactor,
-                pool,
-            }),
-        })
-    }
-}

tests/current_thread.rs

@@ -1,397 +0,0 @@
-#![cfg(not(feature = "unstable-futures"))]
-
-extern crate tokio;
-extern crate tokio_executor;
-extern crate futures;
-
-use tokio::executor::current_thread::{self, block_on_all, CurrentThread};
-
-use std::any::Any;
-use std::cell::{Cell, RefCell};
-use std::rc::Rc;
-use std::thread;
-use std::time::Duration;
-
-use futures::task;
-use futures::future::{self, lazy};
-use futures::prelude::*;
-use futures::sync::oneshot;
-
-#[test]
-fn spawn_from_block_on_all() {
-    let cnt = Rc::new(Cell::new(0));
-    let c = cnt.clone();
-
-    let msg = current_thread::block_on_all(lazy(move || {
-        c.set(1 + c.get());
-
-        // Spawn!
-        current_thread::spawn(lazy(move || {
-            c.set(1 + c.get());
-            Ok::<(), ()>(())
-        }));
-
-        Ok::<_, ()>("hello")
-    })).unwrap();
-
-    assert_eq!(2, cnt.get());
-    assert_eq!(msg, "hello");
-}
-
-#[test]
-fn block_waits() {
-    let (tx, rx) = oneshot::channel();
-
-    thread::spawn(|| {
-        thread::sleep(Duration::from_millis(1000));
-        tx.send(()).unwrap();
-    });
-
-    let cnt = Rc::new(Cell::new(0));
-    let cnt2 = cnt.clone();
-
-    block_on_all(rx.then(move |_| {
-        cnt.set(1 + cnt.get());
-        Ok::<_, ()>(())
-    })).unwrap();
-
-    assert_eq!(1, cnt2.get());
-}
-
-#[test]
-fn spawn_many() {
-    const ITER: usize = 200;
-
-    let cnt = Rc::new(Cell::new(0));
-    let mut current_thread = CurrentThread::new();
-
-    for _ in 0..ITER {
-        let cnt = cnt.clone();
-        current_thread.spawn(lazy(move || {
-            cnt.set(1 + cnt.get());
-            Ok::<(), ()>(())
-        }));
-    }
-
-    current_thread.run().unwrap();
-
-    assert_eq!(cnt.get(), ITER);
-}
-
-#[test]
-fn does_not_set_global_executor_by_default() {
-    use tokio_executor::Executor;
-
-    block_on_all(lazy(|| {
-        tokio_executor::DefaultExecutor::current()
-            .spawn(Box::new(lazy(|| ok())))
-            .unwrap_err();
-
-        ok()
-    })).unwrap();
-}
-
-#[test]
-fn spawn_from_block_on_future() {
-    let cnt = Rc::new(Cell::new(0));
-
-    let mut current_thread = CurrentThread::new();
-
-    current_thread.block_on(lazy(|| {
-        let cnt = cnt.clone();
-
-        current_thread::spawn(lazy(move || {
-            cnt.set(1 + cnt.get());
-            Ok(())
-        }));
-
-        Ok::<_, ()>(())
-    })).unwrap();
-
-    current_thread.run().unwrap();
-
-    assert_eq!(1, cnt.get());
-}
-
-struct Never(Rc<()>);
-
-impl Future for Never {
-    type Item = ();
-    type Error = ();
-
-    fn poll(&mut self) -> Poll<(), ()> {
-        Ok(Async::NotReady)
-    }
-}
-
-#[test]
-fn outstanding_tasks_are_dropped_when_executor_is_dropped() {
-    let mut rc = Rc::new(());
-
-    let mut current_thread = CurrentThread::new();
-    current_thread.spawn(Never(rc.clone()));
-
-    drop(current_thread);
-
-    // Ensure the daemon is dropped
-    assert!(Rc::get_mut(&mut rc).is_some());
-
-    // Using the global spawn fn
-
-    let mut rc = Rc::new(());
-
-    let mut current_thread = CurrentThread::new();
-
-    current_thread.block_on(lazy(|| {
-        current_thread::spawn(Never(rc.clone()));
-        Ok::<_, ()>(())
-    })).unwrap();
-
-    drop(current_thread);
-
-    // Ensure the daemon is dropped
-    assert!(Rc::get_mut(&mut rc).is_some());
-}
-
-#[test]
-#[should_panic]
-fn nesting_run() {
-    block_on_all(lazy(|| {
-        block_on_all(lazy(|| {
-            ok()
-        })).unwrap();
-
-        ok()
-    })).unwrap();
-}
-
-#[test]
-#[should_panic]
-fn run_in_future() {
-    block_on_all(lazy(|| {
-        current_thread::spawn(lazy(|| {
-            block_on_all(lazy(|| {
-                ok()
-            })).unwrap();
-            ok()
-        }));
-        ok()
-    })).unwrap();
-}
-
-#[test]
-fn tick_on_infini_future() {
-    let num = Rc::new(Cell::new(0));
-
-    struct Infini {
-        num: Rc<Cell<usize>>,
-    }
-
-    impl Future for Infini {
-        type Item = ();
-        type Error = ();
-
-        fn poll(&mut self) -> Poll<(), ()> {
-            self.num.set(1 + self.num.get());
-            task::current().notify();
-            Ok(Async::NotReady)
-        }
-    }
-
-    CurrentThread::new()
-        .spawn(Infini {
-            num: num.clone(),
-        })
-        .turn(None)
-        .unwrap();
-
-    assert_eq!(1, num.get());
-}
-
-#[test]
-fn tasks_are_scheduled_fairly() {
-    let state = Rc::new(RefCell::new([0, 0]));
-
-    struct Spin {
-        state: Rc<RefCell<[i32; 2]>>,
-        idx: usize,
-    }
-
-    impl Future for Spin {
-        type Item = ();
-        type Error = ();
-
-        fn poll(&mut self) -> Poll<(), ()> {
-            let mut state = self.state.borrow_mut();
-
-            if self.idx == 0 {
-                let diff = state[0] - state[1];
-
-                assert!(diff.abs() <= 1);
-
-                if state[0] >= 50 {
-                    return Ok(().into());
-                }
-            }
-
-            state[self.idx] += 1;
-
-            if state[self.idx] >= 100 {
-                return Ok(().into());
-            }
-
-            task::current().notify();
-            Ok(Async::NotReady)
-        }
-    }
-
-    block_on_all(lazy(|| {
-        current_thread::spawn(Spin {
-            state: state.clone(),
-            idx: 0,
-        });
-
-        current_thread::spawn(Spin {
-            state: state,
-            idx: 1,
-        });
-
-        ok()
-    })).unwrap();
-}
-
-#[test]
-fn spawn_and_turn() {
-    let cnt = Rc::new(Cell::new(0));
-    let c = cnt.clone();
-
-    let mut current_thread = CurrentThread::new();
-
-    // Spawn a basic task to get the executor to turn
-    current_thread.spawn(lazy(move || {
-        Ok(())
-    }));
-
-    // Turn once...
-    current_thread.turn(None).unwrap();
-
-    current_thread.spawn(lazy(move || {
-        c.set(1 + c.get());
-
-        // Spawn!
-        current_thread::spawn(lazy(move || {
-            c.set(1 + c.get());
-            Ok::<(), ()>(())
-        }));
-
-        Ok(())
-    }));
-
-    // This does not run the newly spawned thread
-    current_thread.turn(None).unwrap();
-    assert_eq!(1, cnt.get());
-
-    // This runs the newly spawned thread
-    current_thread.turn(None).unwrap();
-    assert_eq!(2, cnt.get());
-}
-
-#[test]
-fn spawn_in_drop() {
-    let mut current_thread = CurrentThread::new();
-
-    let (tx, rx) = oneshot::channel();
-
-    current_thread.spawn({
-        struct OnDrop<F: FnOnce()>(Option<F>);
-
-        impl<F: FnOnce()> Drop for OnDrop<F> {
-            fn drop(&mut self) {
-                (self.0.take().unwrap())();
-            }
-        }
-
-        struct MyFuture {
-            _data: Box<Any>,
-        }
-
-        impl Future for MyFuture {
-            type Item = ();
-            type Error = ();
-
-            fn poll(&mut self) -> Poll<(), ()> {
-                Ok(().into())
-            }
-        }
-
-        MyFuture {
-            _data: Box::new(OnDrop(Some(move || {
-                current_thread::spawn(lazy(move || {
-                    tx.send(()).unwrap();
-                    Ok(())
-                }));
-            }))),
-        }
-    });
-
-    current_thread.block_on(rx).unwrap();
-    current_thread.run().unwrap();
-}
-
-#[test]
-fn hammer_turn() {
-    use futures::sync::mpsc;
-
-    const ITER: usize = 100;
-    const N: usize = 100;
-    const THREADS: usize = 4;
-
-    for _ in 0..ITER {
-        let mut ths = vec![];
-
-        // Add some jitter
-        for _ in 0..THREADS {
-            let th = thread::spawn(|| {
-                let mut current_thread = CurrentThread::new();
-
-                let (tx, rx) = mpsc::unbounded();
-
-                current_thread.spawn({
-                    let cnt = Rc::new(Cell::new(0));
-                    let c = cnt.clone();
-
-                    rx.for_each(move |_| {
-                        c.set(1 + c.get());
-                        Ok(())
-                    })
-                    .map_err(|e| panic!("err={:?}", e))
-                    .map(move |v| {
-                        assert_eq!(N, cnt.get());
-                        v
-                    })
-                });
-
-                thread::spawn(move || {
-                    for _ in 0..N {
-                        tx.unbounded_send(()).unwrap();
-                        thread::yield_now();
-                    }
-                });
-
-                while !current_thread.is_idle() {
-                    current_thread.turn(None).unwrap();
-                }
-            });
-
-            ths.push(th);
-        }
-
-        for th in ths {
-            th.join().unwrap();
-        }
-    }
-}
-
-fn ok() -> future::FutureResult<(), ()> {
-    future::ok(())
-}

tests/echo2.rs

@@ -1,53 +0,0 @@
-#![cfg(feature = "unstable-futures")]
-
-// This test is the same as `echo.rs`, but ported to futures 0.2
-
-extern crate env_logger;
-extern crate futures2;
-extern crate tokio;
-extern crate tokio_io;
-
-use std::io::{Read, Write};
-use std::net::TcpStream;
-use std::thread;
-
-use futures2::prelude::*;
-use futures2::executor::block_on;
-use tokio::net::TcpListener;
-
-macro_rules! t {
-    ($e:expr) => (match $e {
-        Ok(e) => e,
-        Err(e) => panic!("{} failed with {:?}", stringify!($e), e),
-    })
-}
-
-#[test]
-fn echo_server() {
-    drop(env_logger::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 = TcpStream::connect(&addr).unwrap();
-
-        for _i in 0..1024 {
-            assert_eq!(t!(s.write(msg.as_bytes())), msg.len());
-            let mut buf = [0; 1024];
-            assert_eq!(t!(s.read(&mut buf)), msg.len());
-            assert_eq!(&buf[..msg.len()], msg.as_bytes());
-        }
-    });
-
-    let clients = srv.incoming();
-    let client = clients.next().map(|e| e.0.unwrap()).map_err(|e| e.0);
-    let halves = client.map(|s| s.split());
-    let copied = halves.and_then(|(a, b)| a.copy_into(b));
-
-    let (amt, _, _) = t!(block_on(copied));
-    t.join().unwrap();
-
-    assert_eq!(amt, msg.len() as u64 * 1024);
-}

tests/global2.rs

@@ -1,122 +0,0 @@
-#![cfg(feature = "unstable-futures")]
-
-// This test is the same as `global.rs`, but ported to futures 0.2
-
-extern crate futures;
-extern crate futures2;
-extern crate tokio;
-extern crate tokio_io;
-extern crate env_logger;
-
-use std::{io, thread};
-use std::sync::Arc;
-
-use futures2::prelude::*;
-use futures2::executor::block_on;
-use futures2::task;
-
-use tokio::net::{TcpStream, TcpListener};
-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() {
-    let _ = env_logger::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().next()
-                .map(|(s, _)| s.unwrap())
-                .map_err(|(s, _)| s);
-            let (mine, theirs) = t!(block_on(mine.join(theirs)));
-
-            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 AsyncRead for Rd {
-    fn poll_read(&mut self, cx: &mut task::Context, dst: &mut [u8]) -> Poll<usize, io::Error> {
-        <&TcpStream>::poll_read(&mut &*self.0, cx, dst)
-    }
-}
-
-impl AsyncWrite for Wr {
-    fn poll_write(&mut self, cx: &mut task::Context, src: &[u8]) -> Poll<usize, io::Error> {
-        <&TcpStream>::poll_write(&mut &*self.0, cx, src)
-    }
-
-    fn poll_flush(&mut self, _cx: &mut task::Context) -> Poll<(), io::Error> {
-        Ok(().into())
-    }
-
-    fn poll_close(&mut self, _cx: &mut task::Context) -> Poll<(), io::Error> {
-        Ok(().into())
-    }
-}
-
-#[test]
-fn hammer_split() {
-    const N: usize = 100;
-
-    let _ = env_logger::init();
-
-    let srv = t!(TcpListener::bind(&"127.0.0.1:0".parse().unwrap()));
-    let addr = t!(srv.local_addr());
-
-    let mut rt = Runtime::new().unwrap();
-
-    fn split(socket: TcpStream) {
-        let socket = Arc::new(socket);
-        let rd = Rd(socket.clone());
-        let wr = Wr(socket);
-
-        let rd = rd.read(vec![0; 1])
-            .map(|_| ())
-            .map_err(|e| panic!("read error = {:?}", e));
-
-        let wr = wr.write_all(b"1")
-            .map(|_| ())
-            .map_err(|e| panic!("write error = {:?}", e));
-
-        tokio::spawn2(rd);
-        tokio::spawn2(wr);
-    }
-
-    rt.spawn2({
-        srv.incoming()
-            .map_err(|e| panic!("accept error = {:?}", e))
-            .take(N as u64)
-            .for_each(|socket| {
-                split(socket);
-                Ok(())
-            })
-            .map(|_| ())
-    });
-
-    for _ in 0..N {
-        rt.spawn2({
-            TcpStream::connect(&addr)
-                .map_err(|e| panic!("connect error = {:?}", e))
-                .map(|socket| split(socket))
-        });
-    }
-
-    futures::Future::wait(rt.shutdown_on_idle()).unwrap();
-}

tests/runtime.rs

@@ -1,52 +0,0 @@
-extern crate futures;
-extern crate tokio;
-extern crate tokio_io;
-extern crate env_logger;
-
-use futures::prelude::*;
-use tokio::net::{TcpStream, TcpListener};
-use tokio_io::io;
-
-macro_rules! t {
-    ($e:expr) => (match $e {
-        Ok(e) => e,
-        Err(e) => panic!("{} failed with {:?}", stringify!($e), e),
-    })
-}
-
-#[test]
-fn basic_runtime_usage() {
-    let _ = env_logger::init();
-
-    // TODO: Don't require the lazy wrapper
-    tokio::run(::futures::future::lazy(|| {
-        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| println!("accept err = {:?}", e))
-            .for_each(|socket| {
-                tokio::spawn({
-                    io::write_all(socket, b"hello")
-                        .map(|_| println!("write done"))
-                        .map_err(|e| println!("write err = {:?}", e))
-                })
-            })
-            .map(|_| println!("accept done"));
-
-        let client = client
-            .map_err(|e| println!("connect err = {:?}", e))
-            .and_then(|client| {
-                // Read all
-                io::read_to_end(client, vec![])
-                    .map(|_| println!("read done"))
-                    .map_err(|e| println!("read err = {:?}", e))
-            });
-
-        tokio::spawn({
-            server.join(client)
-                .map(|_| println!("done"))
-        })
-    }));
-}

tests/tcp2.rs

@@ -1,136 +0,0 @@
-#![cfg(feature = "unstable-futures")]
-
-// This test is the same as `tcp.rs`, but ported to futures 0.2
-
-extern crate env_logger;
-extern crate tokio;
-extern crate mio;
-extern crate futures2;
-
-use std::{net, thread};
-use std::sync::mpsc::channel;
-
-use tokio::net::{TcpListener, TcpStream};
-use futures2::executor::block_on;
-use futures2::prelude::*;
-
-macro_rules! t {
-    ($e:expr) => (match $e {
-        Ok(e) => e,
-        Err(e) => panic!("{} failed with {:?}", stringify!($e), e),
-    })
-}
-
-#[test]
-fn connect() {
-    drop(env_logger::init());
-    let srv = t!(net::TcpListener::bind("127.0.0.1:0"));
-    let addr = t!(srv.local_addr());
-    let t = thread::spawn(move || {
-        t!(srv.accept()).0
-    });
-
-    let stream = TcpStream::connect(&addr);
-    let mine = t!(block_on(stream));
-    let theirs = t.join().unwrap();
-
-    assert_eq!(t!(mine.local_addr()), t!(theirs.peer_addr()));
-    assert_eq!(t!(theirs.local_addr()), t!(mine.peer_addr()));
-}
-
-#[test]
-fn accept() {
-    drop(env_logger::init());
-    let srv = t!(TcpListener::bind(&t!("127.0.0.1:0".parse())));
-    let addr = t!(srv.local_addr());
-
-    let (tx, rx) = channel();
-    let client = srv.incoming().map(move |t| {
-        tx.send(()).unwrap();
-        t
-    }).next().map_err(|e| e.0);
-    assert!(rx.try_recv().is_err());
-    let t = thread::spawn(move || {
-        net::TcpStream::connect(&addr).unwrap()
-    });
-
-    let (mine, _remaining) = t!(block_on(client));
-    let mine = mine.unwrap();
-    let theirs = t.join().unwrap();
-
-    assert_eq!(t!(mine.local_addr()), t!(theirs.peer_addr()));
-    assert_eq!(t!(theirs.local_addr()), t!(mine.peer_addr()));
-}
-
-#[test]
-fn accept2() {
-    drop(env_logger::init());
-    let srv = t!(TcpListener::bind(&t!("127.0.0.1:0".parse())));
-    let addr = t!(srv.local_addr());
-
-    let t = thread::spawn(move || {
-        net::TcpStream::connect(&addr).unwrap()
-    });
-
-    let (tx, rx) = channel();
-    let client = srv.incoming().map(move |t| {
-        tx.send(()).unwrap();
-        t
-    }).next().map_err(|e| e.0);
-    assert!(rx.try_recv().is_err());
-
-    let (mine, _remaining) = t!(block_on(client));
-    mine.unwrap();
-    t.join().unwrap();
-}
-
-#[cfg(unix)]
-mod unix {
-    use tokio::net::TcpStream;
-    use tokio::prelude::*;
-
-    use env_logger;
-    use futures2::future;
-    use futures2::executor::block_on;
-    use futures2::io::AsyncRead;
-    use mio::unix::UnixReady;
-
-    use std::{net, thread};
-    use std::time::Duration;
-
-    #[test]
-    fn poll_hup() {
-        drop(env_logger::init());
-
-        let srv = t!(net::TcpListener::bind("127.0.0.1:0"));
-        let addr = t!(srv.local_addr());
-        let t = thread::spawn(move || {
-            let mut client = t!(srv.accept()).0;
-            client.write(b"hello world").unwrap();
-            thread::sleep(Duration::from_millis(200));
-        });
-
-        let mut stream = t!(block_on(TcpStream::connect(&addr)));
-
-        // Poll for HUP before reading.
-        block_on(future::poll_fn(|cx| {
-            stream.poll_read_ready2(cx, UnixReady::hup().into())
-        })).unwrap();
-
-        // Same for write half
-        block_on(future::poll_fn(|cx| {
-            stream.poll_write_ready2(cx)
-        })).unwrap();
-
-        let mut buf = vec![0; 11];
-
-        // Read the data
-        block_on(future::poll_fn(|cx| {
-            stream.poll_read(cx, &mut buf)
-        })).unwrap();
-
-        assert_eq!(b"hello world", &buf[..]);
-
-        t.join().unwrap();
-    }
-}

tokio-buf/CHANGELOG.md

@@ -0,0 +1,14 @@
+# 0.1.1 (April 22, 2019)
+
+### Added
+- Utilities for creating a `BufStream` from iterators and streams (#1011).
+- Add `BufStream::into_stream` (#1048).
+- Implement `FromBufStream` for `Bytes` (#1009).
+- Implement `Error` for `CollectVecError` (#1010).
+
+### Fixed
+- Implement `size_hint` for string types (#1012).
+
+# 0.1.0 (February 23, 2019)
+
+* Initial release

tokio-buf/Cargo.toml

@@ -0,0 +1,32 @@
+[package]
+name = "tokio-buf"
+# When releasing to crates.io:
+# - Remove path dependencies
+# - Update html_root_url.
+# - Update doc url
+#   - Cargo.toml
+#   - README.md
+# - Update CHANGELOG.md.
+# - Create "v0.1.x" git tag.
+version = "0.1.1"
+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.1/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"]
+
+[dev-dependencies]
+tokio-mock-task = "0.1.1"

tokio-buf/LICENSE

@@ -0,0 +1,25 @@
+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.

tokio-buf/README.md

@@ -0,0 +1,35 @@
+# 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.1"
+```
+
+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

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

tokio-buf/src/never.rs

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

tokio-buf/src/size_hint.rs

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

tokio-buf/src/str.rs

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

tokio-buf/src/u8.rs

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

tokio-buf/src/util/chain.rs

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

tokio-buf/src/util/collect.rs

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

tokio-buf/src/util/from.rs

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

tokio-buf/src/util/iter.rs

@@ -0,0 +1,54 @@
+use bytes::Buf;
+use futures::Poll;
+use std::error::Error;
+use std::fmt;
+use BufStream;
+
+/// Converts an `Iterator` into a `BufStream` which is always ready to yield the
+/// next value.
+///
+/// Iterators in Rust don't express the ability to block, so this adapter
+/// simply always calls `iter.next()` and returns that.
+pub fn iter<I>(i: I) -> Iter<I::IntoIter>
+where
+    I: IntoIterator,
+    I::Item: Buf,
+{
+    Iter {
+        iter: i.into_iter(),
+    }
+}
+
+/// `BufStream` returned by the [`iter`] function.
+#[derive(Debug)]
+pub struct Iter<I> {
+    iter: I,
+}
+
+#[derive(Debug)]
+pub enum Never {}
+
+impl<I> BufStream for Iter<I>
+where
+    I: Iterator,
+    I::Item: Buf,
+{
+    type Item = I::Item;
+    type Error = Never;
+
+    fn poll_buf(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
+        Ok(self.iter.next().into())
+    }
+}
+
+impl fmt::Display for Never {
+    fn fmt(&self, _: &mut fmt::Formatter) -> fmt::Result {
+        unreachable!();
+    }
+}
+
+impl Error for Never {
+    fn description(&self) -> &str {
+        unreachable!();
+    }
+}

tokio-buf/src/util/limit.rs

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

tokio-buf/src/util/mod.rs

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

tokio-buf/src/util/stream.rs

@@ -0,0 +1,76 @@
+use bytes::Buf;
+use futures::{Async, Poll, Stream};
+use BufStream;
+
+/// Converts a `Stream` of `Buf` types into a `BufStream`.
+///
+/// While `Stream` and `BufStream` are very similar, they are not identical. The
+/// `stream` function returns a `BufStream` that is backed by the provided
+/// `Stream` type.
+pub fn stream<T>(stream: T) -> FromStream<T>
+where
+    T: Stream,
+    T::Item: Buf,
+{
+    FromStream { stream }
+}
+
+/// `BufStream` returned by the [`stream`] function.
+#[derive(Debug)]
+pub struct FromStream<T> {
+    stream: T,
+}
+
+impl<T> BufStream for FromStream<T>
+where
+    T: Stream,
+    T::Item: Buf,
+{
+    type Item = T::Item;
+    type Error = T::Error;
+
+    fn poll_buf(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
+        self.stream.poll()
+    }
+}
+
+/// Converts a `BufStream` into a `Stream`.
+#[derive(Debug)]
+pub struct IntoStream<T> {
+    buf: T,
+}
+
+impl<T> IntoStream<T> {
+    /// Create a new `Stream` from the provided `BufStream`.
+    pub fn new(buf: T) -> Self {
+        IntoStream { buf }
+    }
+
+    /// Get a reference to the inner `BufStream`.
+    pub fn get_ref(&self) -> &T {
+        &self.buf
+    }
+
+    /// Get a mutable reference to the inner `BufStream`
+    pub fn get_mut(&mut self) -> &mut T {
+        &mut self.buf
+    }
+
+    /// Get the inner `BufStream`.
+    pub fn into_inner(self) -> T {
+        self.buf
+    }
+}
+
+impl<T: BufStream> Stream for IntoStream<T> {
+    type Item = T::Item;
+    type Error = T::Error;
+
+    fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
+        match self.buf.poll_buf()? {
+            Async::Ready(Some(buf)) => Ok(Async::Ready(Some(buf))),
+            Async::Ready(None) => Ok(Async::Ready(None)),
+            Async::NotReady => Ok(Async::NotReady),
+        }
+    }
+}

tokio-buf/tests/buf_stream.rs

@@ -0,0 +1,7 @@
+extern crate tokio_buf;
+
+use tokio_buf::BufStream;
+
+// Ensures that `BufStream` can be a trait object
+#[allow(dead_code)]
+fn obj(_: &mut dyn BufStream<Item = u32, Error = ()>) {}

tokio-buf/tests/chain.rs

@@ -0,0 +1,43 @@
+#![cfg(feature = "util")]
+
+extern crate bytes;
+extern crate futures;
+extern crate tokio_buf;
+
+use futures::Async::*;
+use tokio_buf::{BufStream, BufStreamExt};
+
+#[macro_use]
+mod support;
+
+use support::*;
+
+#[test]
+fn chain() {
+    // Chain one with one
+    //
+    let mut bs = one("hello").chain(one("world"));
+
+    assert_buf_eq!(bs.poll_buf(), "hello");
+    assert_buf_eq!(bs.poll_buf(), "world");
+    assert_none!(bs.poll_buf());
+
+    // Chain multi with multi
+    let mut bs = list(&["foo", "bar"]).chain(list(&["baz", "bok"]));
+
+    assert_buf_eq!(bs.poll_buf(), "foo");
+    assert_buf_eq!(bs.poll_buf(), "bar");
+    assert_buf_eq!(bs.poll_buf(), "baz");
+    assert_buf_eq!(bs.poll_buf(), "bok");
+    assert_none!(bs.poll_buf());
+
+    // Chain includes a not ready call
+    //
+    let mut bs = new_mock(&[Ok(Ready("foo")), Ok(NotReady), Ok(Ready("bar"))]).chain(one("baz"));
+
+    assert_buf_eq!(bs.poll_buf(), "foo");
+    assert_not_ready!(bs.poll_buf());
+    assert_buf_eq!(bs.poll_buf(), "bar");
+    assert_buf_eq!(bs.poll_buf(), "baz");
+    assert_none!(bs.poll_buf());
+}

tokio-buf/tests/collect.rs

@@ -0,0 +1,68 @@
+#![cfg(feature = "util")]
+
+extern crate bytes;
+extern crate futures;
+extern crate tokio_buf;
+
+use bytes::Bytes;
+use futures::Future;
+use tokio_buf::BufStreamExt;
+
+#[macro_use]
+mod support;
+
+use support::*;
+
+macro_rules! test_collect_impl {
+    ($t:ty $(, $capacity:ident)*) => {
+        // While unfortunate, this test makes some assumptions on vec's resizing
+        // behavior.
+        //
+        // Collect one
+        //
+        let bs = one("hello world");
+
+        let vec: $t = bs.collect().wait().unwrap();
+
+        assert_eq!(vec, &b"hello world"[..]);
+        $( assert_eq!(vec.$capacity(), 64); )*
+
+        // Collect one, with size hint
+        //
+        let mut bs = one("hello world");
+        bs.size_hint.set_lower(11);
+
+        let vec: $t = bs.collect().wait().unwrap();
+
+        assert_eq!(vec, &b"hello world"[..]);
+        $( assert_eq!(vec.$capacity(), 64); )*
+
+        // Collect one, with size hint
+        //
+        let mut bs = one("hello world");
+        bs.size_hint.set_lower(10);
+
+        let vec: $t = bs.collect().wait().unwrap();
+
+        assert_eq!(vec, &b"hello world"[..]);
+        $( assert_eq!(vec.$capacity(), 64); )*
+
+        // Collect many
+        //
+        let bs = list(&["hello", " ", "world", ", one two three"]);
+
+        let vec: $t = bs.collect().wait().unwrap();
+
+        assert_eq!(vec, &b"hello world, one two three"[..]);
+    }
+}
+
+#[test]
+fn collect_vec() {
+    test_collect_impl!(Vec<u8>, capacity);
+}
+
+#[test]
+fn collect_bytes() {
+    test_collect_impl!(Bytes);
+}

tokio-buf/tests/iter.rs

@@ -0,0 +1,33 @@
+extern crate bytes;
+extern crate futures;
+extern crate tokio_buf;
+
+use futures::Async::*;
+use std::io::Cursor;
+use tokio_buf::{util, BufStream};
+
+#[macro_use]
+mod support;
+
+type Buf = Cursor<&'static [u8]>;
+
+#[test]
+fn empty_iter() {
+    let mut bs = util::iter(Vec::<Buf>::new());
+    assert_none!(bs.poll_buf());
+}
+
+#[test]
+fn full_iter() {
+    let bufs = vec![buf(b"one"), buf(b"two"), buf(b"three")];
+
+    let mut bs = util::iter(bufs);
+    assert_buf_eq!(bs.poll_buf(), "one");
+    assert_buf_eq!(bs.poll_buf(), "two");
+    assert_buf_eq!(bs.poll_buf(), "three");
+    assert_none!(bs.poll_buf());
+}
+
+fn buf(data: &'static [u8]) -> Buf {
+    Cursor::new(data)
+}

tokio-buf/tests/limit.rs

@@ -0,0 +1,65 @@
+#![cfg(feature = "util")]
+
+extern crate bytes;
+extern crate futures;
+extern crate tokio_buf;
+
+use futures::Async::*;
+use futures::Future;
+use tokio_buf::{BufStream, BufStreamExt};
+
+#[macro_use]
+mod support;
+
+use support::*;
+
+#[test]
+fn limit() {
+    // Not limited
+
+    let res = one("hello world")
+        .limit(100)
+        .collect::<Vec<_>>()
+        .wait()
+        .unwrap();
+
+    assert_eq!(res, b"hello world");
+
+    let res = list(&["hello", " ", "world"])
+        .limit(100)
+        .collect::<Vec<_>>()
+        .wait()
+        .unwrap();
+
+    assert_eq!(res, b"hello world");
+
+    let res = list(&["hello", " ", "world"])
+        .limit(11)
+        .collect::<Vec<_>>()
+        .wait()
+        .unwrap();
+
+    assert_eq!(res, b"hello world");
+
+    // Limited
+
+    let res = one("hello world").limit(5).collect::<Vec<_>>().wait();
+
+    assert!(res.is_err());
+
+    let res = one("hello world").limit(10).collect::<Vec<_>>().wait();
+
+    assert!(res.is_err());
+
+    let mut bs = list(&["hello", " ", "world"]).limit(9);
+
+    assert_buf_eq!(bs.poll_buf(), "hello");
+    assert_buf_eq!(bs.poll_buf(), " ");
+    assert!(bs.poll_buf().is_err());
+
+    let mut bs = list(&["hello", " ", "world"]);
+    bs.size_hint.set_lower(11);
+    let mut bs = bs.limit(9);
+
+    assert!(bs.poll_buf().is_err());
+}

tokio-buf/tests/size_hint.rs

@@ -0,0 +1,42 @@
+extern crate tokio_buf;
+
+use tokio_buf::SizeHint;
+
+#[test]
+fn size_hint() {
+    let hint = SizeHint::new();
+    assert_eq!(hint.lower(), 0);
+    assert!(hint.upper().is_none());
+
+    let mut hint = SizeHint::new();
+    hint.set_lower(100);
+    assert_eq!(hint.lower(), 100);
+    assert!(hint.upper().is_none());
+
+    let mut hint = SizeHint::new();
+    hint.set_upper(200);
+    assert_eq!(hint.lower(), 0);
+    assert_eq!(hint.upper(), Some(200));
+
+    let mut hint = SizeHint::new();
+    hint.set_lower(100);
+    hint.set_upper(100);
+    assert_eq!(hint.lower(), 100);
+    assert_eq!(hint.upper(), Some(100));
+}
+
+#[test]
+#[should_panic]
+fn size_hint_lower_bigger_than_upper() {
+    let mut hint = SizeHint::new();
+    hint.set_upper(100);
+    hint.set_lower(200);
+}
+
+#[test]
+#[should_panic]
+fn size_hint_upper_less_than_lower() {
+    let mut hint = SizeHint::new();
+    hint.set_lower(200);
+    hint.set_upper(100);
+}

tokio-buf/tests/stream.rs

@@ -0,0 +1,49 @@
+extern crate bytes;
+extern crate futures;
+extern crate tokio_buf;
+extern crate tokio_mock_task;
+
+use futures::sync::mpsc;
+use futures::Async::*;
+use std::io::Cursor;
+use tokio_buf::{util, BufStream};
+use tokio_mock_task::MockTask;
+
+#[macro_use]
+mod support;
+
+type Buf = Cursor<&'static [u8]>;
+
+#[test]
+fn empty_stream() {
+    let (_, rx) = mpsc::unbounded::<Buf>();
+    let mut bs = util::stream(rx);
+    assert_none!(bs.poll_buf());
+}
+
+#[test]
+fn full_stream() {
+    let (tx, rx) = mpsc::unbounded();
+    let mut bs = util::stream(rx);
+    let mut task = MockTask::new();
+
+    tx.unbounded_send(buf(b"one")).unwrap();
+
+    assert_buf_eq!(bs.poll_buf(), "one");
+    task.enter(|| assert_not_ready!(bs.poll_buf()));
+
+    tx.unbounded_send(buf(b"two")).unwrap();
+
+    assert!(task.is_notified());
+    assert_buf_eq!(bs.poll_buf(), "two");
+    task.enter(|| assert_not_ready!(bs.poll_buf()));
+
+    drop(tx);
+
+    assert!(task.is_notified());
+    assert_none!(bs.poll_buf());
+}
+
+fn buf(data: &'static [u8]) -> Buf {
+    Cursor::new(data)
+}

tokio-buf/tests/string.rs

@@ -0,0 +1,38 @@
+extern crate bytes;
+extern crate futures;
+extern crate tokio_buf;
+
+use futures::Async::*;
+use std::fmt;
+use tokio_buf::BufStream;
+
+#[macro_use]
+mod support;
+
+fn test_hello_world<B>(mut bs: B)
+where
+    B: BufStream + fmt::Debug,
+    B::Item: fmt::Debug,
+    B::Error: fmt::Debug,
+{
+    let hint = bs.size_hint();
+    assert_eq!(hint.lower(), 11);
+    assert_eq!(hint.upper(), Some(11));
+
+    assert_buf_eq!(bs.poll_buf(), "hello world");
+
+    let hint = bs.size_hint();
+    assert_eq!(hint.lower(), 0);
+    assert_eq!(hint.upper(), Some(0));
+    assert_none!(bs.poll_buf());
+}
+
+#[test]
+fn string() {
+    test_hello_world("hello world".to_string());
+}
+
+#[test]
+fn str() {
+    test_hello_world("hello world");
+}

tokio-buf/tests/support.rs

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

tokio-codec/CHANGELOG.md

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

tokio-codec/Cargo.toml

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

tokio-codec/LICENSE

@@ -0,0 +1,25 @@
+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.

tokio-codec/README.md

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

tokio-codec/src/bytes_codec.rs

@@ -0,0 +1,39 @@
+use bytes::{BufMut, Bytes, BytesMut};
+use std::io;
+use tokio_io::_tokio_codec::{Decoder, Encoder};
+
+/// A simple `Codec` implementation that just ships bytes around.
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct BytesCodec(());
+
+impl BytesCodec {
+    /// Creates a new `BytesCodec` for shipping around raw bytes.
+    pub fn new() -> BytesCodec {
+        BytesCodec(())
+    }
+}
+
+impl Decoder for BytesCodec {
+    type Item = BytesMut;
+    type Error = io::Error;
+
+    fn decode(&mut self, buf: &mut BytesMut) -> Result<Option<BytesMut>, io::Error> {
+        if buf.len() > 0 {
+            let len = buf.len();
+            Ok(Some(buf.split_to(len)))
+        } else {
+            Ok(None)
+        }
+    }
+}
+
+impl Encoder for BytesCodec {
+    type Item = Bytes;
+    type Error = io::Error;
+
+    fn encode(&mut self, data: Bytes, buf: &mut BytesMut) -> Result<(), io::Error> {
+        buf.reserve(data.len());
+        buf.put(data);
+        Ok(())
+    }
+}

tokio-codec/src/lib.rs

@@ -0,0 +1,25 @@
+#![deny(missing_docs, missing_debug_implementations)]
+#![doc(html_root_url = "https://docs.rs/tokio-codec/0.1.1")]
+
+//! Utilities for encoding and decoding frames.
+//!
+//! Contains adapters to go from streams of bytes, [`AsyncRead`] and
+//! [`AsyncWrite`], to framed streams implementing [`Sink`] and [`Stream`].
+//! Framed streams are also known as [transports].
+//!
+//! [`AsyncRead`]: #
+//! [`AsyncWrite`]: #
+//! [`Sink`]: #
+//! [`Stream`]: #
+//! [transports]: #
+
+extern crate bytes;
+extern crate tokio_io;
+
+mod bytes_codec;
+mod lines_codec;
+
+pub use tokio_io::_tokio_codec::{Decoder, Encoder, Framed, FramedParts, FramedRead, FramedWrite};
+
+pub use bytes_codec::BytesCodec;
+pub use lines_codec::LinesCodec;

tokio-codec/src/lines_codec.rs

@@ -0,0 +1,195 @@
+use bytes::{BufMut, BytesMut};
+use std::{cmp, io, str, usize};
+use tokio_io::_tokio_codec::{Decoder, Encoder};
+
+/// A simple `Codec` implementation that splits up data into lines.
+#[derive(Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct LinesCodec {
+    // Stored index of the next index to examine for a `\n` character.
+    // This is used to optimize searching.
+    // For example, if `decode` was called with `abc`, it would hold `3`,
+    // because that is the next index to examine.
+    // The next time `decode` is called with `abcde\n`, the method will
+    // only look at `de\n` before returning.
+    next_index: usize,
+
+    /// The maximum length for a given line. If `usize::MAX`, lines will be
+    /// read until a `\n` character is reached.
+    max_length: usize,
+
+    /// Are we currently discarding the remainder of a line which was over
+    /// the length limit?
+    is_discarding: bool,
+}
+
+impl LinesCodec {
+    /// Returns a `LinesCodec` for splitting up data into lines.
+    ///
+    /// # Note
+    ///
+    /// The returned `LinesCodec` will not have an upper bound on the length
+    /// of a buffered line. See the documentation for [`new_with_max_length`]
+    /// for information on why this could be a potential security risk.
+    ///
+    /// [`new_with_max_length`]: #method.new_with_max_length
+    pub fn new() -> LinesCodec {
+        LinesCodec {
+            next_index: 0,
+            max_length: usize::MAX,
+            is_discarding: false,
+        }
+    }
+
+    /// Returns a `LinesCodec` with a maximum line length limit.
+    ///
+    /// If this is set, calls to `LinesCodec::decode` will return a
+    /// [`LengthError`] when a line exceeds the length limit. Subsequent calls
+    /// will discard up to `limit` bytes from that line until a newline
+    /// character is reached, returning `None` until the line over the limit
+    /// has been fully discarded. After that point, calls to `decode` will
+    /// function as normal.
+    ///
+    /// # Note
+    ///
+    /// Setting a length limit is highly recommended for any `LinesCodec` which
+    /// will be exposed to untrusted input. Otherwise, the size of the buffer
+    /// that holds the line currently being read is unbounded. An attacker could
+    /// exploit this unbounded buffer by sending an unbounded amount of input
+    /// without any `\n` characters, causing unbounded memory consumption.
+    ///
+    /// [`LengthError`]: ../struct.LengthError
+    pub fn new_with_max_length(max_length: usize) -> Self {
+        LinesCodec {
+            max_length,
+            ..LinesCodec::new()
+        }
+    }
+
+    /// Returns the maximum line length when decoding.
+    ///
+    /// ```
+    /// use std::usize;
+    /// use tokio_codec::LinesCodec;
+    ///
+    /// let codec = LinesCodec::new();
+    /// assert_eq!(codec.max_length(), usize::MAX);
+    /// ```
+    /// ```
+    /// use tokio_codec::LinesCodec;
+    ///
+    /// let codec = LinesCodec::new_with_max_length(256);
+    /// assert_eq!(codec.max_length(), 256);
+    /// ```
+    pub fn max_length(&self) -> usize {
+        self.max_length
+    }
+
+    fn discard(&mut self, newline_offset: Option<usize>, read_to: usize, buf: &mut BytesMut) {
+        let discard_to = if let Some(offset) = newline_offset {
+            // If we found a newline, discard up to that offset and
+            // then stop discarding. On the next iteration, we'll try
+            // to read a line normally.
+            self.is_discarding = false;
+            offset + self.next_index + 1
+        } else {
+            // Otherwise, we didn't find a newline, so we'll discard
+            // everything we read. On the next iteration, we'll continue
+            // discarding up to max_len bytes unless we find a newline.
+            read_to
+        };
+        buf.advance(discard_to);
+        self.next_index = 0;
+    }
+}
+
+fn utf8(buf: &[u8]) -> Result<&str, io::Error> {
+    str::from_utf8(buf)
+        .map_err(|_| io::Error::new(io::ErrorKind::InvalidData, "Unable to decode input as UTF8"))
+}
+
+fn without_carriage_return(s: &[u8]) -> &[u8] {
+    if let Some(&b'\r') = s.last() {
+        &s[..s.len() - 1]
+    } else {
+        s
+    }
+}
+
+impl Decoder for LinesCodec {
+    type Item = String;
+    // TODO: in the next breaking change, this should be changed to a custom
+    // error type that indicates the "max length exceeded" condition better.
+    type Error = io::Error;
+
+    fn decode(&mut self, buf: &mut BytesMut) -> Result<Option<String>, io::Error> {
+        loop {
+            // Determine how far into the buffer we'll search for a newline. If
+            // there's no max_length set, we'll read to the end of the buffer.
+            let read_to = cmp::min(self.max_length.saturating_add(1), buf.len());
+
+            let newline_offset = buf[self.next_index..read_to]
+                .iter()
+                .position(|b| *b == b'\n');
+
+            if self.is_discarding {
+                self.discard(newline_offset, read_to, buf);
+            } else {
+                return if let Some(offset) = newline_offset {
+                    // Found a line!
+                    let newline_index = offset + self.next_index;
+                    self.next_index = 0;
+                    let line = buf.split_to(newline_index + 1);
+                    let line = &line[..line.len() - 1];
+                    let line = without_carriage_return(line);
+                    let line = utf8(line)?;
+
+                    Ok(Some(line.to_string()))
+                } else if buf.len() > self.max_length {
+                    // Reached the maximum length without finding a
+                    // newline, return an error and start discarding on the
+                    // next call.
+                    self.is_discarding = true;
+                    Err(io::Error::new(
+                        io::ErrorKind::Other,
+                        "line length limit exceeded",
+                    ))
+                } else {
+                    // We didn't find a line or reach the length limit, so the next
+                    // call will resume searching at the current offset.
+                    self.next_index = read_to;
+                    Ok(None)
+                };
+            }
+        }
+    }
+
+    fn decode_eof(&mut self, buf: &mut BytesMut) -> Result<Option<String>, io::Error> {
+        Ok(match self.decode(buf)? {
+            Some(frame) => Some(frame),
+            None => {
+                // No terminating newline - return remaining data, if any
+                if buf.is_empty() || buf == &b"\r"[..] {
+                    None
+                } else {
+                    let line = buf.take();
+                    let line = without_carriage_return(&line);
+                    let line = utf8(line)?;
+                    self.next_index = 0;
+                    Some(line.to_string())
+                }
+            }
+        })
+    }
+}
+
+impl Encoder for LinesCodec {
+    type Item = String;
+    type Error = io::Error;
+
+    fn encode(&mut self, line: String, buf: &mut BytesMut) -> Result<(), io::Error> {
+        buf.reserve(line.len() + 1);
+        buf.put(line);
+        buf.put_u8(b'\n');
+        Ok(())
+    }
+}

tokio-codec/tests/codecs.rs

@@ -0,0 +1,202 @@
+extern crate bytes;
+extern crate tokio_codec;
+
+use bytes::{BufMut, Bytes, BytesMut};
+use tokio_codec::{BytesCodec, Decoder, Encoder, LinesCodec};
+
+#[test]
+fn bytes_decoder() {
+    let mut codec = BytesCodec::new();
+    let buf = &mut BytesMut::new();
+    buf.put_slice(b"abc");
+    assert_eq!("abc", codec.decode(buf).unwrap().unwrap());
+    assert_eq!(None, codec.decode(buf).unwrap());
+    assert_eq!(None, codec.decode(buf).unwrap());
+    buf.put_slice(b"a");
+    assert_eq!("a", codec.decode(buf).unwrap().unwrap());
+}
+
+#[test]
+fn bytes_encoder() {
+    let mut codec = BytesCodec::new();
+
+    // Default capacity of BytesMut
+    #[cfg(target_pointer_width = "64")]
+    const INLINE_CAP: usize = 4 * 8 - 1;
+    #[cfg(target_pointer_width = "32")]
+    const INLINE_CAP: usize = 4 * 4 - 1;
+
+    let mut buf = BytesMut::new();
+    codec
+        .encode(Bytes::from_static(&[0; INLINE_CAP + 1]), &mut buf)
+        .unwrap();
+
+    // Default capacity of Framed Read
+    const INITIAL_CAPACITY: usize = 8 * 1024;
+
+    let mut buf = BytesMut::with_capacity(INITIAL_CAPACITY);
+    codec
+        .encode(Bytes::from_static(&[0; INITIAL_CAPACITY + 1]), &mut buf)
+        .unwrap();
+}
+
+#[test]
+fn lines_decoder() {
+    let mut codec = LinesCodec::new();
+    let buf = &mut BytesMut::new();
+    buf.reserve(200);
+    buf.put("line 1\nline 2\r\nline 3\n\r\n\r");
+    assert_eq!("line 1", codec.decode(buf).unwrap().unwrap());
+    assert_eq!("line 2", codec.decode(buf).unwrap().unwrap());
+    assert_eq!("line 3", codec.decode(buf).unwrap().unwrap());
+    assert_eq!("", codec.decode(buf).unwrap().unwrap());
+    assert_eq!(None, codec.decode(buf).unwrap());
+    assert_eq!(None, codec.decode_eof(buf).unwrap());
+    buf.put("k");
+    assert_eq!(None, codec.decode(buf).unwrap());
+    assert_eq!("\rk", codec.decode_eof(buf).unwrap().unwrap());
+    assert_eq!(None, codec.decode(buf).unwrap());
+    assert_eq!(None, codec.decode_eof(buf).unwrap());
+}
+
+#[test]
+fn lines_decoder_max_length() {
+    const MAX_LENGTH: usize = 6;
+
+    let mut codec = LinesCodec::new_with_max_length(MAX_LENGTH);
+    let buf = &mut BytesMut::new();
+
+    buf.reserve(200);
+    buf.put("line 1 is too long\nline 2\nline 3\r\nline 4\n\r\n\r");
+
+    assert!(codec.decode(buf).is_err());
+
+    let line = codec.decode(buf).unwrap().unwrap();
+    assert!(
+        line.len() <= MAX_LENGTH,
+        "{:?}.len() <= {:?}",
+        line,
+        MAX_LENGTH
+    );
+    assert_eq!("line 2", line);
+
+    assert!(codec.decode(buf).is_err());
+
+    let line = codec.decode(buf).unwrap().unwrap();
+    assert!(
+        line.len() <= MAX_LENGTH,
+        "{:?}.len() <= {:?}",
+        line,
+        MAX_LENGTH
+    );
+    assert_eq!("line 4", line);
+
+    let line = codec.decode(buf).unwrap().unwrap();
+    assert!(
+        line.len() <= MAX_LENGTH,
+        "{:?}.len() <= {:?}",
+        line,
+        MAX_LENGTH
+    );
+    assert_eq!("", line);
+
+    assert_eq!(None, codec.decode(buf).unwrap());
+    assert_eq!(None, codec.decode_eof(buf).unwrap());
+    buf.put("k");
+    assert_eq!(None, codec.decode(buf).unwrap());
+
+    let line = codec.decode_eof(buf).unwrap().unwrap();
+    assert!(
+        line.len() <= MAX_LENGTH,
+        "{:?}.len() <= {:?}",
+        line,
+        MAX_LENGTH
+    );
+    assert_eq!("\rk", line);
+
+    assert_eq!(None, codec.decode(buf).unwrap());
+    assert_eq!(None, codec.decode_eof(buf).unwrap());
+
+    // Line that's one character too long. This could cause an out of bounds
+    // error if we peek at the next characters using slice indexing.
+    // buf.put("aaabbbc");
+    // assert!(codec.decode(buf).is_err());
+}
+
+#[test]
+fn lines_decoder_max_length_underrun() {
+    const MAX_LENGTH: usize = 6;
+
+    let mut codec = LinesCodec::new_with_max_length(MAX_LENGTH);
+    let buf = &mut BytesMut::new();
+
+    buf.reserve(200);
+    buf.put("line ");
+    assert_eq!(None, codec.decode(buf).unwrap());
+    buf.put("too l");
+    assert!(codec.decode(buf).is_err());
+    buf.put("ong\n");
+    assert_eq!(None, codec.decode(buf).unwrap());
+
+    buf.put("line 2");
+    assert_eq!(None, codec.decode(buf).unwrap());
+    buf.put("\n");
+    assert_eq!("line 2", codec.decode(buf).unwrap().unwrap());
+}
+
+#[test]
+fn lines_decoder_max_length_bursts() {
+    const MAX_LENGTH: usize = 10;
+
+    let mut codec = LinesCodec::new_with_max_length(MAX_LENGTH);
+    let buf = &mut BytesMut::new();
+
+    buf.reserve(200);
+    buf.put("line ");
+    assert_eq!(None, codec.decode(buf).unwrap());
+    buf.put("too l");
+    assert_eq!(None, codec.decode(buf).unwrap());
+    buf.put("ong\n");
+    assert!(codec.decode(buf).is_err());
+}
+
+#[test]
+fn lines_decoder_max_length_big_burst() {
+    const MAX_LENGTH: usize = 10;
+
+    let mut codec = LinesCodec::new_with_max_length(MAX_LENGTH);
+    let buf = &mut BytesMut::new();
+
+    buf.reserve(200);
+    buf.put("line ");
+    assert_eq!(None, codec.decode(buf).unwrap());
+    buf.put("too long!\n");
+    assert!(codec.decode(buf).is_err());
+}
+
+#[test]
+fn lines_decoder_max_length_newline_between_decodes() {
+    const MAX_LENGTH: usize = 5;
+
+    let mut codec = LinesCodec::new_with_max_length(MAX_LENGTH);
+    let buf = &mut BytesMut::new();
+
+    buf.reserve(200);
+    buf.put("hello");
+    assert_eq!(None, codec.decode(buf).unwrap());
+
+    buf.put("\nworld");
+    assert_eq!("hello", codec.decode(buf).unwrap().unwrap());
+}
+
+#[test]
+fn lines_encoder() {
+    let mut codec = LinesCodec::new();
+    let mut buf = BytesMut::new();
+
+    codec.encode(String::from("line 1"), &mut buf).unwrap();
+    assert_eq!("line 1\n", buf);
+
+    codec.encode(String::from("line 2"), &mut buf).unwrap();
+    assert_eq!("line 1\nline 2\n", buf);
+}

tokio-codec/tests/framed.rs

@@ -0,0 +1,94 @@
+extern crate bytes;
+extern crate futures;
+extern crate tokio_codec;
+extern crate tokio_io;
+
+use bytes::{Buf, BufMut, BytesMut, IntoBuf};
+use futures::{Future, Stream};
+use std::io::{self, Read};
+use tokio_codec::{Decoder, Encoder, Framed, FramedParts};
+use tokio_io::AsyncRead;
+
+const INITIAL_CAPACITY: usize = 8 * 1024;
+
+/// Encode and decode u32 values.
+struct U32Codec;
+
+impl Decoder for U32Codec {
+    type Item = u32;
+    type Error = io::Error;
+
+    fn decode(&mut self, buf: &mut BytesMut) -> io::Result<Option<u32>> {
+        if buf.len() < 4 {
+            return Ok(None);
+        }
+
+        let n = buf.split_to(4).into_buf().get_u32_be();
+        Ok(Some(n))
+    }
+}
+
+impl Encoder for U32Codec {
+    type Item = u32;
+    type Error = io::Error;
+
+    fn encode(&mut self, item: u32, dst: &mut BytesMut) -> io::Result<()> {
+        // Reserve space
+        dst.reserve(4);
+        dst.put_u32_be(item);
+        Ok(())
+    }
+}
+
+/// This value should never be used
+struct DontReadIntoThis;
+
+impl Read for DontReadIntoThis {
+    fn read(&mut self, _: &mut [u8]) -> io::Result<usize> {
+        Err(io::Error::new(
+            io::ErrorKind::Other,
+            "Read into something you weren't supposed to.",
+        ))
+    }
+}
+
+impl AsyncRead for DontReadIntoThis {}
+
+#[test]
+fn can_read_from_existing_buf() {
+    let mut parts = FramedParts::new(DontReadIntoThis, U32Codec);
+    parts.read_buf = vec![0, 0, 0, 42].into();
+
+    let framed = Framed::from_parts(parts);
+
+    let num = framed
+        .into_future()
+        .map(|(first_num, _)| first_num.unwrap())
+        .wait()
+        .map_err(|e| e.0)
+        .unwrap();
+
+    assert_eq!(num, 42);
+}
+
+#[test]
+fn external_buf_grows_to_init() {
+    let mut parts = FramedParts::new(DontReadIntoThis, U32Codec);
+    parts.read_buf = vec![0, 0, 0, 42].into();
+
+    let framed = Framed::from_parts(parts);
+    let FramedParts { read_buf, .. } = framed.into_parts();
+
+    assert_eq!(read_buf.capacity(), INITIAL_CAPACITY);
+}
+
+#[test]
+fn external_buf_does_not_shrink() {
+    let mut parts = FramedParts::new(DontReadIntoThis, U32Codec);
+    parts.read_buf = vec![0; INITIAL_CAPACITY * 2].into();
+
+    let framed = Framed::from_parts(parts);
+    let FramedParts { read_buf, .. } = framed.into_parts();
+
+    assert_eq!(read_buf.capacity(), INITIAL_CAPACITY * 2);
+}

tokio-codec/tests/framed_read.rs

@@ -1,16 +1,17 @@
-extern crate tokio_io;
 extern crate bytes;
 extern crate futures;
+extern crate tokio_codec;
+extern crate tokio_io;
 
+use tokio_codec::{Decoder, FramedRead};
 use tokio_io::AsyncRead;
-use tokio_io::codec::{FramedRead, Decoder};
 
-use bytes::{BytesMut, Buf, IntoBuf, BigEndian};
+use bytes::{Buf, BytesMut, IntoBuf};
+use futures::Async::{NotReady, Ready};
 use futures::Stream;
-use futures::Async::{Ready, NotReady};
 
-use std::io::{self, Read};
 use std::collections::VecDeque;
+use std::io::{self, Read};
 
 macro_rules! mock {
     ($($x:expr,)*) => {{
@@ -31,7 +32,7 @@ impl Decoder for U32Decoder {
             return Ok(None);
         }
 
-        let n = buf.split_to(4).into_buf().get_u32::<BigEndian>();
+        let n = buf.split_to(4).into_buf().get_u32_be();
         Ok(Some(n))
     }
 }
@@ -211,5 +212,4 @@ impl Read for Mock {
     }
 }
 
-impl AsyncRead for Mock {
-}
+impl AsyncRead for Mock {}

tokio-codec/tests/framed_write.rs

@@ -1,15 +1,16 @@
-extern crate tokio_io;
 extern crate bytes;
 extern crate futures;
+extern crate tokio_codec;
+extern crate tokio_io;
 
+use tokio_codec::{Encoder, FramedWrite};
 use tokio_io::AsyncWrite;
-use tokio_io::codec::{Encoder, FramedWrite};
 
-use futures::{Sink, Poll};
-use bytes::{BytesMut, BufMut, BigEndian};
+use bytes::{BufMut, BytesMut};
+use futures::{Poll, Sink};
 
-use std::io::{self, Write};
 use std::collections::VecDeque;
+use std::io::{self, Write};
 
 macro_rules! mock {
     ($($x:expr,)*) => {{
@@ -28,7 +29,7 @@ impl Encoder for U32Encoder {
     fn encode(&mut self, item: u32, dst: &mut BytesMut) -> io::Result<()> {
         // Reserve space
         dst.reserve(4);
-        dst.put_u32::<BigEndian>(item);
+        dst.put_u32_be(item);
         Ok(())
     }
 }
@@ -65,7 +66,7 @@ fn write_hits_backpressure() {
 
     for i in 0..(ITER + 1) {
         let mut b = BytesMut::with_capacity(4);
-        b.put_u32::<BigEndian>(i as u32);
+        b.put_u32_be(i as u32);
 
         // Append to the end
         match mock.calls.back_mut().unwrap() {

tokio-current-thread/CHANGELOG.md

@@ -0,0 +1,31 @@
+# 0.1.6 (March 22, 2019)
+
+### Added
+- implement `TypedExecutor` (#993).
+
+# 0.1.5 (March 1, 2019)
+
+### Fixed
+- Documentation typos (#882).
+
+# 0.1.4 (November 21, 2018)
+
+* Fix shutdown on idle (#763).
+
+# 0.1.3 (September 27, 2018)
+
+* Fix minimal versions
+
+# 0.1.2 (September 26, 2018)
+
+* Implement `futures::Executor` for executor types (#563)
+* Spawning performance improvements (#565)
+
+# 0.1.1 (August 6, 2018)
+
+* Implement `std::Error` for misc error types (#501)
+* bugfix: Track tasks pending in spawn queue (#478)
+
+# 0.1.0 (June 13, 2018)
+
+* Extract `tokio::executor::current_thread` to a tokio-current-thread crate (#356)

tokio-current-thread/Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "tokio-current-thread"
+# When releasing to crates.io:
+# - Remove path dependencies
+# - Update html_root_url.
+# - Update doc url
+#   - Cargo.toml
+#   - README.md
+# - Update CHANGELOG.md.
+# - Create "v0.1.x" git tag.
+version = "0.1.6"
+documentation = "https://docs.rs/tokio-current-thread/0.1.6/tokio_current_thread"
+repository = "https://github.com/tokio-rs/tokio"
+homepage = "https://github.com/tokio-rs/tokio"
+license = "MIT"
+authors = ["Carl Lerche <[email protected]>"]
+description = """
+Single threaded executor which manage many tasks concurrently on the current thread.
+"""
+keywords = ["futures", "tokio"]
+categories = ["concurrency", "asynchronous"]
+
+[dependencies]
+tokio-executor = "0.1.7"
+futures = "0.1.19"

tokio-current-thread/LICENSE

@@ -0,0 +1,25 @@
+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.

tokio-current-thread/README.md

@@ -0,0 +1,19 @@
+# tokio-current-thread
+
+Single threaded executor for Tokio.
+
+[Documentation](https://docs.rs/tokio-current-thread/0.1.6/tokio_current_thread/)
+
+## Overview
+
+This crate provides the single threaded executor which execute many tasks concurrently.
+
+## 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-current-thread/src/lib.rs

@@ -0,0 +1,874 @@
+#![doc(html_root_url = "https://docs.rs/tokio-current-thread/0.1.6")]
+#![deny(missing_docs, missing_debug_implementations)]
+
+//! A single-threaded executor which executes tasks on the same thread from which
+//! they are spawned.
+//!
+//!
+//! The crate provides:
+//!
+//! * [`CurrentThread`] is the main type of this crate. It executes tasks on the current thread.
+//!   The easiest way to start a new [`CurrentThread`] executor is to call
+//!   [`block_on_all`] with an initial task to seed the executor.
+//!   All tasks that are being managed by a [`CurrentThread`] executor are able to
+//!   spawn additional tasks by calling [`spawn`].
+//!
+//!
+//! Application authors will not use this crate directly. Instead, they will use the
+//! `tokio` crate. Library authors should only depend on `tokio-current-thread` if they
+//! are building a custom task executor.
+//!
+//! For more details, see [executor module] documentation in the Tokio crate.
+//!
+//! [`CurrentThread`]: struct.CurrentThread.html
+//! [`spawn`]: fn.spawn.html
+//! [`block_on_all`]: fn.block_on_all.html
+//! [executor module]: https://docs.rs/tokio/0.1/tokio/executor/index.html
+
+extern crate futures;
+extern crate tokio_executor;
+
+mod scheduler;
+
+use self::scheduler::Scheduler;
+
+use tokio_executor::park::{Park, ParkThread, Unpark};
+use tokio_executor::{Enter, SpawnError};
+
+use futures::future::{ExecuteError, ExecuteErrorKind, Executor};
+use futures::{executor, Async, Future};
+
+use std::cell::Cell;
+use std::error::Error;
+use std::fmt;
+use std::rc::Rc;
+use std::sync::{atomic, mpsc, Arc};
+use std::thread;
+use std::time::{Duration, Instant};
+
+/// Executes tasks on the current thread
+pub struct CurrentThread<P: Park = ParkThread> {
+    /// Execute futures and receive unpark notifications.
+    scheduler: Scheduler<P::Unpark>,
+
+    /// Current number of futures being executed.
+    ///
+    /// The LSB is used to indicate that the runtime is preparing to shut down.
+    /// Thus, to get the actual number of pending futures, `>>1`.
+    num_futures: Arc<atomic::AtomicUsize>,
+
+    /// Thread park handle
+    park: P,
+
+    /// Handle for spawning new futures from other threads
+    spawn_handle: Handle,
+
+    /// Receiver for futures spawned from other threads
+    spawn_receiver: mpsc::Receiver<Box<dyn Future<Item = (), Error = ()> + Send + 'static>>,
+
+    /// The thread-local ID assigned to this executor.
+    id: u64,
+}
+
+/// Executes futures on the current thread.
+///
+/// All futures executed using this executor will be executed on the current
+/// thread. As such, `run` will wait for these futures to complete before
+/// returning.
+///
+/// For more details, see the [module level](index.html) documentation.
+#[derive(Debug, Clone)]
+pub struct TaskExecutor {
+    // Prevent the handle from moving across threads.
+    _p: ::std::marker::PhantomData<Rc<()>>,
+}
+
+/// Returned by the `turn` function.
+#[derive(Debug)]
+pub struct Turn {
+    polled: bool,
+}
+
+impl Turn {
+    /// `true` if any futures were polled at all and `false` otherwise.
+    pub fn has_polled(&self) -> bool {
+        self.polled
+    }
+}
+
+/// A `CurrentThread` instance bound to a supplied execution context.
+pub struct Entered<'a, P: Park + 'a> {
+    executor: &'a mut CurrentThread<P>,
+    enter: &'a mut Enter,
+}
+
+/// Error returned by the `run` function.
+#[derive(Debug)]
+pub struct RunError {
+    _p: (),
+}
+
+impl fmt::Display for RunError {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmt, "{}", self.description())
+    }
+}
+
+impl Error for RunError {
+    fn description(&self) -> &str {
+        "Run error"
+    }
+}
+
+/// Error returned by the `run_timeout` function.
+#[derive(Debug)]
+pub struct RunTimeoutError {
+    timeout: bool,
+}
+
+impl fmt::Display for RunTimeoutError {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmt, "{}", self.description())
+    }
+}
+
+impl Error for RunTimeoutError {
+    fn description(&self) -> &str {
+        if self.timeout {
+            "Run timeout error (timeout)"
+        } else {
+            "Run timeout error (not timeout)"
+        }
+    }
+}
+
+/// Error returned by the `turn` function.
+#[derive(Debug)]
+pub struct TurnError {
+    _p: (),
+}
+
+impl fmt::Display for TurnError {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmt, "{}", self.description())
+    }
+}
+
+impl Error for TurnError {
+    fn description(&self) -> &str {
+        "Turn error"
+    }
+}
+
+/// Error returned by the `block_on` function.
+#[derive(Debug)]
+pub struct BlockError<T> {
+    inner: Option<T>,
+}
+
+impl<T> fmt::Display for BlockError<T> {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmt, "Block error")
+    }
+}
+
+impl<T: fmt::Debug> Error for BlockError<T> {
+    fn description(&self) -> &str {
+        "Block error"
+    }
+}
+
+/// This is mostly split out to make the borrow checker happy.
+struct Borrow<'a, U: 'a> {
+    id: u64,
+    scheduler: &'a mut Scheduler<U>,
+    num_futures: &'a atomic::AtomicUsize,
+}
+
+trait SpawnLocal {
+    fn spawn_local(
+        &mut self,
+        future: Box<dyn Future<Item = (), Error = ()>>,
+        already_counted: bool,
+    );
+}
+
+struct CurrentRunner {
+    spawn: Cell<Option<*mut dyn SpawnLocal>>,
+    id: Cell<Option<u64>>,
+}
+
+thread_local! {
+    /// Current thread's task runner. This is set in `TaskRunner::with`
+    static CURRENT: CurrentRunner = CurrentRunner {
+        spawn: Cell::new(None),
+        id: Cell::new(None),
+    }
+}
+
+thread_local! {
+    /// Unique ID to assign to each new executor launched on this thread.
+    ///
+    /// The unique ID is used to determine if the currently running executor matches the one
+    /// referred to by a `Handle` so that direct task dispatch can be used.
+    static EXECUTOR_ID: Cell<u64> = Cell::new(0)
+}
+
+/// Run the executor bootstrapping the execution with the provided future.
+///
+/// This creates a new [`CurrentThread`] executor, spawns the provided future,
+/// and blocks the current thread until the provided future and **all**
+/// subsequently spawned futures complete. In other words:
+///
+/// * If the provided bootstrap future does **not** spawn any additional tasks,
+///   `block_on_all` returns once `future` completes.
+/// * If the provided bootstrap future **does** spawn additional tasks, then
+///   `block_on_all` returns once **all** spawned futures complete.
+///
+/// See [module level][mod] documentation for more details.
+///
+/// [`CurrentThread`]: struct.CurrentThread.html
+/// [mod]: index.html
+pub fn block_on_all<F>(future: F) -> Result<F::Item, F::Error>
+where
+    F: Future,
+{
+    let mut current_thread = CurrentThread::new();
+
+    let ret = current_thread.block_on(future);
+    current_thread.run().unwrap();
+
+    ret.map_err(|e| e.into_inner().expect("unexpected execution error"))
+}
+
+/// Executes a future on the current thread.
+///
+/// The provided future must complete or be canceled before `run` will return.
+///
+/// Unlike [`tokio::spawn`], this function will always spawn on a
+/// `CurrentThread` executor and is able to spawn futures that are not `Send`.
+///
+/// # Panics
+///
+/// This function can only be invoked from the context of a `run` call; any
+/// other use will result in a panic.
+///
+/// [`tokio::spawn`]: ../fn.spawn.html
+pub fn spawn<F>(future: F)
+where
+    F: Future<Item = (), Error = ()> + 'static,
+{
+    TaskExecutor::current()
+        .spawn_local(Box::new(future))
+        .unwrap();
+}
+
+// ===== impl CurrentThread =====
+
+impl CurrentThread<ParkThread> {
+    /// Create a new instance of `CurrentThread`.
+    pub fn new() -> Self {
+        CurrentThread::new_with_park(ParkThread::new())
+    }
+}
+
+impl<P: Park> CurrentThread<P> {
+    /// Create a new instance of `CurrentThread` backed by the given park
+    /// handle.
+    pub fn new_with_park(park: P) -> Self {
+        let unpark = park.unpark();
+
+        let (spawn_sender, spawn_receiver) = mpsc::channel();
+        let thread = thread::current().id();
+        let id = EXECUTOR_ID.with(|idc| {
+            let id = idc.get();
+            idc.set(id + 1);
+            id
+        });
+
+        let scheduler = Scheduler::new(unpark);
+        let notify = scheduler.notify();
+
+        let num_futures = Arc::new(atomic::AtomicUsize::new(0));
+
+        CurrentThread {
+            scheduler: scheduler,
+            num_futures: num_futures.clone(),
+            park,
+            id,
+            spawn_handle: Handle {
+                sender: spawn_sender,
+                num_futures: num_futures,
+                notify: notify,
+                shut_down: Cell::new(false),
+                thread: thread,
+                id,
+            },
+            spawn_receiver: spawn_receiver,
+        }
+    }
+
+    /// Returns `true` if the executor is currently idle.
+    ///
+    /// An idle executor is defined by not currently having any spawned tasks.
+    ///
+    /// Note that this method is inherently racy -- if a future is spawned from a remote `Handle`,
+    /// this method may return `true` even though there are more futures to be executed.
+    pub fn is_idle(&self) -> bool {
+        self.num_futures.load(atomic::Ordering::SeqCst) <= 1
+    }
+
+    /// Spawn the future on the executor.
+    ///
+    /// This internally queues the future to be executed once `run` is called.
+    pub fn spawn<F>(&mut self, future: F) -> &mut Self
+    where
+        F: Future<Item = (), Error = ()> + 'static,
+    {
+        self.borrow().spawn_local(Box::new(future), false);
+        self
+    }
+
+    /// Synchronously waits for the provided `future` to complete.
+    ///
+    /// This function can be used to synchronously block the current thread
+    /// until the provided `future` has resolved either successfully or with an
+    /// error. The result of the future is then returned from this function
+    /// call.
+    ///
+    /// Note that this function will **also** execute any spawned futures on the
+    /// current thread, but will **not** block until these other spawned futures
+    /// have completed.
+    ///
+    /// The caller is responsible for ensuring that other spawned futures
+    /// complete execution.
+    pub fn block_on<F>(&mut self, future: F) -> Result<F::Item, BlockError<F::Error>>
+    where
+        F: Future,
+    {
+        let mut enter = tokio_executor::enter().expect("failed to start `current_thread::Runtime`");
+        self.enter(&mut enter).block_on(future)
+    }
+
+    /// Run the executor to completion, blocking the thread until **all**
+    /// spawned futures have completed.
+    pub fn run(&mut self) -> Result<(), RunError> {
+        let mut enter = tokio_executor::enter().expect("failed to start `current_thread::Runtime`");
+        self.enter(&mut enter).run()
+    }
+
+    /// Run the executor to completion, blocking the thread until all
+    /// spawned futures have completed **or** `duration` time has elapsed.
+    pub fn run_timeout(&mut self, duration: Duration) -> Result<(), RunTimeoutError> {
+        let mut enter = tokio_executor::enter().expect("failed to start `current_thread::Runtime`");
+        self.enter(&mut enter).run_timeout(duration)
+    }
+
+    /// Perform a single iteration of the event loop.
+    ///
+    /// This function blocks the current thread even if the executor is idle.
+    pub fn turn(&mut self, duration: Option<Duration>) -> Result<Turn, TurnError> {
+        let mut enter = tokio_executor::enter().expect("failed to start `current_thread::Runtime`");
+        self.enter(&mut enter).turn(duration)
+    }
+
+    /// Bind `CurrentThread` instance with an execution context.
+    pub fn enter<'a>(&'a mut self, enter: &'a mut Enter) -> Entered<'a, P> {
+        Entered {
+            executor: self,
+            enter,
+        }
+    }
+
+    /// Returns a reference to the underlying `Park` instance.
+    pub fn get_park(&self) -> &P {
+        &self.park
+    }
+
+    /// Returns a mutable reference to the underlying `Park` instance.
+    pub fn get_park_mut(&mut self) -> &mut P {
+        &mut self.park
+    }
+
+    fn borrow(&mut self) -> Borrow<P::Unpark> {
+        Borrow {
+            id: self.id,
+            scheduler: &mut self.scheduler,
+            num_futures: &*self.num_futures,
+        }
+    }
+
+    /// Get a new handle to spawn futures on the executor
+    ///
+    /// Different to the executor itself, the handle can be sent to different
+    /// threads and can be used to spawn futures on the executor.
+    pub fn handle(&self) -> Handle {
+        self.spawn_handle.clone()
+    }
+}
+
+impl<P: Park> Drop for CurrentThread<P> {
+    fn drop(&mut self) {
+        // Signal to Handles that no more futures can be spawned by setting LSB.
+        //
+        // NOTE: this isn't technically necessary since the send on the mpsc will fail once the
+        // receiver is dropped, but it's useful to illustrate how clean shutdown will be
+        // implemented (e.g., by setting the LSB).
+        let pending = self.num_futures.fetch_add(1, atomic::Ordering::SeqCst);
+
+        // TODO: We currently ignore any pending futures at the time we shut down.
+        //
+        // The "proper" fix for this is to have an explicit shutdown phase (`shutdown_on_idle`)
+        // which sets LSB (as above) do make Handle::spawn stop working, and then runs until
+        // num_futures.load() == 1.
+        let _ = pending;
+    }
+}
+
+impl tokio_executor::Executor for CurrentThread {
+    fn spawn(
+        &mut self,
+        future: Box<dyn Future<Item = (), Error = ()> + Send>,
+    ) -> Result<(), SpawnError> {
+        self.borrow().spawn_local(future, false);
+        Ok(())
+    }
+}
+
+impl<T> tokio_executor::TypedExecutor<T> for CurrentThread
+where
+    T: Future<Item = (), Error = ()> + 'static,
+{
+    fn spawn(&mut self, future: T) -> Result<(), SpawnError> {
+        self.borrow().spawn_local(Box::new(future), false);
+        Ok(())
+    }
+}
+
+impl<P: Park> fmt::Debug for CurrentThread<P> {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.debug_struct("CurrentThread")
+            .field("scheduler", &self.scheduler)
+            .field(
+                "num_futures",
+                &self.num_futures.load(atomic::Ordering::SeqCst),
+            )
+            .finish()
+    }
+}
+
+// ===== impl Entered =====
+
+impl<'a, P: Park> Entered<'a, P> {
+    /// Spawn the future on the executor.
+    ///
+    /// This internally queues the future to be executed once `run` is called.
+    pub fn spawn<F>(&mut self, future: F) -> &mut Self
+    where
+        F: Future<Item = (), Error = ()> + 'static,
+    {
+        self.executor.borrow().spawn_local(Box::new(future), false);
+        self
+    }
+
+    /// Synchronously waits for the provided `future` to complete.
+    ///
+    /// This function can be used to synchronously block the current thread
+    /// until the provided `future` has resolved either successfully or with an
+    /// error. The result of the future is then returned from this function
+    /// call.
+    ///
+    /// Note that this function will **also** execute any spawned futures on the
+    /// current thread, but will **not** block until these other spawned futures
+    /// have completed.
+    ///
+    /// The caller is responsible for ensuring that other spawned futures
+    /// complete execution.
+    pub fn block_on<F>(&mut self, future: F) -> Result<F::Item, BlockError<F::Error>>
+    where
+        F: Future,
+    {
+        let mut future = executor::spawn(future);
+        let notify = self.executor.scheduler.notify();
+
+        loop {
+            let res = self
+                .executor
+                .borrow()
+                .enter(self.enter, || future.poll_future_notify(&notify, 0));
+
+            match res {
+                Ok(Async::Ready(e)) => return Ok(e),
+                Err(e) => return Err(BlockError { inner: Some(e) }),
+                Ok(Async::NotReady) => {}
+            }
+
+            self.tick();
+
+            if let Err(_) = self.executor.park.park() {
+                return Err(BlockError { inner: None });
+            }
+        }
+    }
+
+    /// Run the executor to completion, blocking the thread until **all**
+    /// spawned futures have completed.
+    pub fn run(&mut self) -> Result<(), RunError> {
+        self.run_timeout2(None).map_err(|_| RunError { _p: () })
+    }
+
+    /// Run the executor to completion, blocking the thread until all
+    /// spawned futures have completed **or** `duration` time has elapsed.
+    pub fn run_timeout(&mut self, duration: Duration) -> Result<(), RunTimeoutError> {
+        self.run_timeout2(Some(duration))
+    }
+
+    /// Perform a single iteration of the event loop.
+    ///
+    /// This function blocks the current thread even if the executor is idle.
+    pub fn turn(&mut self, duration: Option<Duration>) -> Result<Turn, TurnError> {
+        let res = if self.executor.scheduler.has_pending_futures() {
+            self.executor.park.park_timeout(Duration::from_millis(0))
+        } else {
+            match duration {
+                Some(duration) => self.executor.park.park_timeout(duration),
+                None => self.executor.park.park(),
+            }
+        };
+
+        if res.is_err() {
+            return Err(TurnError { _p: () });
+        }
+
+        let polled = self.tick();
+
+        Ok(Turn { polled })
+    }
+
+    /// Returns a reference to the underlying `Park` instance.
+    pub fn get_park(&self) -> &P {
+        &self.executor.park
+    }
+
+    /// Returns a mutable reference to the underlying `Park` instance.
+    pub fn get_park_mut(&mut self) -> &mut P {
+        &mut self.executor.park
+    }
+
+    fn run_timeout2(&mut self, dur: Option<Duration>) -> Result<(), RunTimeoutError> {
+        if self.executor.is_idle() {
+            // Nothing to do
+            return Ok(());
+        }
+
+        let mut time = dur.map(|dur| (Instant::now() + dur, dur));
+
+        loop {
+            self.tick();
+
+            if self.executor.is_idle() {
+                return Ok(());
+            }
+
+            match time {
+                Some((until, rem)) => {
+                    if let Err(_) = self.executor.park.park_timeout(rem) {
+                        return Err(RunTimeoutError::new(false));
+                    }
+
+                    let now = Instant::now();
+
+                    if now >= until {
+                        return Err(RunTimeoutError::new(true));
+                    }
+
+                    time = Some((until, until - now));
+                }
+                None => {
+                    if let Err(_) = self.executor.park.park() {
+                        return Err(RunTimeoutError::new(false));
+                    }
+                }
+            }
+        }
+    }
+
+    /// Returns `true` if any futures were processed
+    fn tick(&mut self) -> bool {
+        // Spawn any futures that were spawned from other threads by manually
+        // looping over the receiver stream
+
+        // FIXME: Slightly ugly but needed to make the borrow checker happy
+        let (mut borrow, spawn_receiver) = (
+            Borrow {
+                id: self.executor.id,
+                scheduler: &mut self.executor.scheduler,
+                num_futures: &*self.executor.num_futures,
+            },
+            &mut self.executor.spawn_receiver,
+        );
+
+        while let Ok(future) = spawn_receiver.try_recv() {
+            borrow.spawn_local(future, true);
+        }
+
+        // After any pending futures were scheduled, do the actual tick
+        borrow
+            .scheduler
+            .tick(borrow.id, &mut *self.enter, borrow.num_futures)
+    }
+}
+
+impl<'a, P: Park> fmt::Debug for Entered<'a, P> {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.debug_struct("Entered")
+            .field("executor", &self.executor)
+            .field("enter", &self.enter)
+            .finish()
+    }
+}
+
+// ===== impl Handle =====
+
+/// Handle to spawn a future on the corresponding `CurrentThread` instance
+#[derive(Clone)]
+pub struct Handle {
+    sender: mpsc::Sender<Box<dyn Future<Item = (), Error = ()> + Send + 'static>>,
+    num_futures: Arc<atomic::AtomicUsize>,
+    shut_down: Cell<bool>,
+    notify: executor::NotifyHandle,
+    thread: thread::ThreadId,
+
+    /// The thread-local ID assigned to this Handle's executor.
+    id: u64,
+}
+
+// Manual implementation because the Sender does not implement Debug
+impl fmt::Debug for Handle {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.debug_struct("Handle")
+            .field("shut_down", &self.shut_down.get())
+            .finish()
+    }
+}
+
+impl Handle {
+    /// Spawn a future onto the `CurrentThread` instance corresponding to this handle
+    ///
+    /// # Panics
+    ///
+    /// This function panics if the spawn fails. Failure occurs if the `CurrentThread`
+    /// instance of the `Handle` does not exist anymore.
+    pub fn spawn<F>(&self, future: F) -> Result<(), SpawnError>
+    where
+        F: Future<Item = (), Error = ()> + Send + 'static,
+    {
+        if thread::current().id() == self.thread {
+            let mut e = TaskExecutor::current();
+            if e.id() == Some(self.id) {
+                return e.spawn_local(Box::new(future));
+            }
+        }
+
+        if self.shut_down.get() {
+            return Err(SpawnError::shutdown());
+        }
+
+        // NOTE: += 2 since LSB is the shutdown bit
+        let pending = self.num_futures.fetch_add(2, atomic::Ordering::SeqCst);
+        if pending % 2 == 1 {
+            // Bring the count back so we still know when the Runtime is idle.
+            self.num_futures.fetch_sub(2, atomic::Ordering::SeqCst);
+
+            // Once the Runtime is shutting down, we know it won't come back.
+            self.shut_down.set(true);
+
+            return Err(SpawnError::shutdown());
+        }
+
+        self.sender
+            .send(Box::new(future))
+            .expect("CurrentThread does not exist anymore");
+        // use 0 for the id, CurrentThread does not make use of it
+        self.notify.notify(0);
+        Ok(())
+    }
+
+    /// Provides a best effort **hint** to whether or not `spawn` will succeed.
+    ///
+    /// This function may return both false positives **and** false negatives.
+    /// If `status` returns `Ok`, then a call to `spawn` will *probably*
+    /// succeed, but may fail. If `status` returns `Err`, a call to `spawn` will
+    /// *probably* fail, but may succeed.
+    ///
+    /// This allows a caller to avoid creating the task if the call to `spawn`
+    /// has a high likelihood of failing.
+    pub fn status(&self) -> Result<(), SpawnError> {
+        if self.shut_down.get() {
+            return Err(SpawnError::shutdown());
+        }
+
+        Ok(())
+    }
+}
+
+// ===== impl TaskExecutor =====
+
+impl TaskExecutor {
+    /// Returns an executor that executes futures on the current thread.
+    ///
+    /// The user of `TaskExecutor` must ensure that when a future is submitted,
+    /// that it is done within the context of a call to `run`.
+    ///
+    /// For more details, see the [module level](index.html) documentation.
+    pub fn current() -> TaskExecutor {
+        TaskExecutor {
+            _p: ::std::marker::PhantomData,
+        }
+    }
+
+    /// Get the current executor's thread-local ID.
+    fn id(&self) -> Option<u64> {
+        CURRENT.with(|current| current.id.get())
+    }
+
+    /// Spawn a future onto the current `CurrentThread` instance.
+    pub fn spawn_local(
+        &mut self,
+        future: Box<dyn Future<Item = (), Error = ()>>,
+    ) -> Result<(), SpawnError> {
+        CURRENT.with(|current| match current.spawn.get() {
+            Some(spawn) => {
+                unsafe { (*spawn).spawn_local(future, false) };
+                Ok(())
+            }
+            None => Err(SpawnError::shutdown()),
+        })
+    }
+}
+
+impl tokio_executor::Executor for TaskExecutor {
+    fn spawn(
+        &mut self,
+        future: Box<dyn Future<Item = (), Error = ()> + Send>,
+    ) -> Result<(), SpawnError> {
+        self.spawn_local(future)
+    }
+}
+
+impl<F> tokio_executor::TypedExecutor<F> for TaskExecutor
+where
+    F: Future<Item = (), Error = ()> + 'static,
+{
+    fn spawn(&mut self, future: F) -> Result<(), SpawnError> {
+        self.spawn_local(Box::new(future))
+    }
+}
+
+impl<F> Executor<F> for TaskExecutor
+where
+    F: Future<Item = (), Error = ()> + 'static,
+{
+    fn execute(&self, future: F) -> Result<(), ExecuteError<F>> {
+        CURRENT.with(|current| match current.spawn.get() {
+            Some(spawn) => {
+                unsafe { (*spawn).spawn_local(Box::new(future), false) };
+                Ok(())
+            }
+            None => Err(ExecuteError::new(ExecuteErrorKind::Shutdown, future)),
+        })
+    }
+}
+
+// ===== impl Borrow =====
+
+impl<'a, U: Unpark> Borrow<'a, U> {
+    fn enter<F, R>(&mut self, _: &mut Enter, f: F) -> R
+    where
+        F: FnOnce() -> R,
+    {
+        CURRENT.with(|current| {
+            current.id.set(Some(self.id));
+            current.set_spawn(self, || f())
+        })
+    }
+}
+
+impl<'a, U: Unpark> SpawnLocal for Borrow<'a, U> {
+    fn spawn_local(
+        &mut self,
+        future: Box<dyn Future<Item = (), Error = ()>>,
+        already_counted: bool,
+    ) {
+        if !already_counted {
+            // NOTE: we have a borrow of the Runtime, so we know that it isn't shut down.
+            // NOTE: += 2 since LSB is the shutdown bit
+            self.num_futures.fetch_add(2, atomic::Ordering::SeqCst);
+        }
+        self.scheduler.schedule(future);
+    }
+}
+
+// ===== impl CurrentRunner =====
+
+impl CurrentRunner {
+    fn set_spawn<F, R>(&self, spawn: &mut dyn SpawnLocal, f: F) -> R
+    where
+        F: FnOnce() -> R,
+    {
+        struct Reset<'a>(&'a CurrentRunner);
+
+        impl<'a> Drop for Reset<'a> {
+            fn drop(&mut self) {
+                self.0.spawn.set(None);
+                self.0.id.set(None);
+            }
+        }
+
+        let _reset = Reset(self);
+
+        let spawn = unsafe { hide_lt(spawn as *mut dyn SpawnLocal) };
+        self.spawn.set(Some(spawn));
+
+        f()
+    }
+}
+
+unsafe fn hide_lt<'a>(p: *mut (dyn SpawnLocal + 'a)) -> *mut (dyn SpawnLocal + 'static) {
+    use std::mem;
+    mem::transmute(p)
+}
+
+// ===== impl RunTimeoutError =====
+
+impl RunTimeoutError {
+    fn new(timeout: bool) -> Self {
+        RunTimeoutError { timeout }
+    }
+
+    /// Returns `true` if the error was caused by the operation timing out.
+    pub fn is_timeout(&self) -> bool {
+        self.timeout
+    }
+}
+
+impl From<tokio_executor::EnterError> for RunTimeoutError {
+    fn from(_: tokio_executor::EnterError) -> Self {
+        RunTimeoutError::new(false)
+    }
+}
+
+// ===== impl BlockError =====
+
+impl<T> BlockError<T> {
+    /// Returns the error yielded by the future being blocked on
+    pub fn into_inner(self) -> Option<T> {
+        self.inner
+    }
+}
+
+impl<T> From<tokio_executor::EnterError> for BlockError<T> {
+    fn from(_: tokio_executor::EnterError) -> Self {
+        BlockError { inner: None }
+    }
+}

tokio-current-thread/src/scheduler.rs

@@ -1,20 +1,20 @@
 use super::Borrow;
-use tokio_executor::Enter;
 use tokio_executor::park::Unpark;
+use tokio_executor::Enter;
 
-use futures::{Future, Async};
-use futures::executor::{self, Spawn, UnsafeNotify, NotifyHandle};
+use futures::executor::{self, NotifyHandle, Spawn, UnsafeNotify};
+use futures::{Async, Future};
 
 use std::cell::UnsafeCell;
 use std::fmt::{self, Debug};
+use std::marker::PhantomData;
 use std::mem;
 use std::ptr;
-use std::sync::atomic::Ordering::{Relaxed, SeqCst, Acquire, Release, AcqRel};
-use std::sync::atomic::{AtomicPtr, AtomicBool, AtomicUsize};
+use std::sync::atomic::Ordering::{AcqRel, Acquire, Relaxed, Release, SeqCst};
+use std::sync::atomic::{AtomicBool, AtomicPtr, AtomicUsize};
 use std::sync::{Arc, Weak};
-use std::usize;
 use std::thread;
-use std::marker::PhantomData;
+use std::usize;
 
 /// A generic task-aware scheduler.
 ///
@@ -52,7 +52,7 @@ struct List<U> {
 // Specifically, when a node is stored in at least one of the two lists
 // described above, this represents a logical `Arc` handle. This is how
 // `Scheduler` maintains its reference to all nodes it manages. Each
-// `NotifyHande` instance is an `Arc<Node>` as well.
+// `NotifyHandle` instance is an `Arc<Node>` as well.
 //
 // When `Scheduler` drops, it clears the linked list of all nodes that it
 // manages. When doing so, it must attempt to decrement the reference count (by
@@ -73,7 +73,7 @@ struct Inner<U> {
     head_readiness: AtomicPtr<Node<U>>,
     tail_readiness: UnsafeCell<*const Node<U>>,
 
-    // Used as part of the MPSC queue algorithm
+    // Used as part of the mpsc queue algorithm
     stub: Arc<Node<U>>,
 }
 
@@ -125,7 +125,7 @@ enum Dequeue<U> {
 }
 
 /// Wraps a spawned boxed future
-struct Task(Spawn<Box<Future<Item = (), Error = ()>>>);
+struct Task(Spawn<Box<dyn Future<Item = (), Error = ()>>>);
 
 /// A task that is scheduled. `turn` must be called
 pub struct Scheduled<'a, U: 'a> {
@@ -135,7 +135,8 @@ pub struct Scheduled<'a, U: 'a> {
 }
 
 impl<U> Scheduler<U>
-where U: Unpark,
+where
+    U: Unpark,
 {
     /// Constructs a new, empty `Scheduler`
     ///
@@ -170,7 +171,7 @@ where U: Unpark,
         self.inner.clone().into()
     }
 
-    pub fn schedule(&mut self, item: Box<Future<Item = (), Error = ()>>) {
+    pub fn schedule(&mut self, item: Box<dyn Future<Item = (), Error = ()>>) {
         // Get the current scheduler tick
         let tick_num = self.inner.tick_num.load(SeqCst);
 
@@ -196,16 +197,21 @@ where U: Unpark,
         self.inner.enqueue(ptr);
     }
 
+    /// Returns `true` if there are currently any pending futures
+    pub fn has_pending_futures(&mut self) -> bool {
+        // See function definition for why the unsafe is needed and
+        // correctly used here
+        unsafe { self.inner.has_pending_futures() }
+    }
+
     /// Advance the scheduler state, returning `true` if any futures were
     /// processed.
     ///
     /// This function should be called whenever the caller is notified via a
     /// wakeup.
-    pub fn tick(&mut self, enter: &mut Enter, num_futures: &mut usize) -> bool
-    {
+    pub fn tick(&mut self, eid: u64, enter: &mut Enter, num_futures: &AtomicUsize) -> bool {
         let mut ret = false;
-        let tick = self.inner.tick_num.fetch_add(1, SeqCst)
-            .wrapping_add(1);
+        let tick = self.inner.tick_num.fetch_add(1, SeqCst).wrapping_add(1);
 
         loop {
             let node = match unsafe { self.inner.dequeue(Some(tick)) } {
@@ -233,11 +239,11 @@ where U: Unpark,
                     // being released, another thread notified it, which
                     // resulted in it getting pushed into the mpsc channel.
                     //
-                    // In this case, we just dec the ref count.
+                    // In this case, we just decrement the ref count.
                     let node = ptr2arc(node);
                     assert!((*node.next_all.get()).is_null());
                     assert!((*node.prev_all.get()).is_null());
-                    continue
+                    continue;
                 };
 
                 // We're going to need to be very careful if the `poll`
@@ -270,6 +276,7 @@ where U: Unpark,
                 let node = self.nodes.remove(node);
 
                 let mut borrow = Borrow {
+                    id: eid,
                     scheduler: self,
                     num_futures,
                 };
@@ -321,7 +328,8 @@ where U: Unpark,
                     };
 
                     if borrow.enter(enter, || scheduled.tick()) {
-                        *borrow.num_futures -= 1;
+                        // we have a borrow of the Runtime, so we know it's not shut down
+                        borrow.num_futures.fetch_sub(2, SeqCst);
                     }
                 }
 
@@ -351,15 +359,14 @@ impl<'a, U: Unpark> Scheduled<'a, U> {
 }
 
 impl Task {
-    pub fn new(future: Box<Future<Item = (), Error = ()> + 'static>) -> Self {
+    pub fn new(future: Box<dyn Future<Item = (), Error = ()> + 'static>) -> Self {
         Task(executor::spawn(future))
     }
 }
 
 impl fmt::Debug for Task {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        fmt.debug_struct("Task")
-            .finish()
+        fmt.debug_struct("Task").finish()
     }
 }
 
@@ -439,6 +446,22 @@ impl<U> Inner<U> {
         }
     }
 
+    /// Returns `true` if there are currently any pending futures
+    ///
+    /// See `dequeue` for an explanation why this function is unsafe.
+    unsafe fn has_pending_futures(&self) -> bool {
+        let tail = *self.tail_readiness.get();
+        let next = (*tail).next_readiness.load(Acquire);
+
+        if tail == self.stub() {
+            if next.is_null() {
+                return false;
+            }
+        }
+
+        true
+    }
+
     /// The dequeue function from the 1024cores intrusive MPSC queue algorithm
     ///
     /// Note that this unsafe as it required mutual exclusion (only one thread
@@ -532,7 +555,7 @@ impl<U> List<U> {
         }
     }
 
-    /// Prepends an element to the back of the list
+    /// Appends an element to the back of the list
     fn push_back(&mut self, node: Arc<Node<U>>) -> *const Node<U> {
         let ptr = arc2ptr(node);
 
@@ -553,7 +576,7 @@ impl<U> List<U> {
 
         self.len += 1;
 
-        return ptr
+        return ptr;
     }
 
     /// Pop an element from the front of the list
@@ -605,7 +628,7 @@ impl<U> List<U> {
 
         self.len -= 1;
 
-        return node
+        return node;
     }
 }
 
@@ -617,7 +640,7 @@ impl<'a, U> Clone for Notify<'a, U> {
 
 impl<'a, U> fmt::Debug for Notify<'a, U> {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        fmt.debug_struct("Notiy").finish()
+        fmt.debug_struct("Notify").finish()
     }
 }
 
@@ -664,8 +687,8 @@ unsafe impl<U: Unpark> UnsafeNotify for ArcNode<U> {
     }
 }
 
-unsafe fn hide_lt<U: Unpark>(p: *mut ArcNode<U>) -> *mut UnsafeNotify {
-    mem::transmute(p as *mut UnsafeNotify)
+unsafe fn hide_lt<U: Unpark>(p: *mut ArcNode<U>) -> *mut dyn UnsafeNotify {
+    mem::transmute(p as *mut dyn UnsafeNotify)
 }
 
 impl<U: Unpark> Node<U> {
@@ -722,7 +745,7 @@ impl<U> Drop for Node<U> {
 fn arc2ptr<T>(ptr: Arc<T>) -> *const T {
     let addr = &*ptr as *const T;
     mem::forget(ptr);
-    return addr
+    return addr;
 }
 
 unsafe fn ptr2arc<T>(ptr: *const T) -> Arc<T> {

tokio-current-thread/tests/current_thread.rs

@@ -0,0 +1,835 @@
+extern crate futures;
+extern crate tokio_current_thread;
+extern crate tokio_executor;
+
+use tokio_current_thread::{block_on_all, CurrentThread};
+
+use std::any::Any;
+use std::cell::{Cell, RefCell};
+use std::rc::Rc;
+use std::thread;
+use std::time::Duration;
+
+use futures::future::{self, lazy};
+use futures::task;
+// This is not actually unused --- we need this trait to be in scope for
+// the tests that sue TaskExecutor::current().execute(). The compiler
+// doesn't realise that.
+#[allow(unused_imports)]
+use futures::future::Executor as _futures_Executor;
+use futures::prelude::*;
+use futures::sync::oneshot;
+
+mod from_block_on_all {
+    use super::*;
+    fn test<F: Fn(Box<dyn Future<Item = (), Error = ()>>) + 'static>(spawn: F) {
+        let cnt = Rc::new(Cell::new(0));
+        let c = cnt.clone();
+
+        let msg = tokio_current_thread::block_on_all(lazy(move || {
+            c.set(1 + c.get());
+
+            // Spawn!
+            spawn(Box::new(lazy(move || {
+                c.set(1 + c.get());
+                Ok::<(), ()>(())
+            })));
+
+            Ok::<_, ()>("hello")
+        }))
+        .unwrap();
+
+        assert_eq!(2, cnt.get());
+        assert_eq!(msg, "hello");
+    }
+
+    #[test]
+    fn spawn() {
+        test(tokio_current_thread::spawn)
+    }
+
+    #[test]
+    fn execute() {
+        test(|f| {
+            tokio_current_thread::TaskExecutor::current()
+                .execute(f)
+                .unwrap();
+        });
+    }
+}
+
+#[test]
+fn block_waits() {
+    let (tx, rx) = oneshot::channel();
+
+    thread::spawn(|| {
+        thread::sleep(Duration::from_millis(1000));
+        tx.send(()).unwrap();
+    });
+
+    let cnt = Rc::new(Cell::new(0));
+    let cnt2 = cnt.clone();
+
+    block_on_all(rx.then(move |_| {
+        cnt.set(1 + cnt.get());
+        Ok::<_, ()>(())
+    }))
+    .unwrap();
+
+    assert_eq!(1, cnt2.get());
+}
+
+#[test]
+fn spawn_many() {
+    const ITER: usize = 200;
+
+    let cnt = Rc::new(Cell::new(0));
+    let mut tokio_current_thread = CurrentThread::new();
+
+    for _ in 0..ITER {
+        let cnt = cnt.clone();
+        tokio_current_thread.spawn(lazy(move || {
+            cnt.set(1 + cnt.get());
+            Ok::<(), ()>(())
+        }));
+    }
+
+    tokio_current_thread.run().unwrap();
+
+    assert_eq!(cnt.get(), ITER);
+}
+
+mod does_not_set_global_executor_by_default {
+    use super::*;
+
+    fn test<F: Fn(Box<dyn Future<Item = (), Error = ()> + Send>) -> Result<(), E> + 'static, E>(
+        spawn: F,
+    ) {
+        block_on_all(lazy(|| {
+            spawn(Box::new(lazy(|| ok()))).unwrap_err();
+            ok()
+        }))
+        .unwrap()
+    }
+
+    #[test]
+    fn spawn() {
+        use tokio_executor::Executor;
+        test(|f| tokio_executor::DefaultExecutor::current().spawn(f))
+    }
+
+    #[test]
+    fn execute() {
+        test(|f| tokio_executor::DefaultExecutor::current().execute(f))
+    }
+}
+
+mod from_block_on_future {
+    use super::*;
+
+    fn test<F: Fn(Box<dyn Future<Item = (), Error = ()>>)>(spawn: F) {
+        let cnt = Rc::new(Cell::new(0));
+
+        let mut tokio_current_thread = CurrentThread::new();
+
+        tokio_current_thread
+            .block_on(lazy(|| {
+                let cnt = cnt.clone();
+
+                spawn(Box::new(lazy(move || {
+                    cnt.set(1 + cnt.get());
+                    Ok(())
+                })));
+
+                Ok::<_, ()>(())
+            }))
+            .unwrap();
+
+        tokio_current_thread.run().unwrap();
+
+        assert_eq!(1, cnt.get());
+    }
+
+    #[test]
+    fn spawn() {
+        test(tokio_current_thread::spawn);
+    }
+
+    #[test]
+    fn execute() {
+        test(|f| {
+            tokio_current_thread::TaskExecutor::current()
+                .execute(f)
+                .unwrap();
+        });
+    }
+}
+
+struct Never(Rc<()>);
+
+impl Future for Never {
+    type Item = ();
+    type Error = ();
+
+    fn poll(&mut self) -> Poll<(), ()> {
+        Ok(Async::NotReady)
+    }
+}
+
+mod outstanding_tasks_are_dropped_when_executor_is_dropped {
+    use super::*;
+
+    fn test<F, G>(spawn: F, dotspawn: G)
+    where
+        F: Fn(Box<dyn Future<Item = (), Error = ()>>) + 'static,
+        G: Fn(&mut CurrentThread, Box<dyn Future<Item = (), Error = ()>>),
+    {
+        let mut rc = Rc::new(());
+
+        let mut tokio_current_thread = CurrentThread::new();
+        dotspawn(&mut tokio_current_thread, Box::new(Never(rc.clone())));
+
+        drop(tokio_current_thread);
+
+        // Ensure the daemon is dropped
+        assert!(Rc::get_mut(&mut rc).is_some());
+
+        // Using the global spawn fn
+
+        let mut rc = Rc::new(());
+
+        let mut tokio_current_thread = CurrentThread::new();
+
+        tokio_current_thread
+            .block_on(lazy(|| {
+                spawn(Box::new(Never(rc.clone())));
+                Ok::<_, ()>(())
+            }))
+            .unwrap();
+
+        drop(tokio_current_thread);
+
+        // Ensure the daemon is dropped
+        assert!(Rc::get_mut(&mut rc).is_some());
+    }
+
+    #[test]
+    fn spawn() {
+        test(tokio_current_thread::spawn, |rt, f| {
+            rt.spawn(f);
+        })
+    }
+
+    #[test]
+    fn execute() {
+        test(
+            |f| {
+                tokio_current_thread::TaskExecutor::current()
+                    .execute(f)
+                    .unwrap();
+            },
+            // Note: `CurrentThread` doesn't currently implement
+            // `futures::Executor`, so we'll call `.spawn(...)` rather than
+            // `.execute(...)` for now. If `CurrentThread` is changed to
+            // implement Executor, change this to `.execute(...).unwrap()`.
+            |rt, f| {
+                rt.spawn(f);
+            },
+        );
+    }
+}
+
+#[test]
+#[should_panic]
+fn nesting_run() {
+    block_on_all(lazy(|| {
+        block_on_all(lazy(|| ok())).unwrap();
+
+        ok()
+    }))
+    .unwrap();
+}
+
+mod run_in_future {
+    use super::*;
+
+    #[test]
+    #[should_panic]
+    fn spawn() {
+        block_on_all(lazy(|| {
+            tokio_current_thread::spawn(lazy(|| {
+                block_on_all(lazy(|| ok())).unwrap();
+                ok()
+            }));
+            ok()
+        }))
+        .unwrap();
+    }
+
+    #[test]
+    #[should_panic]
+    fn execute() {
+        block_on_all(lazy(|| {
+            tokio_current_thread::TaskExecutor::current()
+                .execute(lazy(|| {
+                    block_on_all(lazy(|| ok())).unwrap();
+                    ok()
+                }))
+                .unwrap();
+            ok()
+        }))
+        .unwrap();
+    }
+}
+
+#[test]
+fn tick_on_infini_future() {
+    let num = Rc::new(Cell::new(0));
+
+    struct Infini {
+        num: Rc<Cell<usize>>,
+    }
+
+    impl Future for Infini {
+        type Item = ();
+        type Error = ();
+
+        fn poll(&mut self) -> Poll<(), ()> {
+            self.num.set(1 + self.num.get());
+            task::current().notify();
+            Ok(Async::NotReady)
+        }
+    }
+
+    CurrentThread::new()
+        .spawn(Infini { num: num.clone() })
+        .turn(None)
+        .unwrap();
+
+    assert_eq!(1, num.get());
+}
+
+mod tasks_are_scheduled_fairly {
+    use super::*;
+    struct Spin {
+        state: Rc<RefCell<[i32; 2]>>,
+        idx: usize,
+    }
+
+    impl Future for Spin {
+        type Item = ();
+        type Error = ();
+
+        fn poll(&mut self) -> Poll<(), ()> {
+            let mut state = self.state.borrow_mut();
+
+            if self.idx == 0 {
+                let diff = state[0] - state[1];
+
+                assert!(diff.abs() <= 1);
+
+                if state[0] >= 50 {
+                    return Ok(().into());
+                }
+            }
+
+            state[self.idx] += 1;
+
+            if state[self.idx] >= 100 {
+                return Ok(().into());
+            }
+
+            task::current().notify();
+            Ok(Async::NotReady)
+        }
+    }
+
+    fn test<F: Fn(Spin)>(spawn: F) {
+        let state = Rc::new(RefCell::new([0, 0]));
+
+        block_on_all(lazy(|| {
+            spawn(Spin {
+                state: state.clone(),
+                idx: 0,
+            });
+
+            spawn(Spin {
+                state: state,
+                idx: 1,
+            });
+
+            ok()
+        }))
+        .unwrap();
+    }
+
+    #[test]
+    fn spawn() {
+        test(tokio_current_thread::spawn)
+    }
+
+    #[test]
+    fn execute() {
+        test(|f| {
+            tokio_current_thread::TaskExecutor::current()
+                .execute(f)
+                .unwrap();
+        })
+    }
+}
+
+mod and_turn {
+    use super::*;
+
+    fn test<F, G>(spawn: F, dotspawn: G)
+    where
+        F: Fn(Box<dyn Future<Item = (), Error = ()>>) + 'static,
+        G: Fn(&mut CurrentThread, Box<dyn Future<Item = (), Error = ()>>),
+    {
+        let cnt = Rc::new(Cell::new(0));
+        let c = cnt.clone();
+
+        let mut tokio_current_thread = CurrentThread::new();
+
+        // Spawn a basic task to get the executor to turn
+        dotspawn(&mut tokio_current_thread, Box::new(lazy(move || Ok(()))));
+
+        // Turn once...
+        tokio_current_thread.turn(None).unwrap();
+
+        dotspawn(
+            &mut tokio_current_thread,
+            Box::new(lazy(move || {
+                c.set(1 + c.get());
+
+                // Spawn!
+                spawn(Box::new(lazy(move || {
+                    c.set(1 + c.get());
+                    Ok::<(), ()>(())
+                })));
+
+                Ok(())
+            })),
+        );
+
+        // This does not run the newly spawned thread
+        tokio_current_thread.turn(None).unwrap();
+        assert_eq!(1, cnt.get());
+
+        // This runs the newly spawned thread
+        tokio_current_thread.turn(None).unwrap();
+        assert_eq!(2, cnt.get());
+    }
+
+    #[test]
+    fn spawn() {
+        test(tokio_current_thread::spawn, |rt, f| {
+            rt.spawn(f);
+        })
+    }
+
+    #[test]
+    fn execute() {
+        test(
+            |f| {
+                tokio_current_thread::TaskExecutor::current()
+                    .execute(f)
+                    .unwrap();
+            },
+            // Note: `CurrentThread` doesn't currently implement
+            // `futures::Executor`, so we'll call `.spawn(...)` rather than
+            // `.execute(...)` for now. If `CurrentThread` is changed to
+            // implement Executor, change this to `.execute(...).unwrap()`.
+            |rt, f| {
+                rt.spawn(f);
+            },
+        );
+    }
+}
+
+mod in_drop {
+    use super::*;
+    struct OnDrop<F: FnOnce()>(Option<F>);
+
+    impl<F: FnOnce()> Drop for OnDrop<F> {
+        fn drop(&mut self) {
+            (self.0.take().unwrap())();
+        }
+    }
+
+    struct MyFuture {
+        _data: Box<dyn Any>,
+    }
+
+    impl Future for MyFuture {
+        type Item = ();
+        type Error = ();
+
+        fn poll(&mut self) -> Poll<(), ()> {
+            Ok(().into())
+        }
+    }
+
+    fn test<F, G>(spawn: F, dotspawn: G)
+    where
+        F: Fn(Box<dyn Future<Item = (), Error = ()>>) + 'static,
+        G: Fn(&mut CurrentThread, Box<dyn Future<Item = (), Error = ()>>),
+    {
+        let mut tokio_current_thread = CurrentThread::new();
+
+        let (tx, rx) = oneshot::channel();
+
+        dotspawn(
+            &mut tokio_current_thread,
+            Box::new(MyFuture {
+                _data: Box::new(OnDrop(Some(move || {
+                    spawn(Box::new(lazy(move || {
+                        tx.send(()).unwrap();
+                        Ok(())
+                    })));
+                }))),
+            }),
+        );
+
+        tokio_current_thread.block_on(rx).unwrap();
+        tokio_current_thread.run().unwrap();
+    }
+
+    #[test]
+    fn spawn() {
+        test(tokio_current_thread::spawn, |rt, f| {
+            rt.spawn(f);
+        })
+    }
+
+    #[test]
+    fn execute() {
+        test(
+            |f| {
+                tokio_current_thread::TaskExecutor::current()
+                    .execute(f)
+                    .unwrap();
+            },
+            // Note: `CurrentThread` doesn't currently implement
+            // `futures::Executor`, so we'll call `.spawn(...)` rather than
+            // `.execute(...)` for now. If `CurrentThread` is changed to
+            // implement Executor, change this to `.execute(...).unwrap()`.
+            |rt, f| {
+                rt.spawn(f);
+            },
+        );
+    }
+}
+
+#[test]
+fn hammer_turn() {
+    use futures::sync::mpsc;
+
+    const ITER: usize = 100;
+    const N: usize = 100;
+    const THREADS: usize = 4;
+
+    for _ in 0..ITER {
+        let mut ths = vec![];
+
+        // Add some jitter
+        for _ in 0..THREADS {
+            let th = thread::spawn(|| {
+                let mut tokio_current_thread = CurrentThread::new();
+
+                let (tx, rx) = mpsc::unbounded();
+
+                tokio_current_thread.spawn({
+                    let cnt = Rc::new(Cell::new(0));
+                    let c = cnt.clone();
+
+                    rx.for_each(move |_| {
+                        c.set(1 + c.get());
+                        Ok(())
+                    })
+                    .map_err(|e| panic!("err={:?}", e))
+                    .map(move |v| {
+                        assert_eq!(N, cnt.get());
+                        v
+                    })
+                });
+
+                thread::spawn(move || {
+                    for _ in 0..N {
+                        tx.unbounded_send(()).unwrap();
+                        thread::yield_now();
+                    }
+                });
+
+                while !tokio_current_thread.is_idle() {
+                    tokio_current_thread.turn(None).unwrap();
+                }
+            });
+
+            ths.push(th);
+        }
+
+        for th in ths {
+            th.join().unwrap();
+        }
+    }
+}
+
+#[test]
+fn turn_has_polled() {
+    let mut tokio_current_thread = CurrentThread::new();
+
+    // Spawn oneshot receiver
+    let (sender, receiver) = oneshot::channel::<()>();
+    tokio_current_thread.spawn(receiver.then(|_| Ok(())));
+
+    // Turn once...
+    let res = tokio_current_thread
+        .turn(Some(Duration::from_millis(0)))
+        .unwrap();
+
+    // Should've polled the receiver once, but considered it not ready
+    assert!(res.has_polled());
+
+    // Turn another time
+    let res = tokio_current_thread
+        .turn(Some(Duration::from_millis(0)))
+        .unwrap();
+
+    // Should've polled nothing, the receiver is not ready yet
+    assert!(!res.has_polled());
+
+    // Make the receiver ready
+    sender.send(()).unwrap();
+
+    // Turn another time
+    let res = tokio_current_thread
+        .turn(Some(Duration::from_millis(0)))
+        .unwrap();
+
+    // Should've polled the receiver, it's ready now
+    assert!(res.has_polled());
+
+    // Now the executor should be empty
+    assert!(tokio_current_thread.is_idle());
+    let res = tokio_current_thread
+        .turn(Some(Duration::from_millis(0)))
+        .unwrap();
+
+    // So should've polled nothing
+    assert!(!res.has_polled());
+}
+
+// Our own mock Park that is never really waiting and the only
+// thing it does is to send, on request, something (once) to a oneshot
+// channel
+struct MyPark {
+    sender: Option<oneshot::Sender<()>>,
+    send_now: Rc<Cell<bool>>,
+}
+
+struct MyUnpark;
+
+impl tokio_executor::park::Park for MyPark {
+    type Unpark = MyUnpark;
+    type Error = ();
+
+    fn unpark(&self) -> Self::Unpark {
+        MyUnpark
+    }
+
+    fn park(&mut self) -> Result<(), Self::Error> {
+        // If called twice with send_now, this will intentionally panic
+        if self.send_now.get() {
+            self.sender.take().unwrap().send(()).unwrap();
+        }
+
+        Ok(())
+    }
+
+    fn park_timeout(&mut self, _duration: Duration) -> Result<(), Self::Error> {
+        self.park()
+    }
+}
+
+impl tokio_executor::park::Unpark for MyUnpark {
+    fn unpark(&self) {}
+}
+
+#[test]
+fn turn_fair() {
+    let send_now = Rc::new(Cell::new(false));
+
+    let (sender, receiver) = oneshot::channel::<()>();
+    let (sender_2, receiver_2) = oneshot::channel::<()>();
+    let (sender_3, receiver_3) = oneshot::channel::<()>();
+
+    let my_park = MyPark {
+        sender: Some(sender_3),
+        send_now: send_now.clone(),
+    };
+
+    let mut tokio_current_thread = CurrentThread::new_with_park(my_park);
+
+    let receiver_1_done = Rc::new(Cell::new(false));
+    let receiver_1_done_clone = receiver_1_done.clone();
+
+    // Once an item is received on the oneshot channel, it will immediately
+    // immediately make the second oneshot channel ready
+    tokio_current_thread.spawn(receiver.map_err(|_| unreachable!()).and_then(move |_| {
+        sender_2.send(()).unwrap();
+        receiver_1_done_clone.set(true);
+
+        Ok(())
+    }));
+
+    let receiver_2_done = Rc::new(Cell::new(false));
+    let receiver_2_done_clone = receiver_2_done.clone();
+
+    tokio_current_thread.spawn(receiver_2.map_err(|_| unreachable!()).and_then(move |_| {
+        receiver_2_done_clone.set(true);
+        Ok(())
+    }));
+
+    // The third receiver is only woken up from our Park implementation, it simulates
+    // e.g. a socket that first has to be polled to know if it is ready now
+    let receiver_3_done = Rc::new(Cell::new(false));
+    let receiver_3_done_clone = receiver_3_done.clone();
+
+    tokio_current_thread.spawn(receiver_3.map_err(|_| unreachable!()).and_then(move |_| {
+        receiver_3_done_clone.set(true);
+        Ok(())
+    }));
+
+    // First turn should've polled both and considered them not ready
+    let res = tokio_current_thread
+        .turn(Some(Duration::from_millis(0)))
+        .unwrap();
+    assert!(res.has_polled());
+
+    // Next turn should've polled nothing
+    let res = tokio_current_thread
+        .turn(Some(Duration::from_millis(0)))
+        .unwrap();
+    assert!(!res.has_polled());
+
+    assert!(!receiver_1_done.get());
+    assert!(!receiver_2_done.get());
+    assert!(!receiver_3_done.get());
+
+    // After this the receiver future will wake up the second receiver future,
+    // so there are pending futures again
+    sender.send(()).unwrap();
+
+    // Now the first receiver should be done, the second receiver should be ready
+    // to be polled again and the socket not yet
+    let res = tokio_current_thread.turn(None).unwrap();
+    assert!(res.has_polled());
+
+    assert!(receiver_1_done.get());
+    assert!(!receiver_2_done.get());
+    assert!(!receiver_3_done.get());
+
+    // Now let our park implementation know that it should send something to sender 3
+    send_now.set(true);
+
+    // This should resolve the second receiver directly, but also poll the socket
+    // and read the packet from it. If it didn't do both here, we would handle
+    // futures that are woken up from the reactor and directly unfairly and would
+    // favour the ones that are woken up directly.
+    let res = tokio_current_thread.turn(None).unwrap();
+    assert!(res.has_polled());
+
+    assert!(receiver_1_done.get());
+    assert!(receiver_2_done.get());
+    assert!(receiver_3_done.get());
+
+    // Don't send again
+    send_now.set(false);
+
+    // Now we should be idle and turning should not poll anything
+    assert!(tokio_current_thread.is_idle());
+    let res = tokio_current_thread.turn(None).unwrap();
+    assert!(!res.has_polled());
+}
+
+#[test]
+fn spawn_from_other_thread() {
+    let mut current_thread = CurrentThread::new();
+
+    let handle = current_thread.handle();
+    let (sender, receiver) = oneshot::channel::<()>();
+
+    thread::spawn(move || {
+        handle
+            .spawn(lazy(move || {
+                sender.send(()).unwrap();
+                Ok(())
+            }))
+            .unwrap();
+    });
+
+    let _ = current_thread.block_on(receiver).unwrap();
+}
+
+#[test]
+fn spawn_from_other_thread_unpark() {
+    use std::sync::mpsc::channel as mpsc_channel;
+
+    let mut current_thread = CurrentThread::new();
+
+    let handle = current_thread.handle();
+    let (sender_1, receiver_1) = oneshot::channel::<()>();
+    let (sender_2, receiver_2) = mpsc_channel::<()>();
+
+    thread::spawn(move || {
+        let _ = receiver_2.recv().unwrap();
+
+        handle
+            .spawn(lazy(move || {
+                sender_1.send(()).unwrap();
+                Ok(())
+            }))
+            .unwrap();
+    });
+
+    // Ensure that unparking the executor works correctly. It will first
+    // check if there are new futures (there are none), then execute the
+    // lazy future below which will cause the future to be spawned from
+    // the other thread. Then the executor will park but should be woken
+    // up because *now* we have a new future to schedule
+    let _ = current_thread
+        .block_on(
+            lazy(move || {
+                sender_2.send(()).unwrap();
+                Ok(())
+            })
+            .and_then(|_| receiver_1),
+        )
+        .unwrap();
+}
+
+#[test]
+fn spawn_from_executor_with_handle() {
+    let mut current_thread = CurrentThread::new();
+    let handle = current_thread.handle();
+    let (tx, rx) = oneshot::channel();
+
+    current_thread.spawn(lazy(move || {
+        handle
+            .spawn(lazy(move || {
+                tx.send(()).unwrap();
+                Ok(())
+            }))
+            .unwrap();
+        Ok::<_, ()>(())
+    }));
+
+    current_thread.run();
+
+    rx.wait().unwrap();
+}
+
+fn ok() -> future::FutureResult<(), ()> {
+    future::ok(())
+}

tokio-executor/CHANGELOG.md

@@ -1,3 +1,39 @@
+# 0.1.8 (June 2, 2019)
+
+### Added
+- Add `executor::exit` to allow other executors inside `threadpool::blocking` (#1155).
+
+# 0.1.7 (March 22, 2019)
+
+### Added
+- `TypedExecutor` for spawning futures of a specific type (#993).
+
+# 0.1.6 (January 6, 2019)
+
+* Implement `Unpark` for `Arc<Unpark>` (#802).
+* Switch to crossbeam's Parker / Unparker (#528).
+
+# 0.1.5 (September 26, 2018)
+
+* Implement `futures::Executor` for `DefaultExecutor` (#563).
+* Add `Enter::block_on(future)` (#646)
+
+# 0.1.4 (August 23, 2018)
+
+* Implement `std::error::Error` for error types (#511).
+
+# 0.1.3 (August 6, 2018)
+
+* Implement `Executor` for `Box<E: Executor>` (#420).
+* Improve `EnterError` debug message (#410).
+* Implement `status`, `Send`, and `Sync` for `DefaultExecutor` (#463, #472).
+* Fix race in `ParkThread` (#507).
+* Handle recursive calls into `DefaultExecutor` (#473).
+
+# 0.1.2 (March 30, 2018)
+
+* Implement `Unpark` for `Box<Unpark>`.
+
 # 0.1.1 (March 22, 2018)
 
 * Optionally support futures 0.2.

tokio-executor/Cargo.toml

@@ -1,12 +1,15 @@
 [package]
 name = "tokio-executor"
-
 # When releasing to crates.io:
+# - Remove path dependencies
 # - Update html_root_url.
+# - Update doc url
+#   - Cargo.toml
+#   - README.md
 # - Update CHANGELOG.md.
 # - Create "v0.1.x" git tag.
-version = "0.1.1"
-documentation = "https://docs.rs/tokio-executor"
+version = "0.1.8"
+documentation = "https://docs.rs/tokio-executor/0.1.7/tokio_executor"
 repository = "https://github.com/tokio-rs/tokio"
 homepage = "https://github.com/tokio-rs/tokio"
 license = "MIT"
@@ -18,11 +21,8 @@ keywords = ["futures", "tokio"]
 categories = ["concurrency", "asynchronous"]
 
 [dependencies]
+crossbeam-utils = "0.6.2"
 futures = "0.1.19"
 
-# Futures 0.2 integration
-futures2 = { version = "0.1.0", path = "../futures2", optional = true }
-
-[features]
-unstable-futures = ["futures2"]
-default = []
+[dev-dependencies]
+tokio = "0.1.18"

tokio-executor/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2018 Tokio Contributors
+Copyright (c) 2019 Tokio Contributors
 
 Permission is hereby granted, free of charge, to any
 person obtaining a copy of this software and associated

tokio-executor/README.md

@@ -2,7 +2,7 @@
 
 Task execution related traits and utilities.
 
-[Documentation](https://tokio-rs.github.io/tokio/tokio_executor/)
+[Documentation](https://docs.rs/tokio-executor/0.1.8/tokio_executor)
 
 ## Overview
 
@@ -22,7 +22,7 @@ executor, including:
 * The [`Executor`] trait describes the API for spawning a future onto an
   executor.
 
-* [`enter`] marks that the the current thread is entering an execution
+* [`enter`] marks that the current thread is entering an execution
   context. This prevents a second executor from accidentally starting from
   within the context of one that is already running.
 
@@ -31,10 +31,10 @@ executor, including:
 
 * [`Park`] abstracts over blocking and unblocking the current thread.
 
-[`Executor`]: https://tokio-rs.github.io/tokio/tokio_executor/trait.Executor.html
-[`enter`]: https://tokio-rs.github.io/tokio/tokio_executor/fn.enter.html
-[`DefaultExecutor`]: https://tokio-rs.github.io/tokio/tokio_executor/struct.DefaultExecutor.html
-[`Park`]: https://tokio-rs.github.io/tokio/tokio_executor/park/index.html
+[`Executor`]: https://docs.rs/tokio-executor/0.1.8/tokio_executor/trait.Executor.html
+[`enter`]: https://docs.rs/tokio-executor/0.1.8/tokio_executor/fn.enter.html
+[`DefaultExecutor`]: https://docs.rs/tokio-executor/0.1.8/tokio_executor/struct.DefaultExecutor.html
+[`Park`]: https://docs.rs/tokio-executor/0.1.8/tokio_executor/park/trait.Park.html
 
 ## License
 

tokio-executor/src/enter.rs

@@ -1,9 +1,9 @@
-use std::prelude::v1::*;
 use std::cell::Cell;
+use std::error::Error;
 use std::fmt;
+use std::prelude::v1::*;
 
-#[cfg(feature = "unstable-futures")]
-use futures2;
+use futures::{self, Future};
 
 thread_local!(static ENTERED: Cell<bool> = Cell::new(false));
 
@@ -11,20 +11,36 @@ thread_local!(static ENTERED: Cell<bool> = Cell::new(false));
 ///
 /// For more details, see [`enter` documentation](fn.enter.html)
 pub struct Enter {
-    on_exit: Vec<Box<Callback>>,
+    on_exit: Vec<Box<dyn Callback>>,
     permanent: bool,
-
-    #[cfg(feature = "unstable-futures")]
-    _enter2: futures2::executor::Enter,
 }
 
 /// An error returned by `enter` if an execution scope has already been
 /// entered.
-#[derive(Debug)]
 pub struct EnterError {
     _a: (),
 }
 
+impl fmt::Debug for EnterError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("EnterError")
+            .field("reason", &self.description())
+            .finish()
+    }
+}
+
+impl fmt::Display for EnterError {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmt, "{}", self.description())
+    }
+}
+
+impl Error for EnterError {
+    fn description(&self) -> &str {
+        "attempted to run an executor while another executor is already running"
+    }
+}
+
 /// Marks the current thread as being within the dynamic extent of an
 /// executor.
 ///
@@ -46,18 +62,54 @@ pub fn enter() -> Result<Enter, EnterError> {
             Ok(Enter {
                 on_exit: Vec::new(),
                 permanent: false,
-
-                #[cfg(feature = "unstable-futures")]
-                _enter2: futures2::executor::enter().unwrap(),
             })
         }
     })
 }
 
+// Forces the current "entered" state to be cleared while the closure
+// is executed.
+//
+// # Warning
+//
+// This is hidden for a reason. Do not use without fully understanding
+// executors. Misuing can easily cause your program to deadlock.
+#[doc(hidden)]
+pub fn exit<F: FnOnce() -> R, R>(f: F) -> R {
+    // Reset in case the closure panics
+    struct Reset;
+    impl Drop for Reset {
+        fn drop(&mut self) {
+            ENTERED.with(|c| {
+                c.set(true);
+            });
+        }
+    }
+
+    ENTERED.with(|c| {
+        debug_assert!(c.get());
+        c.set(false);
+    });
+
+    let reset = Reset;
+    let ret = f();
+    ::std::mem::forget(reset);
+
+    ENTERED.with(|c| {
+        assert!(!c.get(), "closure claimed permanent executor");
+        c.set(true);
+    });
+
+    ret
+}
+
 impl Enter {
     /// Register a callback to be invoked if and when the thread
     /// ceased to act as an executor.
-    pub fn on_exit<F>(&mut self, f: F) where F: FnOnce() + 'static {
+    pub fn on_exit<F>(&mut self, f: F)
+    where
+        F: FnOnce() + 'static,
+    {
         self.on_exit.push(Box::new(f));
     }
 
@@ -69,6 +121,12 @@ impl Enter {
     pub fn make_permanent(mut self) {
         self.permanent = true;
     }
+
+    /// Blocks the thread on the specified future, returning the value with
+    /// which that future completes.
+    pub fn block_on<F: Future>(&mut self, f: F) -> Result<F::Item, F::Error> {
+        futures::executor::spawn(f).wait_future()
+    }
 }
 
 impl fmt::Debug for Enter {
@@ -83,7 +141,7 @@ impl Drop for Enter {
             assert!(c.get());
 
             if self.permanent {
-                return
+                return;
             }
 
             for callback in self.on_exit.drain(..) {

tokio-executor/src/error.rs

@@ -0,0 +1,50 @@
+use std::error::Error;
+use std::fmt;
+
+/// Errors returned by `Executor::spawn`.
+///
+/// Spawn errors should represent relatively rare scenarios. Currently, the two
+/// scenarios represented by `SpawnError` are:
+///
+/// * An executor being at capacity or full. As such, the executor is not able
+///   to accept a new future. This error state is expected to be transient.
+/// * An executor has been shutdown and can no longer accept new futures. This
+///   error state is expected to be permanent.
+#[derive(Debug)]
+pub struct SpawnError {
+    is_shutdown: bool,
+}
+
+impl SpawnError {
+    /// Return a new `SpawnError` reflecting a shutdown executor failure.
+    pub fn shutdown() -> Self {
+        SpawnError { is_shutdown: true }
+    }
+
+    /// Return a new `SpawnError` reflecting an executor at capacity failure.
+    pub fn at_capacity() -> Self {
+        SpawnError { is_shutdown: false }
+    }
+
+    /// Returns `true` if the error reflects a shutdown executor failure.
+    pub fn is_shutdown(&self) -> bool {
+        self.is_shutdown
+    }
+
+    /// Returns `true` if the error reflects an executor at capacity failure.
+    pub fn is_at_capacity(&self) -> bool {
+        !self.is_shutdown
+    }
+}
+
+impl fmt::Display for SpawnError {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmt, "{}", self.description())
+    }
+}
+
+impl Error for SpawnError {
+    fn description(&self) -> &str {
+        "attempted to spawn task while the executor is at capacity or shut down"
+    }
+}

tokio-executor/src/executor.rs

@@ -0,0 +1,151 @@
+use futures::Future;
+use SpawnError;
+
+/// A value that executes futures.
+///
+/// The [`spawn`] function is used to submit a future to an executor. Once
+/// submitted, the executor takes ownership of the future and becomes
+/// responsible for driving the future to completion.
+///
+/// The strategy employed by the executor to handle the future is less defined
+/// and is left up to the `Executor` implementation. The `Executor` instance is
+/// expected to call [`poll`] on the future once it has been notified, however
+/// the "when" and "how" can vary greatly.
+///
+/// For example, the executor might be a thread pool, in which case a set of
+/// threads have already been spawned up and the future is inserted into a
+/// queue. A thread will acquire the future and poll it.
+///
+/// The `Executor` trait is only for futures that **are** `Send`. These are most
+/// common. There currently is no trait that describes executors that operate
+/// entirely on the current thread (i.e., are able to spawn futures that are not
+/// `Send`). Note that single threaded executors can still implement `Executor`,
+/// but only futures that are `Send` can be spawned via the trait.
+///
+/// This trait is primarily intended to implemented by executors and used to
+/// back `tokio::spawn`. Libraries and applications **may** use this trait to
+/// bound generics, but doing so will limit usage to futures that implement
+/// `Send`. Instead, libraries and applications are recommended to use
+/// [`TypedExecutor`] as a bound.
+///
+/// # Errors
+///
+/// The [`spawn`] function returns `Result` with an error type of `SpawnError`.
+/// This error type represents the reason that the executor was unable to spawn
+/// the future. The two current represented scenarios are:
+///
+/// * An executor being at capacity or full. As such, the executor is not able
+///   to accept a new future. This error state is expected to be transient.
+/// * An executor has been shutdown and can no longer accept new futures. This
+///   error state is expected to be permanent.
+///
+/// If a caller encounters an at capacity error, the caller should try to shed
+/// load. This can be as simple as dropping the future that was spawned.
+///
+/// If the caller encounters a shutdown error, the caller should attempt to
+/// gracefully shutdown.
+///
+/// # Examples
+///
+/// ```rust
+/// # extern crate futures;
+/// # extern crate tokio_executor;
+/// # use tokio_executor::Executor;
+/// # fn docs(my_executor: &mut Executor) {
+/// use futures::future::lazy;
+/// my_executor.spawn(Box::new(lazy(|| {
+///     println!("running on the executor");
+///     Ok(())
+/// }))).unwrap();
+/// # }
+/// # fn main() {}
+/// ```
+///
+/// [`spawn`]: #tymethod.spawn
+/// [`poll`]: https://docs.rs/futures/0.1/futures/future/trait.Future.html#tymethod.poll
+/// [`TypedExecutor`]: ../trait.TypedExecutor.html
+pub trait Executor {
+    /// Spawns a future object to run on this executor.
+    ///
+    /// `future` is passed to the executor, which will begin running it. The
+    /// future may run on the current thread or another thread at the discretion
+    /// of the `Executor` implementation.
+    ///
+    /// # Panics
+    ///
+    /// Implementations are encouraged to avoid panics. However, panics are
+    /// permitted and the caller should check the implementation specific
+    /// documentation for more details on possible panics.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # extern crate futures;
+    /// # extern crate tokio_executor;
+    /// # use tokio_executor::Executor;
+    /// # fn docs(my_executor: &mut Executor) {
+    /// use futures::future::lazy;
+    /// my_executor.spawn(Box::new(lazy(|| {
+    ///     println!("running on the executor");
+    ///     Ok(())
+    /// }))).unwrap();
+    /// # }
+    /// # fn main() {}
+    /// ```
+    fn spawn(
+        &mut self,
+        future: Box<dyn Future<Item = (), Error = ()> + Send>,
+    ) -> Result<(), SpawnError>;
+
+    /// Provides a best effort **hint** to whether or not `spawn` will succeed.
+    ///
+    /// This function may return both false positives **and** false negatives.
+    /// If `status` returns `Ok`, then a call to `spawn` will *probably*
+    /// succeed, but may fail. If `status` returns `Err`, a call to `spawn` will
+    /// *probably* fail, but may succeed.
+    ///
+    /// This allows a caller to avoid creating the task if the call to `spawn`
+    /// has a high likelihood of failing.
+    ///
+    /// # Panics
+    ///
+    /// This function must not panic. Implementers must ensure that panics do
+    /// not happen.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # extern crate futures;
+    /// # extern crate tokio_executor;
+    /// # use tokio_executor::Executor;
+    /// # fn docs(my_executor: &mut Executor) {
+    /// use futures::future::lazy;
+    ///
+    /// if my_executor.status().is_ok() {
+    ///     my_executor.spawn(Box::new(lazy(|| {
+    ///         println!("running on the executor");
+    ///         Ok(())
+    ///     }))).unwrap();
+    /// } else {
+    ///     println!("the executor is not in a good state");
+    /// }
+    /// # }
+    /// # fn main() {}
+    /// ```
+    fn status(&self) -> Result<(), SpawnError> {
+        Ok(())
+    }
+}
+
+impl<E: Executor + ?Sized> Executor for Box<E> {
+    fn spawn(
+        &mut self,
+        future: Box<dyn Future<Item = (), Error = ()> + Send>,
+    ) -> Result<(), SpawnError> {
+        (**self).spawn(future)
+    }
+
+    fn status(&self) -> Result<(), SpawnError> {
+        (**self).status()
+    }
+}

tokio-executor/src/global.rs

@@ -1,13 +1,8 @@
-use super::{Executor, Enter, SpawnError};
+use super::{Enter, Executor, SpawnError};
 
-use futures::Future;
+use futures::{future, Future};
 
 use std::cell::Cell;
-use std::marker::PhantomData;
-use std::rc::Rc;
-
-#[cfg(feature = "unstable-futures")]
-use futures2;
 
 /// Executes futures on the default executor for the current execution context.
 ///
@@ -21,8 +16,7 @@ use futures2;
 /// variable and is set using `tokio_executor::with_default`
 #[derive(Debug, Clone)]
 pub struct DefaultExecutor {
-    // Prevent the handle from moving across threads.
-    _p: PhantomData<Rc<()>>,
+    _dummy: (),
 }
 
 impl DefaultExecutor {
@@ -34,50 +28,92 @@ impl DefaultExecutor {
     /// the default **at the time `spawn` is called**. This enables
     /// `DefaultExecutor::current()` to be called before an execution context is
     /// setup, then passed **into** an execution context before it is used.
+    ///
+    /// This is also true for sending the handle across threads, so calling
+    /// `DefaultExecutor::current()` on thread A and then sending the result to
+    /// thread B will _not_ reference the default executor that was set on thread A.
     pub fn current() -> DefaultExecutor {
-        DefaultExecutor {
-            _p: PhantomData,
-        }
+        DefaultExecutor { _dummy: () }
+    }
+
+    #[inline]
+    fn with_current<F: FnOnce(&mut dyn Executor) -> R, R>(f: F) -> Option<R> {
+        EXECUTOR.with(
+            |current_executor| match current_executor.replace(State::Active) {
+                State::Ready(executor_ptr) => {
+                    let executor = unsafe { &mut *executor_ptr };
+                    let result = f(executor);
+                    current_executor.set(State::Ready(executor_ptr));
+                    Some(result)
+                }
+                State::Empty | State::Active => None,
+            },
+        )
     }
 }
 
-/// Thread-local tracking the current executor
-thread_local!(static EXECUTOR: Cell<Option<*mut Executor>> = Cell::new(None));
+#[derive(Clone, Copy)]
+enum State {
+    // default executor not defined
+    Empty,
+    // default executor is defined and ready to be used
+    Ready(*mut dyn Executor),
+    // default executor is currently active (used to detect recursive calls)
+    Active,
+}
+
+thread_local! {
+    /// Thread-local tracking the current executor
+    static EXECUTOR: Cell<State> = Cell::new(State::Empty)
+}
 
 // ===== impl DefaultExecutor =====
 
 impl super::Executor for DefaultExecutor {
-    fn spawn(&mut self, future: Box<Future<Item = (), Error = ()> + Send>)
-        -> Result<(), SpawnError>
-    {
-        EXECUTOR.with(|current_executor| {
-            match current_executor.get() {
-                Some(executor) => {
-                    let executor = unsafe { &mut *executor };
-                    executor.spawn(future)
-                }
-                None => {
-                    Err(SpawnError::shutdown())
-                }
-            }
-        })
+    fn spawn(
+        &mut self,
+        future: Box<dyn Future<Item = (), Error = ()> + Send>,
+    ) -> Result<(), SpawnError> {
+        DefaultExecutor::with_current(|executor| executor.spawn(future))
+            .unwrap_or_else(|| Err(SpawnError::shutdown()))
     }
 
-    #[cfg(feature = "unstable-futures")]
-    fn spawn2(&mut self, future: Box<futures2::Future<Item = (), Error = futures2::Never> + Send>)
-             -> Result<(), futures2::executor::SpawnError>
-    {
-        EXECUTOR.with(|current_executor| {
-            match current_executor.get() {
-                Some(executor) => {
-                    let executor = unsafe { &mut *executor };
-                    executor.spawn2(future)
-                }
-                None => {
-                    Err(futures2::executor::SpawnError::shutdown())
-                }
-            }
-        })
+    fn status(&self) -> Result<(), SpawnError> {
+        DefaultExecutor::with_current(|executor| executor.status())
+            .unwrap_or_else(|| Err(SpawnError::shutdown()))
+    }
+}
+
+impl<T> super::TypedExecutor<T> for DefaultExecutor
+where
+    T: Future<Item = (), Error = ()> + Send + 'static,
+{
+    fn spawn(&mut self, future: T) -> Result<(), SpawnError> {
+        super::Executor::spawn(self, Box::new(future))
+    }
+
+    fn status(&self) -> Result<(), SpawnError> {
+        super::Executor::status(self)
+    }
+}
+
+impl<T> future::Executor<T> for DefaultExecutor
+where
+    T: Future<Item = (), Error = ()> + Send + 'static,
+{
+    fn execute(&self, future: T) -> Result<(), future::ExecuteError<T>> {
+        if let Err(e) = super::Executor::status(self) {
+            let kind = if e.is_at_capacity() {
+                future::ExecuteErrorKind::NoCapacity
+            } else {
+                future::ExecuteErrorKind::Shutdown
+            };
+
+            return Err(future::ExecuteError::new(kind, future));
+        }
+
+        let _ = DefaultExecutor::with_current(|executor| executor.spawn(Box::new(future)));
+        Ok(())
     }
 }
 
@@ -123,19 +159,10 @@ impl super::Executor for DefaultExecutor {
 /// # pub fn main() {}
 /// ```
 pub fn spawn<T>(future: T)
-    where T: Future<Item = (), Error = ()> + Send + 'static,
+where
+    T: Future<Item = (), Error = ()> + Send + 'static,
 {
-    DefaultExecutor::current().spawn(Box::new(future))
-        .unwrap()
-}
-
-/// Like `spawn` but compatible with futures 0.2
-#[cfg(feature = "unstable-futures")]
-pub fn spawn2<T>(future: T)
-    where T: futures2::Future<Item = (), Error = futures2::Never> + Send + 'static,
-{
-    DefaultExecutor::current().spawn2(Box::new(future))
-        .unwrap()
+    DefaultExecutor::current().spawn(Box::new(future)).unwrap()
 }
 
 /// Set the default executor for the duration of the closure
@@ -144,19 +171,25 @@ pub fn spawn2<T>(future: T)
 ///
 /// This function panics if there already is a default executor set.
 pub fn with_default<T, F, R>(executor: &mut T, enter: &mut Enter, f: F) -> R
-where T: Executor,
-      F: FnOnce(&mut Enter) -> R
+where
+    T: Executor,
+    F: FnOnce(&mut Enter) -> R,
 {
     EXECUTOR.with(|cell| {
-        assert!(cell.get().is_none(), "default executor already set for execution context");
+        match cell.get() {
+            State::Ready(_) | State::Active => {
+                panic!("default executor already set for execution context")
+            }
+            _ => {}
+        }
 
         // Ensure that the executor is removed from the thread-local context
         // when leaving the scope. This handles cases that involve panicking.
-        struct Reset<'a>(&'a Cell<Option<*mut Executor>>);
+        struct Reset<'a>(&'a Cell<State>);
 
         impl<'a> Drop for Reset<'a> {
             fn drop(&mut self) {
-                self.0.set(None);
+                self.0.set(State::Empty);
             }
         }
 
@@ -171,13 +204,37 @@ where T: Executor,
         // cells require.
         let executor = unsafe { hide_lt(executor as &mut _ as *mut _) };
 
-        cell.set(Some(executor));
+        cell.set(State::Ready(executor));
 
         f(enter)
     })
 }
 
-unsafe fn hide_lt<'a>(p: *mut (Executor + 'a)) -> *mut (Executor + 'static) {
+unsafe fn hide_lt<'a>(p: *mut (dyn Executor + 'a)) -> *mut (dyn Executor + 'static) {
     use std::mem;
     mem::transmute(p)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::{with_default, DefaultExecutor, Executor};
+
+    #[test]
+    fn default_executor_is_send_and_sync() {
+        fn assert_send_sync<T: Send + Sync>() {}
+
+        assert_send_sync::<DefaultExecutor>();
+    }
+
+    #[test]
+    fn nested_default_executor_status() {
+        let mut enter = super::super::enter().unwrap();
+        let mut executor = DefaultExecutor::current();
+
+        let result = with_default(&mut executor, &mut enter, |_| {
+            DefaultExecutor::current().status()
+        });
+
+        assert!(result.err().unwrap().is_shutdown())
+    }
+}

tokio-executor/src/lib.rs

@@ -1,3 +1,6 @@
+#![deny(missing_docs, missing_debug_implementations)]
+#![doc(html_root_url = "https://docs.rs/tokio-executor/0.1.8")]
+
 //! Task execution related traits and utilities.
 //!
 //! In the Tokio execution model, futures are lazy. When a future is created, no
@@ -6,17 +9,22 @@
 //! an executor is called a "task".
 //!
 //! The executor is responsible for ensuring that [`Future::poll`] is called
-//! whenever the task is [notified]. Notification happens when the internal
-//! state of a task transitions from "not ready" to ready. For example, a socket
-//! might have received data and a call to `read` will now be able to succeed.
+//! whenever the task is notified. Notification happens when the internal
+//! state of a task transitions from *not ready* to *ready*. For example, a
+//! socket might have received data and a call to `read` will now be able to
+//! succeed.
 //!
 //! This crate provides traits and utilities that are necessary for building an
 //! executor, including:
 //!
-//! * The [`Executor`] trait describes the API for spawning a future onto an
-//!   executor.
+//! * The [`Executor`] trait spawns future object onto an executor.
 //!
-//! * [`enter`] marks that the the current thread is entering an execution
+//! * The [`TypedExecutor`] trait spawns futures of a specific type onto an
+//!   executor. This is used to be generic over executors that spawn futures
+//!   that are either `Send` or `!Send` or implement executors that apply to
+//!   specific futures.
+//!
+//! * [`enter`] marks that the current thread is entering an execution
 //!   context. This prevents a second executor from accidentally starting from
 //!   within the context of one that is already running.
 //!
@@ -25,195 +33,36 @@
 //!
 //! * [`Park`] abstracts over blocking and unblocking the current thread.
 //!
+//! # Implementing an executor
+//!
+//! Executors should always implement `TypedExecutor`. This usually is the bound
+//! that applications and libraries will use when generic over an executor. See
+//! the [trait documentation][`TypedExecutor`] for more details.
+//!
+//! If the executor is able to spawn all futures that are `Send`, then the
+//! executor should also implement the `Executor` trait. This trait is rarely
+//! used directly by applications and libraries. Instead, `tokio::spawn` is
+//! configured to dispatch to type that implements `Executor`.
+//!
 //! [`Executor`]: trait.Executor.html
+//! [`TypedExecutor`]: trait.TypedExecutor.html
 //! [`enter`]: fn.enter.html
 //! [`DefaultExecutor`]: struct.DefaultExecutor.html
 //! [`Park`]: park/index.html
+//! [`Future::poll`]: https://docs.rs/futures/0.1/futures/future/trait.Future.html#tymethod.poll
 
-#![deny(missing_docs, missing_debug_implementations, warnings)]
-#![doc(html_root_url = "https://docs.rs/tokio-executor/0.1.1")]
-
+extern crate crossbeam_utils;
 extern crate futures;
 
-#[cfg(feature = "unstable-futures")]
-extern crate futures2;
-
 mod enter;
+mod error;
+mod executor;
 mod global;
 pub mod park;
+mod typed;
 
-pub use enter::{enter, Enter, EnterError};
+pub use enter::{enter, exit, Enter, EnterError};
+pub use error::SpawnError;
+pub use executor::Executor;
 pub use global::{spawn, with_default, DefaultExecutor};
-
-#[cfg(feature = "unstable-futures")]
-pub use global::spawn2;
-
-use futures::Future;
-
-/// A value that executes futures.
-///
-/// The [`spawn`] function is used to submit a future to an executor. Once
-/// submitted, the executor takes ownership of the future and becomes
-/// responsible for driving the future to completion.
-///
-/// The strategy employed by the executor to handle the future is less defined
-/// and is left up to the `Executor` implementation. The `Executor` instance is
-/// expected to call [`poll`] on the future once it has been notified, however
-/// the "when" and "how" can vary greatly.
-///
-/// For example, the executor might be a thread pool, in which case a set of
-/// threads have already been spawned up and the future is inserted into a
-/// queue. A thread will acquire the future and poll it.
-///
-/// The `Executor` trait is only for futures that **are** `Send`. These are most
-/// common. There currently is no trait that describes executors that operate
-/// entirely on the current thread (i.e., are able to spawn futures that are not
-/// `Send`). Note that single threaded executors can still implement `Executor`,
-/// but only futures that are `Send` can be spawned via the trait.
-///
-/// # Errors
-///
-/// The [`spawn`] function returns `Result` with an error type of `SpawnError`.
-/// This error type represents the reason that the executor was unable to spawn
-/// the future. The two current represented scenarios are:
-///
-/// * An executor being at capacity or full. As such, the executor is not able
-///   to accept a new future. This error state is expected to be transient.
-/// * An executor has been shutdown and can no longer accept new futures. This
-///   error state is expected to be permanent.
-///
-/// If a caller encounters an at capacity error, the caller should try to shed
-/// load. This can be as simple as dropping the future that was spawned.
-///
-/// If the caller encounters a shutdown error, the caller should attempt to
-/// gracefully shutdown.
-///
-/// # Examples
-///
-/// ```rust
-/// # extern crate futures;
-/// # extern crate tokio_executor;
-/// # use tokio_executor::Executor;
-/// # fn docs(my_executor: &mut Executor) {
-/// use futures::future::lazy;
-/// my_executor.spawn(Box::new(lazy(|| {
-///     println!("running on the executor");
-///     Ok(())
-/// }))).unwrap();
-/// # }
-/// # fn main() {}
-/// ```
-///
-/// [`spawn`]: #tymethod.spawn
-/// [`poll`]: https://docs.rs/futures/0.1/futures/future/trait.Future.html#tymethod.poll
-pub trait Executor {
-    /// Spawns a future object to run on this executor.
-    ///
-    /// `future` is passed to the executor, which will begin running it. The
-    /// future may run on the current thread or another thread at the discretion
-    /// of the `Executor` implementation.
-    ///
-    /// # Panics
-    ///
-    /// Implementors are encouraged to avoid panics. However, a panic is
-    /// permitted and the caller should check the implementation specific
-    /// documentation for more details on possible panics.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # extern crate futures;
-    /// # extern crate tokio_executor;
-    /// # use tokio_executor::Executor;
-    /// # fn docs(my_executor: &mut Executor) {
-    /// use futures::future::lazy;
-    /// my_executor.spawn(Box::new(lazy(|| {
-    ///     println!("running on the executor");
-    ///     Ok(())
-    /// }))).unwrap();
-    /// # }
-    /// # fn main() {}
-    /// ```
-    fn spawn(&mut self, future: Box<Future<Item = (), Error = ()> + Send>)
-             -> Result<(), SpawnError>;
-
-    /// Like `spawn`, but compatible with futures 0.2
-    #[cfg(feature = "unstable-futures")]
-    fn spawn2(&mut self, future: Box<futures2::Future<Item = (), Error = futures2::Never> + Send>)
-             -> Result<(), futures2::executor::SpawnError>;
-
-    /// Provides a best effort **hint** to whether or not `spawn` will succeed.
-    ///
-    /// This function may return both false positives **and** false negatives.
-    /// If `status` returns `Ok`, then a call to `spawn` will *probably*
-    /// succeed, but may fail. If `status` returns `Err`, a call to `spawn` will
-    /// *probably* fail, but may succeed.
-    ///
-    /// This allows a caller to avoid creating the task if the call to `spawn`
-    /// has a high likelihood of failing.
-    ///
-    /// # Panics
-    ///
-    /// This function must not panic. Implementors must ensure that panics do
-    /// not happen.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # extern crate futures;
-    /// # extern crate tokio_executor;
-    /// # use tokio_executor::Executor;
-    /// # fn docs(my_executor: &mut Executor) {
-    /// use futures::future::lazy;
-    ///
-    /// if my_executor.status().is_ok() {
-    ///     my_executor.spawn(Box::new(lazy(|| {
-    ///         println!("running on the executor");
-    ///         Ok(())
-    ///     }))).unwrap();
-    /// } else {
-    ///     println!("the executor is not in a good state");
-    /// }
-    /// # }
-    /// # fn main() {}
-    /// ```
-    fn status(&self) -> Result<(), SpawnError> {
-        Ok(())
-    }
-}
-
-/// Errors returned by `Executor::spawn`.
-///
-/// Spawn errors should represent relatively rare scenarios. Currently, the two
-/// scenarios represented by `SpawnError` are:
-///
-/// * An executor being at capacity or full. As such, the executor is not able
-///   to accept a new future. This error state is expected to be transient.
-/// * An executor has been shutdown and can no longer accept new futures. This
-///   error state is expected to be permanent.
-#[derive(Debug)]
-pub struct SpawnError {
-    is_shutdown: bool,
-}
-
-impl SpawnError {
-    /// Return a new `SpawnError` reflecting a shutdown executor failure.
-    pub fn shutdown() -> Self {
-        SpawnError { is_shutdown: true }
-    }
-
-    /// Return a new `SpawnError` reflecting an executor at capacity failure.
-    pub fn at_capacity() -> Self {
-        SpawnError { is_shutdown: false }
-    }
-
-    /// Returns `true` if the error reflects a shutdown executor failure.
-    pub fn is_shutdown(&self) -> bool {
-        self.is_shutdown
-    }
-
-    /// Returns `true` if the error reflects an executor at capacity failure.
-    pub fn is_at_capacity(&self) -> bool {
-        !self.is_shutdown
-    }
-}
+pub use typed::TypedExecutor;