Bump to 0.1.1

Ignore errors in signal handler
Closes #3
2026-09-09 00:00:08 +02:00 · 2017-01-11 18:56:15 -08:00 · 2017-01-11 10:21:01 -08:00 · 2016-11-19 09:15:38 -08:00 · 2016-11-07 14:25:06 -08:00 · 2016-11-07 22:04:08 +00:00
486 changed files with 1134 additions and 66448 deletions
@@ -1,43 +0,0 @@
-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
-    - (cd tokio-trace/test-log-support && cargo test)
-    - (cd tokio-trace/test_static_max_level_features && cargo test)
-    - 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
@@ -1,51 +0,0 @@
-<!--
-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>
-->
@@ -1,23 +0,0 @@
-<!--
-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.
-->
@@ -0,0 +1,25 @@
+language: rust
+
+rust:
+  - stable
+  - beta
+  - nightly
+sudo: false
+before_script:
+  - pip install 'travis-cargo<0.2' --user && export PATH=$HOME/.local/bin:$PATH
+script:
+  - cargo build
+  - cargo test
+  - cargo doc --no-deps
+after_success:
+  - travis-cargo --only nightly doc-upload
+env:
+  global:
+    - secure: "SXXK7Znvm1s5WWQ94l9IP25mXA0uGIQ7ghBuumZz3nSAfxhhJQnYi5hCAbl2/cOfSbpgEtE137dgk6Nd9UDx7rIkLCSe8TWyYjzraX/vvX3xNtLh/fjsayYYRK9a6qU2HIJegZdxPgyF5h2DeBgeLks0Ue8drrFQ1s9bYZVUO0yeuZ3aLkL1FkIG6RXGItUFpb6srEYL1NLizYLxXFEG3cL+kKoFIWc2qPx3EwOqv/eii134nQsuObhWZvPqfTo7zfNP8W/6TnoiggpRH1nrZc3DI3CynTICIOJ2Ogn9gFX9LftYKuJysSwUNVN3WF5aOuLP/XjRSBLYc+PW3v0iqiGzMX3n1VpcyhcbsSNA7ZckGn1HZsWYwspAxkN3idSuVie9Mezm7IV4005juiYKEWEr6hlkv1lzd49QZkWOvLCFCMRiwOOGp4NyzilG1Q1Zs3G1wrcvstmasNpK+QUFNdOFvT2sm34rI4x2rQUvjC/OyqbAK+PjYmTHL47YKON5ymfUL3mAcwgUfBUSd4Wpx8G3VKg3gMcmQm27ah1knOGJWH6XulYTnfGfx6bLo5t2NGx+vZk0naqajD3auWnseobMDsFjhUIRrt6GlnfPqeFoJSm0unu3riAX+RDF/iqZdDfjhX4evETIw3SaTl8EQtVLwz7kJTnxSbTU4XTi+0M="
+
+notifications:
+  email:
+    on_success: never
+os:
+  - linux
+  - osx
@@ -1,387 +0,0 @@
-# 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
@@ -1,25 +1,25 @@
-[workspace]
+[package]
+name = "tokio-signal"
+version = "0.1.1"
+authors = ["Alex Crichton <[email protected]>"]
+license = "MIT/Apache-2.0"
+repository = "https://github.com/alexcrichton/tokio-signal"
+homepage = "https://github.com/alexcrichton/tokio-signal"
+documentation = "https://alexcrichton.github.io/tokio-signal"
+description = """
+An implementation of an asynchronous Unix signal handling backed futures.
+"""

-members = [
-  "tokio",
-  "tokio-buf",
-  "tokio-codec",
-  "tokio-current-thread",
-  "tokio-executor",
-  "tokio-fs",
-  "tokio-futures",
-  "tokio-io",
-  "tokio-macros",
-  "tokio-reactor",
-  "tokio-signal",
-  "tokio-sync",
-  "tokio-test",
-  "tokio-threadpool",
-  "tokio-timer",
-  "tokio-tcp",
-  "tokio-tls",
-  "tokio-trace",
-  "tokio-trace/tokio-trace-core",
-  "tokio-udp",
-  "tokio-uds",
-]
+[dependencies]
+tokio-core = "0.1"
+futures = "0.1"
+
+[target.'cfg(unix)'.dependencies]
+tokio-uds = "0.1"
+libc = "0.2"
+mio = "0.6"
+
+[target.'cfg(windows)'.dependencies]
+winapi = "0.2"
+kernel32-sys = "0.2"
+mio = "0.6"
@@ -1,25 +0,0 @@
-Copyright (c) 2019 Tokio Contributors
-
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
@@ -1,4 +1,4 @@
-Copyright (c) 2019 Tokio Contributors
+Copyright (c) 2016 Alex Crichton

 Permission is hereby granted, free of charge, to any
 person obtaining a copy of this software and associated
@@ -1,189 +1,32 @@
-# Tokio
+# tokio-signal

-A runtime for writing reliable, asynchronous, and slim applications with
-the Rust programming language. It is:
+An implementation of Unix signal handling for Tokio

-* **Fast**: Tokio's zero-cost abstractions give you bare-metal
-  performance.
+[![Build Status](https://travis-ci.org/alexcrichton/tokio-signal.svg?branch=master)](https://travis-ci.org/alexcrichton/tokio-signal)

-* **Reliable**: Tokio leverages Rust's ownership, type system, and
-  concurrency model to reduce bugs and ensure thread safety.
+[Documentation](https://alexcrichton.github.io/tokio-signal)

-* **Scalable**: Tokio has a minimal footprint, and handles backpressure
-  and cancellation naturally.
+## Usage

-[![Crates.io][crates-badge]][crates-url]
-[![MIT licensed][mit-badge]][mit-url]
-[![Build Status][azure-badge]][azure-url]
-[![Gitter chat][gitter-badge]][gitter-url]
+First, add this to your `Cargo.toml`:

-[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
-[azure-badge]: https://dev.azure.com/tokio-rs/Tokio/_apis/build/status/tokio-rs.tokio?branchName=master
-[azure-url]: https://dev.azure.com/tokio-rs/Tokio/_build/latest?definitionId=1&branchName=master
-[gitter-badge]: https://img.shields.io/gitter/room/tokio-rs/tokio.svg
-[gitter-url]: https://gitter.im/tokio-rs/tokio
-
-[Website](https://tokio.rs) |
-[Guides](https://tokio.rs/docs/getting-started/hello-world/) |
-[API Docs](https://docs.rs/tokio/0.1.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/doc/tokio/
-
-## Overview
-
-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 multithreaded, work-stealing based task [scheduler].
-* A [reactor] backed by the operating system's event queue (epoll, kqueue,
-  IOCP, etc...).
-* Asynchronous [TCP and UDP][net] sockets.
-
-These components provide the runtime components necessary for building
-an asynchronous application.
-
-[net]: https://docs.rs/tokio/0.1.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
-
-A basic TCP echo server with Tokio:
-
-```rust
-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);
-}
+```toml
+[dependencies]
+tokio-signal = { git = "https://github.com/alexcrichton/tokio-signal" }
 ```

-More examples can be found [here](tokio/examples).
+Next, add this to your crate:

-## Getting Help
+```rust
+extern crate tokio_signal;
+```

-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.
+# License

-[chat]: https://gitter.im/tokio-rs/tokio
-[issue]: https://github.com/tokio-rs/tokio/issues/new
+`tokio-signal` is primarily distributed under the terms of both the MIT
+license and the Apache License (Version 2.0), with portions covered by various
+BSD-like licenses.

-## Contributing
+See LICENSE-APACHE, and LICENSE-MIT for details.

-: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
-
-The `tokio` crate, found at the root, is primarily intended for use by
-application developers.  Library authors should depend on the sub crates, which
-have greater guarantees of stability.
-
-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-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-tcp`]: tokio-tcp
-[`tokio-threadpool`]: tokio-threadpool
-[`tokio-timer`]: tokio-timer
-[`tokio-udp`]: tokio-udp
-[`tokio-uds`]: tokio-uds
-
-## 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
-
-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.
@@ -1,2 +0,0 @@
-[build]
-target-dir = "../target"
@@ -1,49 +0,0 @@
-[package]
-name = "examples"
-edition = "2018"
-version = "0.1.0"
-authors = ["Carl Lerche <[email protected]>"]
-license = "MIT"
-
-# Break out of the parent workspace
-[workspace]
-
-[[bin]]
-name = "chat"
-path = "src/chat.rs"
-
-[[bin]]
-name = "echo_client"
-path = "src/echo_client.rs"
-
-[[bin]]
-name = "echo_server"
-path = "src/echo_server.rs"
-
-[[bin]]
-name = "hyper"
-path = "src/hyper.rs"
-
-[dependencies]
-tokio = { version = "0.1.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" }
@@ -1,5 +0,0 @@
-# Tokio async/await examples
-
-These are a separate crate in order to work around some cargo bugs. It also
-allows `[patch]` to be used in `Cargo.toml` to ensure the correct lib versions
-are being pulled in.
@@ -1,131 +0,0 @@
-#![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");
-            }
-        });
-    }
-}
-
@@ -1,50 +0,0 @@
-#![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),
-    }
-}
@@ -1,42 +0,0 @@
-#![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);
-    }
-}
@@ -1,29 +0,0 @@
-#![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());
-    }
-}
@@ -1,22 +0,0 @@
-#![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));
-}
@@ -1,114 +0,0 @@
-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
-      - tokio-trace
-      - tokio-trace/tokio-trace-core
-      - tokio-trace/test-log-support
-      - tokio-trace/test_static_max_level_features
-
- 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
-      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.26.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
@@ -1,115 +0,0 @@
-#![feature(test)]
-#![deny(warnings)]
-
-extern crate test;
-#[macro_use]
-extern crate futures;
-extern crate tokio;
-
-use std::io;
-use std::net::SocketAddr;
-use std::thread;
-
-use futures::sync::mpsc;
-use futures::sync::oneshot;
-use futures::{Future, Poll, Sink, Stream};
-use test::Bencher;
-use tokio::net::UdpSocket;
-
-/// UDP echo server
-struct EchoServer {
-    socket: UdpSocket,
-    buf: Vec<u8>,
-    to_send: Option<(usize, SocketAddr)>,
-}
-
-impl EchoServer {
-    fn new(s: UdpSocket) -> Self {
-        EchoServer {
-            socket: s,
-            to_send: None,
-            buf: vec![0u8; 1600],
-        }
-    }
-}
-
-impl Future for EchoServer {
-    type Item = ();
-    type Error = io::Error;
-
-    fn poll(&mut self) -> Poll<(), io::Error> {
-        loop {
-            if let Some(&(size, peer)) = self.to_send.as_ref() {
-                try_ready!(self.socket.poll_send_to(&self.buf[..size], &peer));
-                self.to_send = None;
-            }
-            self.to_send = Some(try_ready!(self.socket.poll_recv_from(&mut self.buf)));
-        }
-    }
-}
-
-#[bench]
-fn udp_echo_latency(b: &mut Bencher) {
-    let any_addr = "127.0.0.1:0".to_string();
-    let any_addr = any_addr.parse::<SocketAddr>().unwrap();
-
-    let (stop_c, stop_p) = oneshot::channel::<()>();
-    let (tx, rx) = oneshot::channel();
-
-    let child = thread::spawn(move || {
-        let socket = tokio::net::UdpSocket::bind(&any_addr).unwrap();
-        tx.send(socket.local_addr().unwrap()).unwrap();
-
-        let server = EchoServer::new(socket);
-        let server = server.select(stop_p.map_err(|_| panic!()));
-        let server = server.map_err(|_| ());
-        server.wait().unwrap();
-    });
-
-    let client = std::net::UdpSocket::bind(&any_addr).unwrap();
-
-    let server_addr = rx.wait().unwrap();
-    let mut buf = [0u8; 1000];
-
-    // warmup phase; for some reason initial couple of
-    // runs are much slower
-    //
-    // TODO: Describe the exact reasons; caching? branch predictor? lazy closures?
-    for _ in 0..8 {
-        client.send_to(&buf, &server_addr).unwrap();
-        let _ = client.recv_from(&mut buf).unwrap();
-    }
-
-    b.iter(|| {
-        client.send_to(&buf, &server_addr).unwrap();
-        let _ = client.recv_from(&mut buf).unwrap();
-    });
-
-    stop_c.send(()).unwrap();
-    child.join().unwrap();
-}
-
-#[bench]
-fn futures_channel_latency(b: &mut Bencher) {
-    let (mut in_tx, in_rx) = mpsc::channel(32);
-    let (out_tx, out_rx) = mpsc::channel::<_>(32);
-
-    let child = thread::spawn(|| out_tx.send_all(in_rx.then(|r| r.unwrap())).wait());
-    let mut rx_iter = out_rx.wait();
-
-    // warmup phase; for some reason initial couple of runs are much slower
-    //
-    // TODO: Describe the exact reasons; caching? branch predictor? lazy closures?
-    for _ in 0..8 {
-        in_tx.start_send(Ok(1usize)).unwrap();
-        let _ = rx_iter.next();
-    }
-
-    b.iter(|| {
-        in_tx.start_send(Ok(1usize)).unwrap();
-        let _ = rx_iter.next();
-    });
-
-    drop(in_tx);
-    child.join().unwrap().unwrap();
-}
@@ -1,57 +0,0 @@
-// Measure cost of different operations
-// to get a sense of performance tradeoffs
-#![feature(test)]
-#![deny(warnings)]
-
-extern crate mio;
-extern crate test;
-
-use test::Bencher;
-
-use mio::tcp::TcpListener;
-use mio::{PollOpt, Ready, Token};
-
-#[bench]
-fn mio_register_deregister(b: &mut Bencher) {
-    let addr = "127.0.0.1:0".parse().unwrap();
-    // Setup the server socket
-    let sock = TcpListener::bind(&addr).unwrap();
-    let poll = mio::Poll::new().unwrap();
-
-    const CLIENT: Token = Token(1);
-
-    b.iter(|| {
-        poll.register(&sock, CLIENT, Ready::readable(), PollOpt::edge())
-            .unwrap();
-        poll.deregister(&sock).unwrap();
-    });
-}
-
-#[bench]
-fn mio_reregister(b: &mut Bencher) {
-    let addr = "127.0.0.1:0".parse().unwrap();
-    // Setup the server socket
-    let sock = TcpListener::bind(&addr).unwrap();
-    let poll = mio::Poll::new().unwrap();
-
-    const CLIENT: Token = Token(1);
-    poll.register(&sock, CLIENT, Ready::readable(), PollOpt::edge())
-        .unwrap();
-
-    b.iter(|| {
-        poll.reregister(&sock, CLIENT, Ready::readable(), PollOpt::edge())
-            .unwrap();
-    });
-    poll.deregister(&sock).unwrap();
-}
-
-#[bench]
-fn mio_poll(b: &mut Bencher) {
-    let poll = mio::Poll::new().unwrap();
-    let timeout = std::time::Duration::new(0, 0);
-    let mut events = mio::Events::with_capacity(1024);
-
-    b.iter(|| {
-        poll.poll(&mut events, Some(timeout)).unwrap();
-    });
-}
@@ -1,261 +0,0 @@
-#![feature(test)]
-#![deny(warnings)]
-
-extern crate futures;
-extern crate tokio;
-
-#[macro_use]
-extern crate tokio_io;
-
-pub extern crate test;
-
-mod prelude {
-    pub use futures::*;
-    pub use tokio::net::{TcpListener, TcpStream};
-    pub use tokio::reactor::Reactor;
-    pub use tokio_io::io::read_to_end;
-
-    pub use std::io::{self, Read, Write};
-    pub use std::thread;
-    pub use std::time::Duration;
-    pub use test::{self, Bencher};
-}
-
-mod connect_churn {
-    use prelude::*;
-
-    const NUM: usize = 300;
-    const CONCURRENT: usize = 8;
-
-    #[bench]
-    fn one_thread(b: &mut Bencher) {
-        let addr = "127.0.0.1:0".parse().unwrap();
-
-        b.iter(move || {
-            let listener = TcpListener::bind(&addr).unwrap();
-            let addr = listener.local_addr().unwrap();
-
-            // Spawn a single future that accepts & drops connections
-            let serve_incomings = listener
-                .incoming()
-                .map_err(|e| panic!("server err: {:?}", e))
-                .for_each(|_| Ok(()));
-
-            let connects = stream::iter_result((0..NUM).map(|_| {
-                Ok(TcpStream::connect(&addr).and_then(|sock| {
-                    sock.set_linger(Some(Duration::from_secs(0))).unwrap();
-                    read_to_end(sock, vec![])
-                }))
-            }));
-
-            let connects_concurrent = connects
-                .buffer_unordered(CONCURRENT)
-                .map_err(|e| panic!("client err: {:?}", e))
-                .for_each(|_| Ok(()));
-
-            serve_incomings
-                .select(connects_concurrent)
-                .map(|_| ())
-                .map_err(|_| ())
-                .wait()
-                .unwrap();
-        });
-    }
-
-    fn n_workers(n: usize, b: &mut Bencher) {
-        let (shutdown_tx, shutdown_rx) = sync::oneshot::channel();
-        let (addr_tx, addr_rx) = sync::oneshot::channel();
-
-        // Spawn reactor thread
-        let server_thread = thread::spawn(move || {
-            // Bind the TCP listener
-            let listener = TcpListener::bind(&"127.0.0.1:0".parse().unwrap()).unwrap();
-
-            // Get the address being listened on.
-            let addr = listener.local_addr().unwrap();
-
-            // Send the remote & address back to the main thread
-            addr_tx.send(addr).unwrap();
-
-            // Spawn a single future that accepts & drops connections
-            let serve_incomings = listener
-                .incoming()
-                .map_err(|e| panic!("server err: {:?}", e))
-                .for_each(|_| Ok(()));
-
-            // Run server
-            serve_incomings
-                .select(shutdown_rx)
-                .map(|_| ())
-                .map_err(|_| ())
-                .wait()
-                .unwrap();
-        });
-
-        // Get the bind addr of the server
-        let addr = addr_rx.wait().unwrap();
-
-        b.iter(move || {
-            use std::sync::{Arc, Barrier};
-
-            // Create a barrier to coordinate threads
-            let barrier = Arc::new(Barrier::new(n + 1));
-
-            // Spawn worker threads
-            let threads: Vec<_> = (0..n)
-                .map(|_| {
-                    let barrier = barrier.clone();
-                    let addr = addr.clone();
-
-                    thread::spawn(move || {
-                        let connects = stream::iter_result((0..(NUM / n)).map(|_| {
-                            Ok(TcpStream::connect(&addr)
-                                .map_err(|e| panic!("connect err: {:?}", e))
-                                .and_then(|sock| {
-                                    sock.set_linger(Some(Duration::from_secs(0))).unwrap();
-                                    read_to_end(sock, vec![])
-                                }))
-                        }));
-
-                        barrier.wait();
-
-                        connects
-                            .buffer_unordered(CONCURRENT)
-                            .map_err(|e| panic!("client err: {:?}", e))
-                            .for_each(|_| Ok(()))
-                            .wait()
-                            .unwrap();
-                    })
-                })
-                .collect();
-
-            barrier.wait();
-
-            for th in threads {
-                th.join().unwrap();
-            }
-        });
-
-        // Shutdown the server
-        shutdown_tx.send(()).unwrap();
-        server_thread.join().unwrap();
-    }
-
-    #[bench]
-    fn two_threads(b: &mut Bencher) {
-        n_workers(1, b);
-    }
-
-    #[bench]
-    fn multi_threads(b: &mut Bencher) {
-        n_workers(4, b);
-    }
-}
-
-mod transfer {
-    use prelude::*;
-    use std::{cmp, mem};
-
-    const MB: usize = 3 * 1024 * 1024;
-
-    struct Drain {
-        sock: TcpStream,
-        chunk: usize,
-    }
-
-    impl Future for Drain {
-        type Item = ();
-        type Error = io::Error;
-
-        fn poll(&mut self) -> Poll<(), io::Error> {
-            let mut buf: [u8; 1024] = unsafe { mem::uninitialized() };
-
-            loop {
-                match try_nb!(self.sock.read(&mut buf[..self.chunk])) {
-                    0 => return Ok(Async::Ready(())),
-                    _ => {}
-                }
-            }
-        }
-    }
-
-    struct Transfer {
-        sock: TcpStream,
-        rem: usize,
-        chunk: usize,
-    }
-
-    impl Future for Transfer {
-        type Item = ();
-        type Error = io::Error;
-
-        fn poll(&mut self) -> Poll<(), io::Error> {
-            while self.rem > 0 {
-                let len = cmp::min(self.rem, self.chunk);
-                let buf = &DATA[..len];
-
-                let n = try_nb!(self.sock.write(&buf));
-                self.rem -= n;
-            }
-
-            Ok(Async::Ready(()))
-        }
-    }
-
-    static DATA: [u8; 1024] = [0; 1024];
-
-    fn one_thread(b: &mut Bencher, read_size: usize, write_size: usize) {
-        let addr = "127.0.0.1:0".parse().unwrap();
-
-        b.iter(move || {
-            let listener = TcpListener::bind(&addr).unwrap();
-            let addr = listener.local_addr().unwrap();
-
-            // Spawn a single future that accepts 1 connection, Drain it and drops
-            let server = listener
-                .incoming()
-                .into_future() // take the first connection
-                .map_err(|(e, _other_incomings)| e)
-                .map(|(connection, _other_incomings)| connection.unwrap())
-                .and_then(|sock| {
-                    sock.set_linger(Some(Duration::from_secs(0))).unwrap();
-                    let drain = Drain {
-                        sock: sock,
-                        chunk: read_size,
-                    };
-                    drain
-                        .map(|_| ())
-                        .map_err(|e| panic!("server error: {:?}", e))
-                })
-                .map_err(|e| panic!("server err: {:?}", e));
-
-            let client = TcpStream::connect(&addr)
-                .and_then(move |sock| Transfer {
-                    sock: sock,
-                    rem: MB,
-                    chunk: write_size,
-                })
-                .map_err(|e| panic!("client err: {:?}", e));
-
-            server.join(client).wait().unwrap();
-        });
-    }
-
-    mod small_chunks {
-        use prelude::*;
-
-        #[bench]
-        fn one_thread(b: &mut Bencher) {
-            super::one_thread(b, 32, 32);
-        }
-    }
-
-    mod big_chunks {
-        use prelude::*;
-
-        #[bench]
-        fn one_thread(b: &mut Bencher) {
-            super::one_thread(b, 1_024, 1_024);
-        }
-    }
-}
@@ -1,29 +0,0 @@
-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 }}
@@ -1,14 +0,0 @@
-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
@@ -1,27 +0,0 @@
-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
@@ -1,38 +0,0 @@
-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'
@@ -1,27 +0,0 @@
-steps:
-  # Linux and macOS.
-  - script: |
-      set -e
-      curl https://sh.rustup.rs -sSf | sh -s -- -y --default-toolchain $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: |
-      curl -sSf -o rustup-init.exe https://win.rustup.rs
-      rustup-init.exe -y --default-toolchain %RUSTUP_TOOLCHAIN%
-      set PATH=%PATH%;%USERPROFILE%\.cargo\bin
-      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
@@ -1,9 +0,0 @@
-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
@@ -1,16 +0,0 @@
-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
@@ -1,16 +0,0 @@
-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
@@ -1,19 +0,0 @@
-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 +nightly check --all
-
-  # Check benches
-  - script: cargo check --benches --all
-    displayName: Check benchmarks
@@ -1,41 +0,0 @@
-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 }}
@@ -1,36 +0,0 @@
-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-2018-11-18
-
-  - 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
-
@@ -1,22 +0,0 @@
-# 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-trace = { path = "tokio-trace" }
-tokio-trace-core = { path = "tokio-trace/tokio-trace-core" }
-tokio-udp = { path = "tokio-udp" }
-tokio-uds = { path = "tokio-uds" }
@@ -1,37 +0,0 @@
-# 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
@@ -0,0 +1,17 @@
+extern crate futures;
+extern crate tokio_core;
+extern crate tokio_signal;
+
+use futures::stream::Stream;
+use tokio_core::reactor::Core;
+
+fn main() {
+    let mut core = Core::new().unwrap();
+    let ctrlc = tokio_signal::ctrl_c(&core.handle());
+    let stream = core.run(ctrlc).unwrap();
+
+    core.run(stream.for_each(|()| {
+        println!("Ctrl-C received!");
+        Ok(())
+    })).unwrap();
+}
@@ -0,0 +1,62 @@
+//! Asynchronous signal handling for Tokio
+//!
+//! This crate implements asynchronous signal handling for Tokio, an
+//! asynchronous I/O framework in Rust. The primary type exported from this
+//! crate, `unix::Signal`, allows listening for arbitrary signals on Unix
+//! platforms, receiving them in an asynchronous fashion.
+//!
+//! Note that signal handling is in general a very tricky topic and should be
+//! used with great care. This crate attempts to implement 'best practice' for
+//! signal handling, but it should be evaluated for your own applications' needs
+//! to see if it's suitable.
+//!
+//! The are some fundamental limitations of this crate documented on the
+//! `Signal` structure as well.
+//!
+//! > **Note**: This crate compiles on Windows, but currently contains no
+//! >           bindings. Windows does not have signals like Unix does, but it
+//! >           does have a way to receive ctrl-c notifications at the console.
+//! >           It's planned that this will be bound and exported outside the
+//! >           `unix` module in the future!
+
+#![deny(missing_docs)]
+
+#[macro_use]
+extern crate futures;
+extern crate tokio_core;
+
+use futures::Future;
+use futures::stream::Stream;
+use tokio_core::reactor::Handle;
+use tokio_core::io::{IoStream, IoFuture};
+
+pub mod unix;
+pub mod windows;
+
+/// Creates a stream which receives "ctrl-c" notifications sent to a process.
+///
+/// In general signals are handled very differently across Unix and Windows, but
+/// this is somewhat cross platform in terms of how it can be handled. A ctrl-c
+/// event to a console process can be represented as a stream for both Windows
+/// and Unix.
+///
+/// This function receives a `Handle` to an event loop and returns a future
+/// which when resolves yields a stream receiving all signal events. Note that
+/// there are a number of caveats listening for signals, and you may wish to
+/// read up on the documentation in the `unix` or `windows` module to take a
+/// peek.
+pub fn ctrl_c(handle: &Handle) -> IoFuture<IoStream<()>> {
+    return ctrl_c_imp(handle);
+
+    #[cfg(unix)]
+    fn ctrl_c_imp(handle: &Handle) -> IoFuture<IoStream<()>> {
+        unix::Signal::new(unix::libc::SIGINT, handle).map(|x| {
+            x.map(|_| ()).boxed()
+        }).boxed()
+    }
+
+    #[cfg(windows)]
+    fn ctrl_c_imp(handle: &Handle) -> IoFuture<IoStream<()>> {
+        windows::Event::ctrl_c(handle).map(|x| x.boxed()).boxed()
+    }
+}
@@ -0,0 +1,396 @@
+//! Unix-specific types for signal handling.
+//!
+//! This module is only defined on Unix platforms and contains the primary
+//! `Signal` type for receiving notifications of signals.
+
+#![cfg(unix)]
+
+pub extern crate libc;
+extern crate mio;
+extern crate tokio_uds;
+
+use std::cell::RefCell;
+use std::io::{self, Write, Read};
+use std::mem;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Once, ONCE_INIT, Mutex};
+
+use futures::stream::{Stream, Fuse};
+use futures::{self, Future, IntoFuture, Complete, Oneshot, Poll, Async};
+use self::libc::c_int;
+use self::tokio_uds::UnixStream;
+use tokio_core::io::IoFuture;
+use tokio_core::reactor::{PollEvented, Handle};
+use tokio_core::channel::{channel, Sender, Receiver};
+
+static INIT: Once = ONCE_INIT;
+static mut GLOBAL_STATE: *mut GlobalState = 0 as *mut _;
+
+/// An implementation of `Stream` for receiving a particular type of signal.
+///
+/// This structure implements the `Stream` trait and represents notifications
+/// of the current process receiving a particular signal. The signal being
+/// listened for is passed to `Signal::new`, and the same signal number is then
+/// yielded as each element for the stream.
+///
+/// In general signal handling on Unix is a pretty tricky topic, and this
+/// structure is no exception! There are some important limitations to keep in
+/// mind when using `Signal` streams:
+///
+/// * While multiple event loops are supported, the *first* event loop to
+///   register a signal handler is required to be active to ensure that signals
+///   for other event loops are delivered. In other words, once an event loop
+///   registers a signal, it's best to keep it around and running. This is
+///   normally just a problem for tests, and the "workaround" is to spawn a
+///   thread in the background at the beginning of the test suite which is
+///   running an event loop (and listening for a signal).
+///
+/// * Signals handling in Unix already necessitates coalescing signals
+///   together sometimes. This `Signal` stream is also no exception here in
+///   that it will also coalesce signals. That is, even if the signal handler
+///   for this process runs multiple times, the `Signal` stream may only return
+///   one signal notification. Specifically, before `poll` is called, all
+///   signal notifications are coalesced into one item returned from `poll`.
+///   Once `poll` has been called, however, a further signal is guaranteed to
+///   be yielded as an item.
+///
+/// * Signal handling in general is relatively inefficient. Although some
+///   improvements are possible in this crate, it's recommended to not plan on
+///   having millions of signal channels open.
+///
+/// * Currently the "driver task" to process incoming signals never exits.
+///
+/// If you've got any questions about this feel free to open an issue on the
+/// repo, though, as I'd love to chat about this! In other words, I'd love to
+/// alleviate some of these limitations if possible!
+pub struct Signal {
+    signum: c_int,
+    reg: PollEvented<MyRegistration>,
+    _finished: Complete<()>,
+}
+
+struct GlobalState {
+    write: UnixStream,
+    tx: Mutex<Sender<Message>>,
+    signals: [GlobalSignalState; 32],
+}
+
+struct GlobalSignalState {
+    ready: AtomicBool,
+    prev: libc::sigaction,
+}
+
+enum Message {
+    NewSignal(c_int, Complete<io::Result<Signal>>),
+}
+
+struct DriverTask {
+    handle: Handle,
+    read: UnixStream,
+    rx: Fuse<Receiver<Message>>,
+    signals: [SignalState; 32],
+}
+
+struct SignalState {
+    registered: bool,
+    tasks: Vec<(RefCell<Oneshot<()>>, mio::SetReadiness)>,
+}
+
+pub use self::libc::{SIGINT, SIGTERM, SIGUSR1, SIGUSR2};
+pub use self::libc::{SIGHUP, SIGQUIT, SIGPIPE, SIGALRM, SIGTRAP};
+
+impl Signal {
+    /// Creates a new stream which will receive notifications when the current
+    /// process receives the signal `signum`.
+    ///
+    /// This function will create a new stream which may be based on the
+    /// event loop handle provided. This function returns a future which will
+    /// then resolve to the signal stream, if successful.
+    ///
+    /// The `Signal` stream is an infinite stream which will receive
+    /// notifications whenever a signal is received. More documentation can be
+    /// found on `Signal` itself, but to reiterate:
+    ///
+    /// * Signals may be coalesced beyond what the kernel already does.
+    /// * While multiple event loops are supported, the first event loop to
+    ///   register a signal handler must be active to deliver signal
+    ///   notifications
+    /// * Once a signal handle is registered with the process the underlying
+    ///   libc signal handler is never unregistered.
+    ///
+    /// A `Signal` stream can be created for a particular signal number
+    /// multiple times. When a signal is received then all the associated
+    /// channels will receive the signal notification.
+    pub fn new(signum: c_int, handle: &Handle) -> IoFuture<Signal> {
+        let mut init = None;
+        INIT.call_once(|| {
+            init = Some(global_init(handle));
+        });
+        let new_signal = futures::lazy(move || {
+            let (tx, rx) = futures::oneshot();
+            let msg = Message::NewSignal(signum, tx);
+            let res = unsafe {
+                (*GLOBAL_STATE).tx.lock().unwrap().send(msg)
+            };
+            res.expect("failed to request a new signal stream, did the \
+                        first event loop go away?");
+            rx.then(|r| r.unwrap())
+        });
+        match init {
+            Some(init) => init.into_future().and_then(|()| new_signal).boxed(),
+            None => new_signal.boxed(),
+        }
+    }
+}
+
+impl Stream for Signal {
+    type Item = c_int;
+    type Error = io::Error;
+
+    fn poll(&mut self) -> Poll<Option<c_int>, io::Error> {
+        if !self.reg.poll_read().is_ready() {
+            return Ok(Async::NotReady)
+        }
+        self.reg.need_read();
+        self.reg.get_ref()
+                .inner.borrow()
+                .as_ref().unwrap().1
+                .set_readiness(mio::Ready::none())
+                .expect("failed to set readiness");
+        Ok(Async::Ready(Some(self.signum)))
+    }
+}
+
+fn global_init(handle: &Handle) -> io::Result<()> {
+    let (tx, rx) = try!(channel(handle));
+    let (read, write) = try!(UnixStream::pair(handle));
+    unsafe {
+        let state = Box::new(GlobalState {
+            write: write,
+            signals: {
+                fn new() -> GlobalSignalState {
+                    GlobalSignalState {
+                        ready: AtomicBool::new(false),
+                        prev: unsafe { mem::zeroed() },
+                    }
+                }
+                [
+                    new(), new(), new(), new(), new(), new(), new(), new(),
+                    new(), new(), new(), new(), new(), new(), new(), new(),
+                    new(), new(), new(), new(), new(), new(), new(), new(),
+                    new(), new(), new(), new(), new(), new(), new(), new(),
+                ]
+            },
+            tx: Mutex::new(tx.clone()),
+        });
+        GLOBAL_STATE = Box::into_raw(state);
+
+        handle.spawn(DriverTask {
+            handle: handle.clone(),
+            rx: rx.fuse(),
+            read: read,
+            signals: {
+                fn new() -> SignalState {
+                    SignalState { registered: false, tasks: Vec::new() }
+                }
+                [
+                    new(), new(), new(), new(), new(), new(), new(), new(),
+                    new(), new(), new(), new(), new(), new(), new(), new(),
+                    new(), new(), new(), new(), new(), new(), new(), new(),
+                    new(), new(), new(), new(), new(), new(), new(), new(),
+                ]
+            },
+        });
+
+        Ok(())
+    }
+}
+
+impl Future for DriverTask {
+    type Item = ();
+    type Error = ();
+
+    fn poll(&mut self) -> Poll<(), ()> {
+        self.check_signal_drops();
+        self.check_messages();
+        self.check_signals();
+
+        // TODO: when to finish this task?
+        Ok(Async::NotReady)
+    }
+}
+
+impl DriverTask {
+    fn check_signal_drops(&mut self) {
+        for signal in self.signals.iter_mut() {
+            signal.tasks.retain(|task| {
+                !task.0.borrow_mut().poll().is_err()
+            });
+        }
+    }
+
+    fn check_messages(&mut self) {
+        loop {
+            // Acquire the next message
+            let message = match self.rx.poll() {
+                Ok(Async::Ready(Some(e))) => e,
+                Ok(Async::Ready(None)) |
+                Ok(Async::NotReady) => break,
+                Err(e) => panic!("error on rx: {}", e),
+            };
+            let (sig, complete) = match message {
+                Message::NewSignal(sig, complete) => (sig, complete),
+            };
+
+            // If the signal's too large, then we return an error, otherwise we
+            // use this index to look at the signal slot.
+            //
+            // If the signal wasn't previously registered then we do so now.
+            let signal = match self.signals.get_mut(sig as usize) {
+                Some(signal) => signal,
+                None => {
+                    complete.complete(Err(io::Error::new(io::ErrorKind::Other,
+                                                         "signum too large")));
+                    continue
+                }
+            };
+            if !signal.registered {
+                unsafe {
+                    let mut new: libc::sigaction = mem::zeroed();
+                    new.sa_sigaction = handler as usize;
+                    new.sa_flags = libc::SA_RESTART | libc::SA_SIGINFO;
+                    let mut prev = mem::zeroed();
+                    if libc::sigaction(sig, &new, &mut prev) != 0 {
+                        complete.complete(Err(io::Error::last_os_error()));
+                        continue
+                    }
+                    signal.registered = true;
+                }
+            }
+
+            // Acquire the (registration, set_readiness) pair by... assuming
+            // we're on the event loop (true because of the spawn above).
+            let reg = MyRegistration { inner: RefCell::new(None) };
+            let reg = match PollEvented::new(reg, &self.handle) {
+                Ok(reg) => reg,
+                Err(e) => {
+                    complete.complete(Err(e));
+                    continue
+                }
+            };
+
+            // Create the `Signal` to pass back and then also keep a handle to
+            // the `SetReadiness` for ourselves internally.
+            let (tx, rx) = futures::oneshot();
+            let ready = reg.get_ref().inner.borrow_mut().as_mut().unwrap().1.clone();
+            complete.complete(Ok(Signal {
+                signum: sig,
+                reg: reg,
+                _finished: tx,
+            }));
+            signal.tasks.push((RefCell::new(rx), ready));
+        }
+    }
+
+    fn check_signals(&mut self) {
+        // Drain all data from the pipe
+        let mut buf = [0; 32];
+        let mut any = false;
+        loop {
+            match self.read.read(&mut buf) {
+                Ok(0) => {  // EOF == something happened
+                    any = true;
+                    break
+                }
+                Ok(..) => any = true,   // data read, but keep draining
+                Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => break,
+                Err(e) => panic!("bad read: {}", e),
+            }
+        }
+
+        // If nothing happened, no need to check the signals
+        if !any {
+            return
+        }
+
+        for (i, slot) in self.signals.iter().enumerate() {
+            // No need to go farther if we haven't even registered a signal
+            if !slot.registered {
+                continue
+            }
+
+            // See if this signal actually happened since we last checked
+            unsafe {
+                if !(*GLOBAL_STATE).signals[i].ready.swap(false, Ordering::SeqCst) {
+                    continue
+                }
+            }
+
+            // Wake up all the tasks waiting on this signal
+            for task in slot.tasks.iter() {
+                task.1.set_readiness(mio::Ready::readable())
+                      .expect("failed to set readiness");
+            }
+        }
+    }
+}
+
+extern fn handler(signum: c_int,
+                  info: *mut libc::siginfo_t,
+                  ptr: *mut libc::c_void) {
+    type FnSigaction = extern fn(c_int, *mut libc::siginfo_t, *mut libc::c_void);
+    type FnHandler = extern fn(c_int);
+
+    unsafe {
+        let state = match (*GLOBAL_STATE).signals.get(signum as usize) {
+            Some(state) => state,
+            None => return,
+        };
+
+        if !state.ready.swap(true, Ordering::SeqCst) {
+            // Ignore errors here as we're not in a context that can panic,
+            // and otherwise there's not much we can do.
+            drop((&(*GLOBAL_STATE).write).write(&[1]));
+        }
+
+        let fnptr = state.prev.sa_sigaction;
+        if fnptr == 0 || fnptr == libc::SIG_DFL || fnptr == libc::SIG_IGN {
+            return
+        }
+        if state.prev.sa_flags & libc::SA_SIGINFO == 0 {
+            let action = mem::transmute::<usize, FnHandler>(fnptr);
+            action(signum)
+        } else {
+            let action = mem::transmute::<usize, FnSigaction>(fnptr);
+            action(signum, info, ptr)
+        }
+    }
+}
+
+struct MyRegistration {
+    inner: RefCell<Option<(mio::Registration, mio::SetReadiness)>>,
+}
+
+impl mio::Evented for MyRegistration {
+    fn register(&self,
+                poll: &mio::Poll,
+                token: mio::Token,
+                events: mio::Ready,
+                opts: mio::PollOpt) -> io::Result<()> {
+        let reg = mio::Registration::new(poll, token, events, opts);
+        *self.inner.borrow_mut() = Some(reg);
+        Ok(())
+    }
+
+    fn reregister(&self,
+                  _poll: &mio::Poll,
+                  _token: mio::Token,
+                  _events: mio::Ready,
+                  _opts: mio::PollOpt) -> io::Result<()> {
+        Ok(())
+    }
+
+    fn deregister(&self, _poll: &mio::Poll) -> io::Result<()> {
+        Ok(())
+    }
+}
@@ -0,0 +1,293 @@
+//! Windows-specific types for signal handling.
+//!
+//! This module is only defined on Windows and contains the primary `Event` type
+//! for receiving notifications of events. These events are listened for via the
+//! `SetConsoleCtrlHandler` function which receives events of the type
+//! `CTRL_C_EVENT` and `CTRL_BREAK_EVENT`
+
+#![cfg(windows)]
+
+extern crate kernel32;
+extern crate mio;
+extern crate winapi;
+
+use std::cell::RefCell;
+use std::io;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Once, ONCE_INIT, Mutex};
+
+use futures::stream::{Stream, Fuse};
+use futures::{self, Future, IntoFuture, Complete, Oneshot, Poll, Async};
+use tokio_core::io::IoFuture;
+use tokio_core::reactor::{PollEvented, Handle};
+use tokio_core::channel::{channel, Sender, Receiver};
+
+static INIT: Once = ONCE_INIT;
+static mut GLOBAL_STATE: *mut GlobalState = 0 as *mut _;
+
+/// Stream of events discovered via `SetConsoleCtrlHandler`.
+///
+/// This structure can be used to listen for events of the type `CTRL_C_EVENT`
+/// and `CTRL_BREAK_EVENT`. The `Stream` trait is implemented for this struct
+/// and will resolve for each notification received by the process. Note that
+/// there are few limitations with this as well:
+///
+/// * A notification to this process notifies *all* `Event` streams for that
+///   event type.
+/// * Notifications to an `Event` stream **are coalesced** if they aren't
+///   processed quickly enough. This means that if two notifications are
+///   received back-to-back, then the stream may only receive one item about the
+///   two notifications.
+pub struct Event {
+    reg: PollEvented<MyRegistration>,
+    _finished: Complete<()>,
+}
+
+struct GlobalState {
+    ready: mio::SetReadiness,
+    tx: Mutex<Sender<Message>>,
+    ctrl_c: GlobalEventState,
+    ctrl_break: GlobalEventState,
+}
+
+struct GlobalEventState {
+    ready: AtomicBool,
+}
+
+enum Message {
+    NewEvent(winapi::DWORD, Complete<io::Result<Event>>),
+}
+
+struct DriverTask {
+    handle: Handle,
+    reg: PollEvented<MyRegistration>,
+    rx: Fuse<Receiver<Message>>,
+    ctrl_c: EventState,
+    ctrl_break: EventState,
+}
+
+struct EventState {
+    tasks: Vec<(RefCell<Oneshot<()>>, mio::SetReadiness)>,
+}
+
+impl Event {
+    /// Creates a new stream listening for the `CTRL_C_EVENT` events.
+    ///
+    /// This function will register a handler via `SetConsoleCtrlHandler` and
+    /// deliver notifications to the returned stream.
+    pub fn ctrl_c(handle: &Handle) -> IoFuture<Event> {
+        Event::new(winapi::CTRL_C_EVENT, handle)
+    }
+
+    /// Creates a new stream listening for the `CTRL_BREAK_EVENT` events.
+    ///
+    /// This function will register a handler via `SetConsoleCtrlHandler` and
+    /// deliver notifications to the returned stream.
+    pub fn ctrl_break(handle: &Handle) -> IoFuture<Event> {
+        Event::new(winapi::CTRL_BREAK_EVENT, handle)
+    }
+
+    fn new(signum: winapi::DWORD, handle: &Handle) -> IoFuture<Event> {
+        let mut init = None;
+        INIT.call_once(|| {
+            init = Some(global_init(handle));
+        });
+        let new_signal = futures::lazy(move || {
+            let (tx, rx) = futures::oneshot();
+            let msg = Message::NewEvent(signum, tx);
+            let res = unsafe {
+                (*GLOBAL_STATE).tx.lock().unwrap().send(msg)
+            };
+            res.expect("failed to request a new signal stream, did the \
+                        first event loop go away?");
+            rx.then(|r| r.unwrap())
+        });
+        match init {
+            Some(init) => init.into_future().and_then(|()| new_signal).boxed(),
+            None => new_signal.boxed(),
+        }
+    }
+}
+
+impl Stream for Event {
+    type Item = ();
+    type Error = io::Error;
+
+    fn poll(&mut self) -> Poll<Option<()>, io::Error> {
+        if !self.reg.poll_read().is_ready() {
+            return Ok(Async::NotReady)
+        }
+        self.reg.need_read();
+        self.reg.get_ref()
+                .inner.borrow()
+                .as_ref().unwrap().1
+                .set_readiness(mio::Ready::none())
+                .expect("failed to set readiness");
+        Ok(Async::Ready(Some(())))
+    }
+}
+
+fn global_init(handle: &Handle) -> io::Result<()> {
+    let (tx, rx) = try!(channel(handle));
+    let reg = MyRegistration { inner: RefCell::new(None) };
+    let reg = try!(PollEvented::new(reg, handle));
+    let ready = reg.get_ref().inner.borrow().as_ref().unwrap().1.clone();
+    unsafe {
+        let state = Box::new(GlobalState {
+            ready: ready,
+            ctrl_c: GlobalEventState { ready: AtomicBool::new(false) },
+            ctrl_break: GlobalEventState { ready: AtomicBool::new(false) },
+            tx: Mutex::new(tx.clone()),
+        });
+        GLOBAL_STATE = Box::into_raw(state);
+
+        let rc = kernel32::SetConsoleCtrlHandler(Some(handler), winapi::TRUE);
+        if rc == 0 {
+            Box::from_raw(GLOBAL_STATE);
+            GLOBAL_STATE = 0 as *mut _;
+            return Err(io::Error::last_os_error())
+        }
+
+        handle.spawn(DriverTask {
+            handle: handle.clone(),
+            rx: rx.fuse(),
+            reg: reg,
+            ctrl_c: EventState { tasks: Vec::new() },
+            ctrl_break: EventState { tasks: Vec::new() },
+        });
+
+        Ok(())
+    }
+}
+
+impl Future for DriverTask {
+    type Item = ();
+    type Error = ();
+
+    fn poll(&mut self) -> Poll<(), ()> {
+        self.check_event_drops();
+        self.check_messages();
+        self.check_events();
+
+        // TODO: when to finish this task?
+        Ok(Async::NotReady)
+    }
+}
+
+impl DriverTask {
+    fn check_event_drops(&mut self) {
+        self.ctrl_c.tasks.retain(|task| {
+            !task.0.borrow_mut().poll().is_err()
+        });
+        self.ctrl_break.tasks.retain(|task| {
+            !task.0.borrow_mut().poll().is_err()
+        });
+    }
+
+    fn check_messages(&mut self) {
+        loop {
+            // Acquire the next message
+            let message = match self.rx.poll() {
+                Ok(Async::Ready(Some(e))) => e,
+                Ok(Async::Ready(None)) |
+                Ok(Async::NotReady) => break,
+                Err(e) => panic!("error on rx: {}", e),
+            };
+            let (sig, complete) = match message {
+                Message::NewEvent(sig, complete) => (sig, complete),
+            };
+
+            let event = if sig == winapi::CTRL_C_EVENT {
+                &mut self.ctrl_c
+            } else {
+                &mut self.ctrl_break
+            };
+
+            // Acquire the (registration, set_readiness) pair by... assuming
+            // we're on the event loop (true because of the spawn above).
+            let reg = MyRegistration { inner: RefCell::new(None) };
+            let reg = match PollEvented::new(reg, &self.handle) {
+                Ok(reg) => reg,
+                Err(e) => {
+                    complete.complete(Err(e));
+                    continue
+                }
+            };
+
+            // Create the `Event` to pass back and then also keep a handle to
+            // the `SetReadiness` for ourselves internally.
+            let (tx, rx) = futures::oneshot();
+            let ready = reg.get_ref().inner.borrow_mut().as_mut().unwrap().1.clone();
+            complete.complete(Ok(Event {
+                reg: reg,
+                _finished: tx,
+            }));
+            event.tasks.push((RefCell::new(rx), ready));
+        }
+    }
+
+    fn check_events(&mut self) {
+        if self.reg.poll_read().is_not_ready() {
+            return
+        }
+        self.reg.need_read();
+        self.reg.get_ref().inner.borrow().as_ref().unwrap()
+            .1.set_readiness(mio::Ready::none()).unwrap();
+
+        if unsafe { (*GLOBAL_STATE).ctrl_c.ready.swap(false, Ordering::SeqCst) } {
+            for task in self.ctrl_c.tasks.iter() {
+                task.1.set_readiness(mio::Ready::readable()).unwrap();
+            }
+        }
+        if unsafe { (*GLOBAL_STATE).ctrl_break.ready.swap(false, Ordering::SeqCst) } {
+            for task in self.ctrl_break.tasks.iter() {
+                task.1.set_readiness(mio::Ready::readable()).unwrap();
+            }
+        }
+    }
+}
+
+unsafe extern "system" fn handler(ty: winapi::DWORD) -> winapi::BOOL {
+    let event = match ty {
+        winapi::CTRL_C_EVENT => &(*GLOBAL_STATE).ctrl_c,
+        winapi::CTRL_BREAK_EVENT => &(*GLOBAL_STATE).ctrl_break,
+        _ => return winapi::FALSE
+    };
+    if event.ready.swap(true, Ordering::SeqCst) {
+        winapi::FALSE
+    } else {
+        drop((*GLOBAL_STATE).ready.set_readiness(mio::Ready::readable()));
+        // TODO: this will report that we handled a CTRL_BREAK_EVENT when in
+        //       fact we may not have any streams actually created for that
+        //       event.
+        winapi::TRUE
+    }
+}
+
+struct MyRegistration {
+    inner: RefCell<Option<(mio::Registration, mio::SetReadiness)>>,
+}
+
+impl mio::Evented for MyRegistration {
+    fn register(&self,
+                poll: &mio::Poll,
+                token: mio::Token,
+                events: mio::Ready,
+                opts: mio::PollOpt) -> io::Result<()> {
+        let reg = mio::Registration::new(poll, token, events, opts);
+        *self.inner.borrow_mut() = Some(reg);
+        Ok(())
+    }
+
+    fn reregister(&self,
+                  _poll: &mio::Poll,
+                  _token: mio::Token,
+                  _events: mio::Ready,
+                  _opts: mio::PollOpt) -> io::Result<()> {
+        Ok(())
+    }
+
+    fn deregister(&self, _poll: &mio::Poll) -> io::Result<()> {
+        Ok(())
+    }
+}
@@ -0,0 +1,97 @@
+#![cfg(unix)]
+
+extern crate futures;
+extern crate libc;
+extern crate tokio_core;
+extern crate tokio_signal;
+
+use std::sync::mpsc::channel;
+use std::sync::{Once, ONCE_INIT, Mutex, MutexGuard};
+use std::thread;
+use std::time::Duration;
+
+use futures::Future;
+use futures::stream::Stream;
+use tokio_core::reactor::{Core, Timeout};
+use tokio_signal::unix::Signal;
+
+static INIT: Once = ONCE_INIT;
+static mut LOCK: *mut Mutex<()> = 0 as *mut _;
+
+fn lock() -> MutexGuard<'static, ()> {
+    unsafe {
+        INIT.call_once(|| {
+            LOCK = Box::into_raw(Box::new(Mutex::new(())));
+            let (tx, rx) = channel();
+            thread::spawn(move || {
+                let mut lp = Core::new().unwrap();
+                let handle = lp.handle();
+                let _signal = lp.run(Signal::new(libc::SIGALRM, &handle)).unwrap();
+                tx.send(()).unwrap();
+                drop(lp.run(futures::empty::<(), ()>()));
+            });
+            rx.recv().unwrap();
+        });
+        (*LOCK).lock().unwrap()
+    }
+}
+
+#[test]
+fn simple() {
+    let _lock = lock();
+
+    let mut lp = Core::new().unwrap();
+    let handle = lp.handle();
+    let signal = lp.run(Signal::new(libc::SIGUSR1, &handle)).unwrap();
+    unsafe {
+        assert_eq!(libc::kill(libc::getpid(), libc::SIGUSR1), 0);
+    }
+    lp.run(signal.into_future()).ok().unwrap();
+}
+
+#[test]
+fn notify_both() {
+    let _lock = lock();
+
+    let mut lp = Core::new().unwrap();
+    let handle = lp.handle();
+    let signal1 = lp.run(Signal::new(libc::SIGUSR2, &handle)).unwrap();
+    let signal2 = lp.run(Signal::new(libc::SIGUSR2, &handle)).unwrap();
+    unsafe {
+        assert_eq!(libc::kill(libc::getpid(), libc::SIGUSR2), 0);
+    }
+    lp.run(signal1.into_future().join(signal2.into_future())).ok().unwrap();
+}
+
+#[test]
+fn drop_then_get_a_signal() {
+    let _lock = lock();
+
+    let mut lp = Core::new().unwrap();
+    let handle = lp.handle();
+    let signal = lp.run(Signal::new(libc::SIGUSR1, &handle)).unwrap();
+    drop(signal);
+    unsafe {
+        assert_eq!(libc::kill(libc::getpid(), libc::SIGUSR1), 0);
+    }
+    let timeout = Timeout::new(Duration::from_millis(1), &lp.handle()).unwrap();
+    lp.run(timeout).unwrap();
+}
+
+#[test]
+fn twice() {
+    let _lock = lock();
+
+    let mut lp = Core::new().unwrap();
+    let handle = lp.handle();
+    let signal = lp.run(Signal::new(libc::SIGUSR1, &handle)).unwrap();
+    unsafe {
+        assert_eq!(libc::kill(libc::getpid(), libc::SIGUSR1), 0);
+    }
+    let (num, signal) = lp.run(signal.into_future()).ok().unwrap();
+    assert_eq!(num, Some(libc::SIGUSR1));
+    unsafe {
+        assert_eq!(libc::kill(libc::getpid(), libc::SIGUSR1), 0);
+    }
+    lp.run(signal.into_future()).ok().unwrap();
+}
@@ -1,14 +0,0 @@
-# 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
@@ -1,32 +0,0 @@
-[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"
@@ -1,35 +0,0 @@
-# tokio-buf
-
-Asynchronous stream of byte buffers
-
-[Documenation](https://docs.rs/tokio-buf)
-
-## Usage
-
-First, add this to your `Cargo.toml`:
-
-```toml
-[dependencies]
-tokio-buf = "0.1.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.
@@ -1,99 +0,0 @@
-#![doc(html_root_url = "https://docs.rs/tokio-buf/0.1.1")]
-#![deny(missing_docs, missing_debug_implementations, unreachable_pub)]
-#![cfg_attr(test, deny(warnings))]
-
-//! Asynchronous stream of bytes.
-//!
-//! This crate contains the `BufStream` trait and a number of combinators for
-//! this trait. The trait is similar to `Stream` in the `futures` library, but
-//! instead of yielding arbitrary values, it only yields types that implement
-//! `Buf` (i.e, byte collections).
-
-extern crate bytes;
-#[cfg(feature = "util")]
-extern crate either;
-#[allow(unused)]
-#[macro_use]
-extern crate futures;
-
-mod never;
-mod size_hint;
-mod str;
-mod u8;
-#[cfg(feature = "util")]
-pub mod util;
-
-pub use self::size_hint::SizeHint;
-#[doc(inline)]
-#[cfg(feature = "util")]
-pub use util::BufStreamExt;
-
-use bytes::Buf;
-use futures::Poll;
-
-/// An asynchronous stream of bytes.
-///
-/// `BufStream` asynchronously yields values implementing `Buf`, i.e. byte
-/// buffers.
-pub trait BufStream {
-    /// Values yielded by the `BufStream`.
-    ///
-    /// Each item is a sequence of bytes representing a chunk of the total
-    /// `ByteStream`.
-    type Item: Buf;
-
-    /// The error type this `BufStream` might generate.
-    type Error;
-
-    /// Attempt to pull out the next buffer of this stream, registering the
-    /// current task for wakeup if the value is not yet available, and returning
-    /// `None` if the stream is exhausted.
-    ///
-    /// # Return value
-    ///
-    /// There are several possible return values, each indicating a distinct
-    /// stream state:
-    ///
-    /// - `Ok(Async::NotReady)` means that this stream's next value is not ready
-    /// yet. Implementations will ensure that the current task will be notified
-    /// when the next value may be ready.
-    ///
-    /// - `Ok(Async::Ready(Some(buf)))` means that the stream has successfully
-    /// produced a value, `buf`, and may produce further values on subsequent
-    /// `poll_buf` calls.
-    ///
-    /// - `Ok(Async::Ready(None))` means that the stream has terminated, and
-    /// `poll_buf` should not be invoked again.
-    ///
-    /// # Panics
-    ///
-    /// Once a stream is finished, i.e. `Ready(None)` has been returned, further
-    /// calls to `poll_buf` may result in a panic or other "bad behavior".
-    fn poll_buf(&mut self) -> Poll<Option<Self::Item>, Self::Error>;
-
-    /// Returns the bounds on the remaining length of the stream.
-    ///
-    /// The size hint allows the caller to perform certain optimizations that
-    /// are dependent on the byte stream size. For example, `collect` uses the
-    /// size hint to pre-allocate enough capacity to store the entirety of the
-    /// data received from the byte stream.
-    ///
-    /// When `SizeHint::upper()` returns `Some` with a value equal to
-    /// `SizeHint::lower()`, this represents the exact number of bytes that will
-    /// be yielded by the `BufStream`.
-    ///
-    /// # Implementation notes
-    ///
-    /// While not enforced, implementations are expected to respect the values
-    /// returned from `SizeHint`. Any deviation is considered an implementation
-    /// bug. Consumers may rely on correctness in order to use the value as part
-    /// of protocol impelmentations. For example, an HTTP library may use the
-    /// size hint to set the `content-length` header.
-    ///
-    /// However, `size_hint` must not be trusted to omit bounds checks in unsafe
-    /// code. An incorrect implementation of `size_hint()` must not lead to
-    /// memory safety violations.
-    fn size_hint(&self) -> SizeHint {
-        SizeHint::default()
-    }
-}
@@ -1,22 +0,0 @@
-use std::{error, fmt};
-
-/// An error that can never occur
-pub enum Never {}
-
-impl fmt::Debug for Never {
-    fn fmt(&self, _f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {}
-    }
-}
-
-impl fmt::Display for Never {
-    fn fmt(&self, _f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {}
-    }
-}
-
-impl error::Error for Never {
-    fn description(&self) -> &str {
-        match *self {}
-    }
-}
@@ -1,56 +0,0 @@
-use std::u64;
-
-/// A `BufStream` size hint
-///
-/// The default implementation returns:
-///
-/// * 0 for `available`
-/// * 0 for `lower`
-/// * `None` for `upper`.
-#[derive(Debug, Default, Clone)]
-pub struct SizeHint {
-    lower: u64,
-    upper: Option<u64>,
-}
-
-impl SizeHint {
-    /// Returns a new `SizeHint` with default values
-    pub fn new() -> SizeHint {
-        SizeHint::default()
-    }
-
-    /// Returns the lower bound of data that the `BufStream` will yield before
-    /// completing.
-    pub fn lower(&self) -> u64 {
-        self.lower
-    }
-
-    /// Set the value of the `lower` hint.
-    ///
-    /// # Panics
-    ///
-    /// The function panics if `value` is 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);
-    }
-}
@@ -1,55 +0,0 @@
-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
-}
@@ -1,66 +0,0 @@
-use bytes::{Bytes, BytesMut};
-use futures::Poll;
-use never::Never;
-use std::io;
-use BufStream;
-
-impl BufStream for Vec<u8> {
-    type Item = io::Cursor<Vec<u8>>;
-    type Error = Never;
-
-    fn poll_buf(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
-        if self.is_empty() {
-            return Ok(None.into());
-        }
-
-        poll_bytes(self)
-    }
-}
-
-impl BufStream for &'static [u8] {
-    type Item = io::Cursor<&'static [u8]>;
-    type Error = Never;
-
-    fn poll_buf(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
-        if self.is_empty() {
-            return Ok(None.into());
-        }
-
-        poll_bytes(self)
-    }
-}
-
-impl BufStream for Bytes {
-    type Item = io::Cursor<Bytes>;
-    type Error = Never;
-
-    fn poll_buf(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
-        if self.is_empty() {
-            return Ok(None.into());
-        }
-
-        poll_bytes(self)
-    }
-}
-
-impl BufStream for BytesMut {
-    type Item = io::Cursor<BytesMut>;
-    type Error = Never;
-
-    fn poll_buf(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
-        if self.is_empty() {
-            return Ok(None.into());
-        }
-
-        poll_bytes(self)
-    }
-}
-
-fn poll_bytes<T: Default>(buf: &mut T) -> Poll<Option<io::Cursor<T>>, Never> {
-    use std::mem;
-
-    let bytes = mem::replace(buf, Default::default());
-    let buf = io::Cursor::new(bytes);
-
-    Ok(Some(buf).into())
-}
@@ -1,46 +0,0 @@
-use BufStream;
-
-use either::Either;
-use futures::Poll;
-
-/// A buf stream that sequences two buf streams together.
-///
-/// `Chain` values are produced by the `chain` function on `BufStream`.
-#[derive(Debug)]
-pub struct Chain<T, U> {
-    left: Option<T>,
-    right: U,
-}
-
-impl<T, U> Chain<T, U> {
-    pub(crate) fn new(left: T, right: U) -> Chain<T, U> {
-        Chain {
-            left: Some(left),
-            right,
-        }
-    }
-}
-
-impl<T, U> BufStream for Chain<T, U>
-where
-    T: BufStream,
-    U: BufStream<Error = T::Error>,
-{
-    type Item = Either<T::Item, U::Item>;
-    type Error = T::Error;
-
-    fn poll_buf(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
-        if let Some(ref mut stream) = self.left {
-            let res = try_ready!(stream.poll_buf());
-
-            if res.is_some() {
-                return Ok(res.map(Either::Left).into());
-            }
-        }
-
-        self.left = None;
-
-        let res = try_ready!(self.right.poll_buf());
-        Ok(res.map(Either::Right).into())
-    }
-}
@@ -1,101 +0,0 @@
-use super::FromBufStream;
-use BufStream;
-
-use futures::{Future, Poll};
-
-/// Consumes a buf stream, collecting the data into a single byte container.
-///
-/// `Collect` values are produced by `BufStream::collect`.
-#[derive(Debug)]
-pub struct Collect<T, U>
-where
-    T: BufStream,
-    U: FromBufStream<T::Item>,
-{
-    stream: T,
-    builder: Option<U::Builder>,
-}
-
-/// Errors returned from `Collect` future.
-#[derive(Debug)]
-pub struct CollectError<T, U> {
-    inner: Error<T, U>,
-}
-
-#[derive(Debug)]
-enum Error<T, U> {
-    Stream(T),
-    Collect(U),
-}
-
-impl<T, U> Collect<T, U>
-where
-    T: BufStream,
-    U: FromBufStream<T::Item>,
-{
-    pub(crate) fn new(stream: T) -> Collect<T, U> {
-        let builder = U::builder(&stream.size_hint());
-
-        Collect {
-            stream,
-            builder: Some(builder),
-        }
-    }
-}
-
-impl<T, U> Future for Collect<T, U>
-where
-    T: BufStream,
-    U: FromBufStream<T::Item>,
-{
-    type Item = U;
-    type Error = CollectError<T::Error, U::Error>;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        loop {
-            let res = self.stream.poll_buf().map_err(|err| {
-                let inner = Error::Stream(err);
-                CollectError { inner }
-            });
-
-            match try_ready!(res) {
-                Some(mut buf) => {
-                    let builder = self.builder.as_mut().expect("cannot poll after done");
-
-                    U::extend(builder, &mut buf, &self.stream.size_hint()).map_err(|err| {
-                        let inner = Error::Collect(err);
-                        CollectError { inner }
-                    })?;
-                }
-                None => {
-                    let builder = self.builder.take().expect("cannot poll after done");
-                    let value = U::build(builder).map_err(|err| {
-                        let inner = Error::Collect(err);
-                        CollectError { inner }
-                    })?;
-                    return Ok(value.into());
-                }
-            }
-        }
-    }
-}
-
-// ===== impl CollectError =====
-
-impl<T, U> CollectError<T, U> {
-    /// Returns `true` if the error was caused by polling the stream.
-    pub fn is_stream_err(&self) -> bool {
-        match self.inner {
-            Error::Stream(_) => true,
-            _ => false,
-        }
-    }
-
-    /// Returns `true` if the error happened while collecting the data.
-    pub fn is_collect_err(&self) -> bool {
-        match self.inner {
-            Error::Collect(_) => true,
-            _ => false,
-        }
-    }
-}
@@ -1,162 +0,0 @@
-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"
-    }
-}
@@ -1,54 +0,0 @@
-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!();
-    }
-}
@@ -1,76 +0,0 @@
-use BufStream;
-
-use bytes::Buf;
-use futures::Poll;
-
-/// Limits the stream to a maximum amount of data.
-#[derive(Debug)]
-pub struct Limit<T> {
-    stream: T,
-    remaining: u64,
-}
-
-/// Errors returned from `Limit`.
-#[derive(Debug)]
-pub struct LimitError<T> {
-    /// When `None`, limit was reached
-    inner: Option<T>,
-}
-
-impl<T> Limit<T> {
-    pub(crate) fn new(stream: T, amount: u64) -> Limit<T> {
-        Limit {
-            stream,
-            remaining: amount,
-        }
-    }
-}
-
-impl<T> BufStream for Limit<T>
-where
-    T: BufStream,
-{
-    type Item = T::Item;
-    type Error = LimitError<T::Error>;
-
-    fn poll_buf(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
-        use futures::Async::Ready;
-
-        if self.stream.size_hint().lower() > self.remaining {
-            return Err(LimitError { inner: None });
-        }
-
-        let res = self
-            .stream
-            .poll_buf()
-            .map_err(|err| LimitError { inner: Some(err) });
-
-        match res {
-            Ok(Ready(Some(ref buf))) => {
-                if buf.remaining() as u64 > self.remaining {
-                    self.remaining = 0;
-                    return Err(LimitError { inner: None });
-                }
-
-                self.remaining -= buf.remaining() as u64;
-            }
-            _ => {}
-        }
-
-        res
-    }
-}
-
-// ===== impl LimitError =====
-
-impl<T> LimitError<T> {
-    /// Returns `true` if the error was caused by polling the stream.
-    pub fn is_stream_err(&self) -> bool {
-        self.inner.is_some()
-    }
-
-    /// Returns `true` if the stream reached its limit.
-    pub fn is_limit_err(&self) -> bool {
-        self.inner.is_none()
-    }
-}
@@ -1,87 +0,0 @@
-//! 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)
-    }
-}
@@ -1,76 +0,0 @@
-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),
-        }
-    }
-}
@@ -1,7 +0,0 @@
-extern crate tokio_buf;
-
-use tokio_buf::BufStream;
-
-// Ensures that `BufStream` can be a trait object
-#[allow(dead_code)]
-fn obj(_: &mut BufStream<Item = u32, Error = ()>) {}
@@ -1,43 +0,0 @@
-#![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());
-}
@@ -1,68 +0,0 @@
-#![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);
-}
@@ -1,33 +0,0 @@
-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)
-}
@@ -1,65 +0,0 @@
-#![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());
-}
@@ -1,42 +0,0 @@
-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);
-}
@@ -1,49 +0,0 @@
-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)
-}
@@ -1,38 +0,0 @@
-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");
-}
@@ -1,133 +0,0 @@
-#![allow(unused)]
-
-extern crate bytes;
-extern crate futures;
-extern crate tokio_buf;
-
-use bytes::Buf;
-use futures::Async::*;
-use futures::Poll;
-use tokio_buf::{BufStream, SizeHint};
-
-use std::collections::VecDeque;
-use std::io::Cursor;
-
-macro_rules! assert_buf_eq {
-    ($actual:expr, $expect:expr) => {{
-        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)
-    }
-}
@@ -1,7 +0,0 @@
-# 0.1.1 (September 26, 2018)
-
-* Allow setting max line length with `LinesCodec` (#632)
-
-# 0.1.0 (June 13, 2018)
-
-* Initial release (#353)
@@ -1,25 +0,0 @@
-[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"
@@ -1,25 +0,0 @@
-Copyright (c) 2019 Tokio Contributors
-
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
@@ -1,35 +0,0 @@
-# tokio-codec
-
-Utilities for encoding and decoding frames.
-
-[Documentation](https://docs.rs/tokio-codec)
-
-## Usage
-
-First, add this to your `Cargo.toml`:
-
-```toml
-[dependencies]
-tokio-codec = "0.1"
-```
-
-Next, add this to your crate:
-
-```rust
-extern crate tokio_codec;
-```
-
-You can find extensive documentation and examples about how to use this crate
-online at [https://tokio.rs](https://tokio.rs). The [API
-documentation](https://docs.rs/tokio-codec) is also a great place to get started
-for the nitty-gritty.
-
-## License
-
-This project is licensed under the [MIT license](LICENSE).
-
-### Contribution
-
-Unless you explicitly state otherwise, any contribution intentionally submitted
-for inclusion in Tokio by you, shall be licensed as MIT, without any additional
-terms or conditions.
@@ -1,39 +0,0 @@
-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(())
-    }
-}
@@ -1,25 +0,0 @@
-#![deny(missing_docs, missing_debug_implementations, warnings)]
-#![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;
@@ -1,195 +0,0 @@
-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(())
-    }
-}
@@ -1,202 +0,0 @@
-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);
-}
@@ -1,94 +0,0 @@
-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);
-}
@@ -1,215 +0,0 @@
-extern crate bytes;
-extern crate futures;
-extern crate tokio_codec;
-extern crate tokio_io;
-
-use tokio_codec::{Decoder, FramedRead};
-use tokio_io::AsyncRead;
-
-use bytes::{Buf, BytesMut, IntoBuf};
-use futures::Async::{NotReady, Ready};
-use futures::Stream;
-
-use std::collections::VecDeque;
-use std::io::{self, Read};
-
-macro_rules! mock {
-    ($($x:expr,)*) => {{
-        let mut v = VecDeque::new();
-        v.extend(vec![$($x),*]);
-        Mock { calls: v }
-    }};
-}
-
-struct U32Decoder;
-
-impl Decoder for U32Decoder {
-    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))
-    }
-}
-
-#[test]
-fn read_multi_frame_in_packet() {
-    let mock = mock! {
-        Ok(b"\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02".to_vec()),
-    };
-
-    let mut framed = FramedRead::new(mock, U32Decoder);
-    assert_eq!(Ready(Some(0)), framed.poll().unwrap());
-    assert_eq!(Ready(Some(1)), framed.poll().unwrap());
-    assert_eq!(Ready(Some(2)), framed.poll().unwrap());
-    assert_eq!(Ready(None), framed.poll().unwrap());
-}
-
-#[test]
-fn read_multi_frame_across_packets() {
-    let mock = mock! {
-        Ok(b"\x00\x00\x00\x00".to_vec()),
-        Ok(b"\x00\x00\x00\x01".to_vec()),
-        Ok(b"\x00\x00\x00\x02".to_vec()),
-    };
-
-    let mut framed = FramedRead::new(mock, U32Decoder);
-    assert_eq!(Ready(Some(0)), framed.poll().unwrap());
-    assert_eq!(Ready(Some(1)), framed.poll().unwrap());
-    assert_eq!(Ready(Some(2)), framed.poll().unwrap());
-    assert_eq!(Ready(None), framed.poll().unwrap());
-}
-
-#[test]
-fn read_not_ready() {
-    let mock = mock! {
-        Err(io::Error::new(io::ErrorKind::WouldBlock, "")),
-        Ok(b"\x00\x00\x00\x00".to_vec()),
-        Ok(b"\x00\x00\x00\x01".to_vec()),
-    };
-
-    let mut framed = FramedRead::new(mock, U32Decoder);
-    assert_eq!(NotReady, framed.poll().unwrap());
-    assert_eq!(Ready(Some(0)), framed.poll().unwrap());
-    assert_eq!(Ready(Some(1)), framed.poll().unwrap());
-    assert_eq!(Ready(None), framed.poll().unwrap());
-}
-
-#[test]
-fn read_partial_then_not_ready() {
-    let mock = mock! {
-        Ok(b"\x00\x00".to_vec()),
-        Err(io::Error::new(io::ErrorKind::WouldBlock, "")),
-        Ok(b"\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02".to_vec()),
-    };
-
-    let mut framed = FramedRead::new(mock, U32Decoder);
-    assert_eq!(NotReady, framed.poll().unwrap());
-    assert_eq!(Ready(Some(0)), framed.poll().unwrap());
-    assert_eq!(Ready(Some(1)), framed.poll().unwrap());
-    assert_eq!(Ready(Some(2)), framed.poll().unwrap());
-    assert_eq!(Ready(None), framed.poll().unwrap());
-}
-
-#[test]
-fn read_err() {
-    let mock = mock! {
-        Err(io::Error::new(io::ErrorKind::Other, "")),
-    };
-
-    let mut framed = FramedRead::new(mock, U32Decoder);
-    assert_eq!(io::ErrorKind::Other, framed.poll().unwrap_err().kind());
-}
-
-#[test]
-fn read_partial_then_err() {
-    let mock = mock! {
-        Ok(b"\x00\x00".to_vec()),
-        Err(io::Error::new(io::ErrorKind::Other, "")),
-    };
-
-    let mut framed = FramedRead::new(mock, U32Decoder);
-    assert_eq!(io::ErrorKind::Other, framed.poll().unwrap_err().kind());
-}
-
-#[test]
-fn read_partial_would_block_then_err() {
-    let mock = mock! {
-        Ok(b"\x00\x00".to_vec()),
-        Err(io::Error::new(io::ErrorKind::WouldBlock, "")),
-        Err(io::Error::new(io::ErrorKind::Other, "")),
-    };
-
-    let mut framed = FramedRead::new(mock, U32Decoder);
-    assert_eq!(NotReady, framed.poll().unwrap());
-    assert_eq!(io::ErrorKind::Other, framed.poll().unwrap_err().kind());
-}
-
-#[test]
-fn huge_size() {
-    let data = [0; 32 * 1024];
-
-    let mut framed = FramedRead::new(&data[..], BigDecoder);
-    assert_eq!(Ready(Some(0)), framed.poll().unwrap());
-    assert_eq!(Ready(None), framed.poll().unwrap());
-
-    struct BigDecoder;
-
-    impl Decoder for BigDecoder {
-        type Item = u32;
-        type Error = io::Error;
-
-        fn decode(&mut self, buf: &mut BytesMut) -> io::Result<Option<u32>> {
-            if buf.len() < 32 * 1024 {
-                return Ok(None);
-            }
-            buf.split_to(32 * 1024);
-            Ok(Some(0))
-        }
-    }
-}
-
-#[test]
-fn data_remaining_is_error() {
-    let data = [0; 5];
-
-    let mut framed = FramedRead::new(&data[..], U32Decoder);
-    assert_eq!(Ready(Some(0)), framed.poll().unwrap());
-    assert!(framed.poll().is_err());
-}
-
-#[test]
-fn multi_frames_on_eof() {
-    struct MyDecoder(Vec<u32>);
-
-    impl Decoder for MyDecoder {
-        type Item = u32;
-        type Error = io::Error;
-
-        fn decode(&mut self, _buf: &mut BytesMut) -> io::Result<Option<u32>> {
-            unreachable!();
-        }
-
-        fn decode_eof(&mut self, _buf: &mut BytesMut) -> io::Result<Option<u32>> {
-            if self.0.is_empty() {
-                return Ok(None);
-            }
-
-            Ok(Some(self.0.remove(0)))
-        }
-    }
-
-    let mut framed = FramedRead::new(mock!(), MyDecoder(vec![0, 1, 2, 3]));
-    assert_eq!(Ready(Some(0)), framed.poll().unwrap());
-    assert_eq!(Ready(Some(1)), framed.poll().unwrap());
-    assert_eq!(Ready(Some(2)), framed.poll().unwrap());
-    assert_eq!(Ready(Some(3)), framed.poll().unwrap());
-    assert_eq!(Ready(None), framed.poll().unwrap());
-}
-
-// ===== Mock ======
-
-struct Mock {
-    calls: VecDeque<io::Result<Vec<u8>>>,
-}
-
-impl Read for Mock {
-    fn read(&mut self, dst: &mut [u8]) -> io::Result<usize> {
-        match self.calls.pop_front() {
-            Some(Ok(data)) => {
-                debug_assert!(dst.len() >= data.len());
-                dst[..data.len()].copy_from_slice(&data[..]);
-                Ok(data.len())
-            }
-            Some(Err(e)) => Err(e),
-            None => Ok(0),
-        }
-    }
-}
-
-impl AsyncRead for Mock {}
@@ -1,134 +0,0 @@
-extern crate bytes;
-extern crate futures;
-extern crate tokio_codec;
-extern crate tokio_io;
-
-use tokio_codec::{Encoder, FramedWrite};
-use tokio_io::AsyncWrite;
-
-use bytes::{BufMut, BytesMut};
-use futures::{Poll, Sink};
-
-use std::collections::VecDeque;
-use std::io::{self, Write};
-
-macro_rules! mock {
-    ($($x:expr,)*) => {{
-        let mut v = VecDeque::new();
-        v.extend(vec![$($x),*]);
-        Mock { calls: v }
-    }};
-}
-
-struct U32Encoder;
-
-impl Encoder for U32Encoder {
-    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(())
-    }
-}
-
-#[test]
-fn write_multi_frame_in_packet() {
-    let mock = mock! {
-        Ok(b"\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02".to_vec()),
-    };
-
-    let mut framed = FramedWrite::new(mock, U32Encoder);
-    assert!(framed.start_send(0).unwrap().is_ready());
-    assert!(framed.start_send(1).unwrap().is_ready());
-    assert!(framed.start_send(2).unwrap().is_ready());
-
-    // Nothing written yet
-    assert_eq!(1, framed.get_ref().calls.len());
-
-    // Flush the writes
-    assert!(framed.poll_complete().unwrap().is_ready());
-
-    assert_eq!(0, framed.get_ref().calls.len());
-}
-
-#[test]
-fn write_hits_backpressure() {
-    const ITER: usize = 2 * 1024;
-
-    let mut mock = mock! {
-        // Block the `ITER`th write
-        Err(io::Error::new(io::ErrorKind::WouldBlock, "not ready")),
-        Ok(b"".to_vec()),
-    };
-
-    for i in 0..(ITER + 1) {
-        let mut b = BytesMut::with_capacity(4);
-        b.put_u32_be(i as u32);
-
-        // Append to the end
-        match mock.calls.back_mut().unwrap() {
-            &mut Ok(ref mut data) => {
-                // Write in 2kb chunks
-                if data.len() < ITER {
-                    data.extend_from_slice(&b[..]);
-                    continue;
-                }
-            }
-            _ => unreachable!(),
-        }
-
-        // Push a new new chunk
-        mock.calls.push_back(Ok(b[..].to_vec()));
-    }
-
-    let mut framed = FramedWrite::new(mock, U32Encoder);
-
-    for i in 0..ITER {
-        assert!(framed.start_send(i as u32).unwrap().is_ready());
-    }
-
-    // This should reject
-    assert!(!framed.start_send(ITER as u32).unwrap().is_ready());
-
-    // This should succeed and start flushing the buffer.
-    assert!(framed.start_send(ITER as u32).unwrap().is_ready());
-
-    // Flush the rest of the buffer
-    assert!(framed.poll_complete().unwrap().is_ready());
-
-    // Ensure the mock is empty
-    assert_eq!(0, framed.get_ref().calls.len());
-}
-
-// ===== Mock ======
-
-struct Mock {
-    calls: VecDeque<io::Result<Vec<u8>>>,
-}
-
-impl Write for Mock {
-    fn write(&mut self, src: &[u8]) -> io::Result<usize> {
-        match self.calls.pop_front() {
-            Some(Ok(data)) => {
-                assert!(src.len() >= data.len());
-                assert_eq!(&data[..], &src[..data.len()]);
-                Ok(data.len())
-            }
-            Some(Err(e)) => Err(e),
-            None => panic!("unexpected write; {:?}", src),
-        }
-    }
-
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-impl AsyncWrite for Mock {
-    fn shutdown(&mut self) -> Poll<(), io::Error> {
-        Ok(().into())
-    }
-}
@@ -1,31 +0,0 @@
-# 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)
@@ -1,25 +0,0 @@
-[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"
@@ -1,25 +0,0 @@
-Copyright (c) 2019 Tokio Contributors
-
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
@@ -1,19 +0,0 @@
-# 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.
@@ -1,866 +0,0 @@
-#![doc(html_root_url = "https://docs.rs/tokio-current-thread/0.1.6")]
-#![deny(warnings, 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<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<Future<Item = (), Error = ()>>, already_counted: bool);
-}
-
-struct CurrentRunner {
-    spawn: Cell<Option<*mut 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<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<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<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<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<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 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 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 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 }
-    }
-}
@@ -1,770 +0,0 @@
-use super::Borrow;
-use tokio_executor::park::Unpark;
-use tokio_executor::Enter;
-
-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::{AcqRel, Acquire, Relaxed, Release, SeqCst};
-use std::sync::atomic::{AtomicBool, AtomicPtr, AtomicUsize};
-use std::sync::{Arc, Weak};
-use std::thread;
-use std::usize;
-
-/// A generic task-aware scheduler.
-///
-/// This is used both by `FuturesUnordered` and the current-thread executor.
-pub struct Scheduler<U> {
-    inner: Arc<Inner<U>>,
-    nodes: List<U>,
-}
-
-pub struct Notify<'a, U: 'a>(&'a Arc<Node<U>>);
-
-// A linked-list of nodes
-struct List<U> {
-    len: usize,
-    head: *const Node<U>,
-    tail: *const Node<U>,
-}
-
-// Scheduler is implemented using two linked lists. The first linked list tracks
-// all items managed by a `Scheduler`. This list is stored on the `Scheduler`
-// struct and is **not** thread safe. The second linked list is an
-// implementation of the intrusive MPSC queue algorithm described by
-// 1024cores.net and is stored on `Inner`. This linked list can push items to
-// the back concurrently but only one consumer may pop from the front. To
-// enforce this requirement, all popping will be performed via fns on
-// `Scheduler` that take `&mut self`.
-//
-// When a item is submitted to the set a node is allocated and inserted in
-// both linked lists. This means that all insertion operations **must** be
-// originated from `Scheduler` with `&mut self` The next call to `tick` will
-// (eventually) see this node and call `poll` on the item.
-//
-// Nodes are wrapped in `Arc` cells which manage the lifetime of the node.
-// However, `Arc` handles are sometimes cast to `*const Node` pointers.
-// 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
-// `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
-// dropping an Arc handle). However, it can **only** decrement the reference
-// count if the node is not currently stored in the mpsc channel. If the node
-// **is** "queued" in the mpsc channel, then the arc reference count cannot be
-// decremented. Once the node is popped from the mpsc channel, then the final
-// arc reference count can be decremented, thus freeing the node.
-
-struct Inner<U> {
-    // Thread unpark handle
-    unpark: U,
-
-    // Tick number
-    tick_num: AtomicUsize,
-
-    // Head/tail of the readiness queue
-    head_readiness: AtomicPtr<Node<U>>,
-    tail_readiness: UnsafeCell<*const Node<U>>,
-
-    // Used as part of the mpsc queue algorithm
-    stub: Arc<Node<U>>,
-}
-
-unsafe impl<U: Sync + Send> Send for Inner<U> {}
-unsafe impl<U: Sync + Send> Sync for Inner<U> {}
-
-impl<U: Unpark> executor::Notify for Inner<U> {
-    fn notify(&self, _: usize) {
-        self.unpark.unpark();
-    }
-}
-
-struct Node<U> {
-    // The item
-    item: UnsafeCell<Option<Task>>,
-
-    // The tick at which this node was notified
-    notified_at: AtomicUsize,
-
-    // Next pointer for linked list tracking all active nodes
-    next_all: UnsafeCell<*const Node<U>>,
-
-    // Previous node in linked list tracking all active nodes
-    prev_all: UnsafeCell<*const Node<U>>,
-
-    // Next pointer in readiness queue
-    next_readiness: AtomicPtr<Node<U>>,
-
-    // Whether or not this node is currently in the mpsc queue.
-    queued: AtomicBool,
-
-    // Queue that we'll be enqueued to when notified
-    queue: Weak<Inner<U>>,
-}
-
-/// Returned by `Inner::dequeue`, representing either a dequeue success (with
-/// the dequeued node), an empty list, or an inconsistent state.
-///
-/// The inconsistent state is described in more detail at [1024cores], but
-/// roughly indicates that a node will be ready to dequeue sometime shortly in
-/// the future and the caller should try again soon.
-///
-/// [1024cores]: http://www.1024cores.net/home/lock-free-algorithms/queues/intrusive-mpsc-node-based-queue
-enum Dequeue<U> {
-    Data(*const Node<U>),
-    Empty,
-    Yield,
-    Inconsistent,
-}
-
-/// Wraps a spawned boxed future
-struct Task(Spawn<Box<Future<Item = (), Error = ()>>>);
-
-/// A task that is scheduled. `turn` must be called
-pub struct Scheduled<'a, U: 'a> {
-    task: &'a mut Task,
-    notify: &'a Notify<'a, U>,
-    done: &'a mut bool,
-}
-
-impl<U> Scheduler<U>
-where
-    U: Unpark,
-{
-    /// Constructs a new, empty `Scheduler`
-    ///
-    /// The returned `Scheduler` does not contain any items and, in this
-    /// state, `Scheduler::poll` will return `Ok(Async::Ready(None))`.
-    pub fn new(unpark: U) -> Self {
-        let stub = Arc::new(Node {
-            item: UnsafeCell::new(None),
-            notified_at: AtomicUsize::new(0),
-            next_all: UnsafeCell::new(ptr::null()),
-            prev_all: UnsafeCell::new(ptr::null()),
-            next_readiness: AtomicPtr::new(ptr::null_mut()),
-            queued: AtomicBool::new(true),
-            queue: Weak::new(),
-        });
-        let stub_ptr = &*stub as *const Node<U>;
-        let inner = Arc::new(Inner {
-            unpark,
-            tick_num: AtomicUsize::new(0),
-            head_readiness: AtomicPtr::new(stub_ptr as *mut _),
-            tail_readiness: UnsafeCell::new(stub_ptr),
-            stub: stub,
-        });
-
-        Scheduler {
-            inner: inner,
-            nodes: List::new(),
-        }
-    }
-
-    pub fn notify(&self) -> NotifyHandle {
-        self.inner.clone().into()
-    }
-
-    pub fn schedule(&mut self, item: Box<Future<Item = (), Error = ()>>) {
-        // Get the current scheduler tick
-        let tick_num = self.inner.tick_num.load(SeqCst);
-
-        let node = Arc::new(Node {
-            item: UnsafeCell::new(Some(Task::new(item))),
-            notified_at: AtomicUsize::new(tick_num),
-            next_all: UnsafeCell::new(ptr::null_mut()),
-            prev_all: UnsafeCell::new(ptr::null_mut()),
-            next_readiness: AtomicPtr::new(ptr::null_mut()),
-            queued: AtomicBool::new(true),
-            queue: Arc::downgrade(&self.inner),
-        });
-
-        // Right now our node has a strong reference count of 1. We transfer
-        // ownership of this reference count to our internal linked list
-        // and we'll reclaim ownership through the `unlink` function below.
-        let ptr = self.nodes.push_back(node);
-
-        // We'll need to get the item "into the system" to start tracking it,
-        // e.g. getting its unpark notifications going to us tracking which
-        // items are ready. To do that we unconditionally enqueue it for
-        // polling here.
-        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, 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);
-
-        loop {
-            let node = match unsafe { self.inner.dequeue(Some(tick)) } {
-                Dequeue::Empty => {
-                    return ret;
-                }
-                Dequeue::Yield => {
-                    self.inner.unpark.unpark();
-                    return ret;
-                }
-                Dequeue::Inconsistent => {
-                    thread::yield_now();
-                    continue;
-                }
-                Dequeue::Data(node) => node,
-            };
-
-            ret = true;
-
-            debug_assert!(node != self.inner.stub());
-
-            unsafe {
-                if (*(*node).item.get()).is_none() {
-                    // The node has already been released. However, while it was
-                    // being released, another thread notified it, which
-                    // resulted in it getting pushed into the mpsc channel.
-                    //
-                    // 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;
-                };
-
-                // We're going to need to be very careful if the `poll`
-                // function below panics. We need to (a) not leak memory and
-                // (b) ensure that we still don't have any use-after-frees. To
-                // manage this we do a few things:
-                //
-                // * This "bomb" here will call `release_node` if dropped
-                //   abnormally. That way we'll be sure the memory management
-                //   of the `node` is managed correctly.
-                //
-                // * We unlink the node from our internal queue to preemptively
-                //   assume is is complete (will return Ready or panic), in
-                //   which case we'll want to discard it regardless.
-                //
-                struct Bomb<'a, U: Unpark + 'a> {
-                    borrow: &'a mut Borrow<'a, U>,
-                    enter: &'a mut Enter,
-                    node: Option<Arc<Node<U>>>,
-                }
-
-                impl<'a, U: Unpark> Drop for Bomb<'a, U> {
-                    fn drop(&mut self) {
-                        if let Some(node) = self.node.take() {
-                            self.borrow.enter(self.enter, || release_node(node))
-                        }
-                    }
-                }
-
-                let node = self.nodes.remove(node);
-
-                let mut borrow = Borrow {
-                    id: eid,
-                    scheduler: self,
-                    num_futures,
-                };
-
-                let mut bomb = Bomb {
-                    node: Some(node),
-                    enter: enter,
-                    borrow: &mut borrow,
-                };
-
-                let mut done = false;
-
-                // Now that the bomb holds the node, create a new scope. This
-                // scope ensures that the borrow will go out of scope before we
-                // mutate the node pointer in `bomb` again
-                {
-                    let node = bomb.node.as_ref().unwrap();
-
-                    // Get a reference to the inner future. We already ensured
-                    // that the item `is_some`.
-                    let item = (*node.item.get()).as_mut().unwrap();
-
-                    // Unset queued flag... this must be done before
-                    // polling. This ensures that the item gets
-                    // rescheduled if it is notified **during** a call
-                    // to `poll`.
-                    let prev = (*node).queued.swap(false, SeqCst);
-                    assert!(prev);
-
-                    // Poll the underlying item with the appropriate `notify`
-                    // implementation. This is where a large bit of the unsafety
-                    // starts to stem from internally. The `notify` instance itself
-                    // is basically just our `Arc<Node>` and tracks the mpsc
-                    // queue of ready items.
-                    //
-                    // Critically though `Node` won't actually access `Task`, the
-                    // item, while it's floating around inside of `Task`
-                    // instances. These structs will basically just use `T` to size
-                    // the internal allocation, appropriately accessing fields and
-                    // deallocating the node if need be.
-                    let borrow = &mut *bomb.borrow;
-                    let enter = &mut *bomb.enter;
-                    let notify = Notify(bomb.node.as_ref().unwrap());
-
-                    let mut scheduled = Scheduled {
-                        task: item,
-                        notify: &notify,
-                        done: &mut done,
-                    };
-
-                    if borrow.enter(enter, || scheduled.tick()) {
-                        // we have a borrow of the Runtime, so we know it's not shut down
-                        borrow.num_futures.fetch_sub(2, SeqCst);
-                    }
-                }
-
-                if !done {
-                    // The future is not done, push it back into the "all
-                    // node" list.
-                    let node = bomb.node.take().unwrap();
-                    bomb.borrow.scheduler.nodes.push_back(node);
-                }
-            }
-        }
-    }
-}
-
-impl<'a, U: Unpark> Scheduled<'a, U> {
-    /// Polls the task, returns `true` if the task has completed.
-    pub fn tick(&mut self) -> bool {
-        // Tick the future
-        let ret = match self.task.0.poll_future_notify(self.notify, 0) {
-            Ok(Async::Ready(_)) | Err(_) => true,
-            Ok(Async::NotReady) => false,
-        };
-
-        *self.done = ret;
-        ret
-    }
-}
-
-impl Task {
-    pub fn new(future: Box<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()
-    }
-}
-
-fn release_node<U>(node: Arc<Node<U>>) {
-    // The item is done, try to reset the queued flag. This will prevent
-    // `notify` from doing any work in the item
-    let prev = node.queued.swap(true, SeqCst);
-
-    // Drop the item, even if it hasn't finished yet. This is safe
-    // because we're dropping the item on the thread that owns
-    // `Scheduler`, which correctly tracks T's lifetimes and such.
-    unsafe {
-        drop((*node.item.get()).take());
-    }
-
-    // If the queued flag was previously set then it means that this node
-    // is still in our internal mpsc queue. We then transfer ownership
-    // of our reference count to the mpsc queue, and it'll come along and
-    // free it later, noticing that the item is `None`.
-    //
-    // If, however, the queued flag was *not* set then we're safe to
-    // release our reference count on the internal node. The queued flag
-    // was set above so all item `enqueue` operations will not actually
-    // enqueue the node, so our node will never see the mpsc queue again.
-    // The node itself will be deallocated once all reference counts have
-    // been dropped by the various owning tasks elsewhere.
-    if prev {
-        mem::forget(node);
-    }
-}
-
-impl<U> Debug for Scheduler<U> {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        write!(fmt, "Scheduler {{ ... }}")
-    }
-}
-
-impl<U> Drop for Scheduler<U> {
-    fn drop(&mut self) {
-        // When a `Scheduler` is dropped we want to drop all items associated
-        // with it. At the same time though there may be tons of `Task` handles
-        // flying around which contain `Node` references inside them. We'll
-        // let those naturally get deallocated when the `Task` itself goes out
-        // of scope or gets notified.
-        while let Some(node) = self.nodes.pop_front() {
-            release_node(node);
-        }
-
-        // Note that at this point we could still have a bunch of nodes in the
-        // mpsc queue. None of those nodes, however, have items associated
-        // with them so they're safe to destroy on any thread. At this point
-        // the `Scheduler` struct, the owner of the one strong reference
-        // to `Inner` will drop the strong reference. At that point
-        // whichever thread releases the strong refcount last (be it this
-        // thread or some other thread as part of an `upgrade`) will clear out
-        // the mpsc queue and free all remaining nodes.
-        //
-        // While that freeing operation isn't guaranteed to happen here, it's
-        // guaranteed to happen "promptly" as no more "blocking work" will
-        // happen while there's a strong refcount held.
-    }
-}
-
-impl<U> Inner<U> {
-    /// The enqueue function from the 1024cores intrusive MPSC queue algorithm.
-    fn enqueue(&self, node: *const Node<U>) {
-        unsafe {
-            debug_assert!((*node).queued.load(Relaxed));
-
-            // This action does not require any coordination
-            (*node).next_readiness.store(ptr::null_mut(), Relaxed);
-
-            // Note that these atomic orderings come from 1024cores
-            let node = node as *mut _;
-            let prev = self.head_readiness.swap(node, AcqRel);
-            (*prev).next_readiness.store(node, Release);
-        }
-    }
-
-    /// 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
-    /// can call this) to be guaranteed elsewhere.
-    unsafe fn dequeue(&self, tick: Option<usize>) -> Dequeue<U> {
-        let mut tail = *self.tail_readiness.get();
-        let mut next = (*tail).next_readiness.load(Acquire);
-
-        if tail == self.stub() {
-            if next.is_null() {
-                return Dequeue::Empty;
-            }
-
-            *self.tail_readiness.get() = next;
-            tail = next;
-            next = (*next).next_readiness.load(Acquire);
-        }
-
-        if let Some(tick) = tick {
-            let actual = (*tail).notified_at.load(SeqCst);
-
-            // Only dequeue if the node was not scheduled during the current
-            // tick.
-            if actual == tick {
-                // Only doing the check above **should** be enough in
-                // practice. However, technically there is a potential for
-                // deadlocking if there are `usize::MAX` ticks while the thread
-                // scheduling the task is frozen.
-                //
-                // If, for some reason, this is not enough, calling `unpark`
-                // here will resolve the issue.
-                return Dequeue::Yield;
-            }
-        }
-
-        if !next.is_null() {
-            *self.tail_readiness.get() = next;
-            debug_assert!(tail != self.stub());
-            return Dequeue::Data(tail);
-        }
-
-        if self.head_readiness.load(Acquire) as *const _ != tail {
-            return Dequeue::Inconsistent;
-        }
-
-        self.enqueue(self.stub());
-
-        next = (*tail).next_readiness.load(Acquire);
-
-        if !next.is_null() {
-            *self.tail_readiness.get() = next;
-            return Dequeue::Data(tail);
-        }
-
-        Dequeue::Inconsistent
-    }
-
-    fn stub(&self) -> *const Node<U> {
-        &*self.stub
-    }
-}
-
-impl<U> Drop for Inner<U> {
-    fn drop(&mut self) {
-        // Once we're in the destructor for `Inner` we need to clear out the
-        // mpsc queue of nodes if there's anything left in there.
-        //
-        // Note that each node has a strong reference count associated with it
-        // which is owned by the mpsc queue. All nodes should have had their
-        // items dropped already by the `Scheduler` destructor above,
-        // so we're just pulling out nodes and dropping their refcounts.
-        unsafe {
-            loop {
-                match self.dequeue(None) {
-                    Dequeue::Empty => break,
-                    Dequeue::Yield => unreachable!(),
-                    Dequeue::Inconsistent => abort("inconsistent in drop"),
-                    Dequeue::Data(ptr) => drop(ptr2arc(ptr)),
-                }
-            }
-        }
-    }
-}
-
-impl<U> List<U> {
-    fn new() -> Self {
-        List {
-            len: 0,
-            head: ptr::null_mut(),
-            tail: ptr::null_mut(),
-        }
-    }
-
-    /// 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);
-
-        unsafe {
-            // Point to the current last node in the list
-            *(*ptr).prev_all.get() = self.tail;
-            *(*ptr).next_all.get() = ptr::null_mut();
-
-            if !self.tail.is_null() {
-                *(*self.tail).next_all.get() = ptr;
-                self.tail = ptr;
-            } else {
-                // This is the first node
-                self.tail = ptr;
-                self.head = ptr;
-            }
-        }
-
-        self.len += 1;
-
-        return ptr;
-    }
-
-    /// Pop an element from the front of the list
-    fn pop_front(&mut self) -> Option<Arc<Node<U>>> {
-        if self.head.is_null() {
-            // The list is empty
-            return None;
-        }
-
-        self.len -= 1;
-
-        unsafe {
-            // Convert the ptr to Arc<_>
-            let node = ptr2arc(self.head);
-
-            // Update the head pointer
-            self.head = *node.next_all.get();
-
-            // If the pointer is null, then the list is empty
-            if self.head.is_null() {
-                self.tail = ptr::null_mut();
-            } else {
-                *(*self.head).prev_all.get() = ptr::null_mut();
-            }
-
-            Some(node)
-        }
-    }
-
-    /// Remove a specific node
-    unsafe fn remove(&mut self, node: *const Node<U>) -> Arc<Node<U>> {
-        let node = ptr2arc(node);
-        let next = *node.next_all.get();
-        let prev = *node.prev_all.get();
-        *node.next_all.get() = ptr::null_mut();
-        *node.prev_all.get() = ptr::null_mut();
-
-        if !next.is_null() {
-            *(*next).prev_all.get() = prev;
-        } else {
-            self.tail = prev;
-        }
-
-        if !prev.is_null() {
-            *(*prev).next_all.get() = next;
-        } else {
-            self.head = next;
-        }
-
-        self.len -= 1;
-
-        return node;
-    }
-}
-
-impl<'a, U> Clone for Notify<'a, U> {
-    fn clone(&self) -> Self {
-        Notify(self.0)
-    }
-}
-
-impl<'a, U> fmt::Debug for Notify<'a, U> {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        fmt.debug_struct("Notify").finish()
-    }
-}
-
-impl<'a, U: Unpark> From<Notify<'a, U>> for NotifyHandle {
-    fn from(handle: Notify<'a, U>) -> NotifyHandle {
-        unsafe {
-            let ptr = handle.0.clone();
-            let ptr = mem::transmute::<Arc<Node<U>>, *mut ArcNode<U>>(ptr);
-            NotifyHandle::new(hide_lt(ptr))
-        }
-    }
-}
-
-struct ArcNode<U>(PhantomData<U>);
-
-// We should never touch `Task` on any thread other than the one owning
-// `Scheduler`, so this should be a safe operation.
-unsafe impl<U: Sync + Send> Send for ArcNode<U> {}
-unsafe impl<U: Sync + Send> Sync for ArcNode<U> {}
-
-impl<U: Unpark> executor::Notify for ArcNode<U> {
-    fn notify(&self, _id: usize) {
-        unsafe {
-            let me: *const ArcNode<U> = self;
-            let me: *const *const ArcNode<U> = &me;
-            let me = me as *const Arc<Node<U>>;
-            Node::notify(&*me)
-        }
-    }
-}
-
-unsafe impl<U: Unpark> UnsafeNotify for ArcNode<U> {
-    unsafe fn clone_raw(&self) -> NotifyHandle {
-        let me: *const ArcNode<U> = self;
-        let me: *const *const ArcNode<U> = &me;
-        let me = &*(me as *const Arc<Node<U>>);
-        Notify(me).into()
-    }
-
-    unsafe fn drop_raw(&self) {
-        let mut me: *const ArcNode<U> = self;
-        let me = &mut me as *mut *const ArcNode<U> as *mut Arc<Node<U>>;
-        ptr::drop_in_place(me);
-    }
-}
-
-unsafe fn hide_lt<U: Unpark>(p: *mut ArcNode<U>) -> *mut UnsafeNotify {
-    mem::transmute(p as *mut UnsafeNotify)
-}
-
-impl<U: Unpark> Node<U> {
-    fn notify(me: &Arc<Node<U>>) {
-        let inner = match me.queue.upgrade() {
-            Some(inner) => inner,
-            None => return,
-        };
-
-        // It's our job to notify the node that it's ready to get polled,
-        // meaning that we need to enqueue it into the readiness queue. To
-        // do this we flag that we're ready to be queued, and if successful
-        // we then do the literal queueing operation, ensuring that we're
-        // only queued once.
-        //
-        // Once the node is inserted we be sure to notify the parent task,
-        // as it'll want to come along and pick up our node now.
-        //
-        // Note that we don't change the reference count of the node here,
-        // we're just enqueueing the raw pointer. The `Scheduler`
-        // implementation guarantees that if we set the `queued` flag true that
-        // there's a reference count held by the main `Scheduler` queue
-        // still.
-        let prev = me.queued.swap(true, SeqCst);
-        if !prev {
-            // Get the current scheduler tick
-            let tick_num = inner.tick_num.load(SeqCst);
-            me.notified_at.store(tick_num, SeqCst);
-
-            inner.enqueue(&**me);
-            inner.unpark.unpark();
-        }
-    }
-}
-
-impl<U> Drop for Node<U> {
-    fn drop(&mut self) {
-        // Currently a `Node` is sent across all threads for any lifetime,
-        // regardless of `T`. This means that for memory safety we can't
-        // actually touch `T` at any time except when we have a reference to the
-        // `Scheduler` itself.
-        //
-        // Consequently it *should* be the case that we always drop items from
-        // the `Scheduler` instance, but this is a bomb in place to catch
-        // any bugs in that logic.
-        unsafe {
-            if (*self.item.get()).is_some() {
-                abort("item still here when dropping");
-            }
-        }
-    }
-}
-
-fn arc2ptr<T>(ptr: Arc<T>) -> *const T {
-    let addr = &*ptr as *const T;
-    mem::forget(ptr);
-    return addr;
-}
-
-unsafe fn ptr2arc<T>(ptr: *const T) -> Arc<T> {
-    let anchor = mem::transmute::<usize, Arc<T>>(0x10);
-    let addr = &*anchor as *const T;
-    mem::forget(anchor);
-    let offset = addr as isize - 0x10;
-    mem::transmute::<isize, Arc<T>>(ptr as isize - offset)
-}
-
-fn abort(s: &str) -> ! {
-    struct DoublePanic;
-
-    impl Drop for DoublePanic {
-        fn drop(&mut self) {
-            panic!("panicking twice to abort the program");
-        }
-    }
-
-    let _bomb = DoublePanic;
-    panic!("{}", s);
-}
@@ -1,837 +0,0 @@
-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<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<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<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<Future<Item = (), Error = ()>>) + 'static,
-        G: Fn(&mut CurrentThread, Box<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<Future<Item = (), Error = ()>>) + 'static,
-        G: Fn(&mut CurrentThread, Box<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<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<Future<Item = (), Error = ()>>) + 'static,
-        G: Fn(&mut CurrentThread, Box<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(())
-}
@@ -1,38 +0,0 @@
-# 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.
-
-# 0.1.0 (March 09, 2018)
-
-* Initial release
@@ -1,28 +0,0 @@
-[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.7"
-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"
-authors = ["Carl Lerche <[email protected]>"]
-description = """
-Future execution primitives
-"""
-keywords = ["futures", "tokio"]
-categories = ["concurrency", "asynchronous"]
-
-[dependencies]
-crossbeam-utils = "0.6.2"
-futures = "0.1.19"
-
-[dev-dependencies]
-tokio = "0.1.18"
@@ -1,25 +0,0 @@
-Copyright (c) 2019 Tokio Contributors
-
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
@@ -1,47 +0,0 @@
-# tokio-executor
-
-Task execution related traits and utilities.
-
-[Documentation](https://docs.rs/tokio-executor/0.1.7/tokio_executor)
-
-## Overview
-
-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 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.
-
-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.
-
-* [`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.
-
-* [`DefaultExecutor`] spawns tasks onto the default executor for the current
-  context.
-
-* [`Park`] abstracts over blocking and unblocking the current thread.
-
-[`Executor`]: https://docs.rs/tokio-executor/0.1.7/tokio_executor/trait.Executor.html
-[`enter`]: https://docs.rs/tokio-executor/0.1.7/tokio_executor/fn.enter.html
-[`DefaultExecutor`]: https://docs.rs/tokio-executor/0.1.7/tokio_executor/struct.DefaultExecutor.html
-[`Park`]: https://docs.rs/tokio-executor/0.1.7/tokio_executor/park/trait.Park.html
-
-## 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.
@@ -1,128 +0,0 @@
-use std::cell::Cell;
-use std::error::Error;
-use std::fmt;
-use std::prelude::v1::*;
-
-use futures::{self, Future};
-
-thread_local!(static ENTERED: Cell<bool> = Cell::new(false));
-
-/// Represents an executor context.
-///
-/// For more details, see [`enter` documentation](fn.enter.html)
-pub struct Enter {
-    on_exit: Vec<Box<Callback>>,
-    permanent: bool,
-}
-
-/// An error returned by `enter` if an execution scope has already been
-/// entered.
-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.
-///
-/// Executor implementations should call this function before blocking the
-/// thread. If `None` is returned, the executor should fail by panicking or
-/// taking some other action without blocking the current thread. This prevents
-/// deadlocks due to multiple executors competing for the same thread.
-///
-/// # Error
-///
-/// Returns an error if the current thread is already marked
-pub fn enter() -> Result<Enter, EnterError> {
-    ENTERED.with(|c| {
-        if c.get() {
-            Err(EnterError { _a: () })
-        } else {
-            c.set(true);
-
-            Ok(Enter {
-                on_exit: Vec::new(),
-                permanent: false,
-            })
-        }
-    })
-}
-
-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,
-    {
-        self.on_exit.push(Box::new(f));
-    }
-
-    /// Treat the remainder of execution on this thread as part of an
-    /// executor; used mostly for thread pool worker threads.
-    ///
-    /// All registered `on_exit` callbacks are *dropped* without being
-    /// invoked.
-    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 {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_struct("Enter").finish()
-    }
-}
-
-impl Drop for Enter {
-    fn drop(&mut self) {
-        ENTERED.with(|c| {
-            assert!(c.get());
-
-            if self.permanent {
-                return;
-            }
-
-            for callback in self.on_exit.drain(..) {
-                callback.call();
-            }
-
-            c.set(false);
-        });
-    }
-}
-
-trait Callback: 'static {
-    fn call(self: Box<Self>);
-}
-
-impl<F: FnOnce() + 'static> Callback for F {
-    fn call(self: Box<Self>) {
-        (*self)()
-    }
-}
@@ -1,50 +0,0 @@
-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"
-    }
-}
@@ -1,151 +0,0 @@
-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<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<Future<Item = (), Error = ()> + Send>,
-    ) -> Result<(), SpawnError> {
-        (**self).spawn(future)
-    }
-
-    fn status(&self) -> Result<(), SpawnError> {
-        (**self).status()
-    }
-}
@@ -1,240 +0,0 @@
-use super::{Enter, Executor, SpawnError};
-
-use futures::{future, Future};
-
-use std::cell::Cell;
-
-/// Executes futures on the default executor for the current execution context.
-///
-/// `DefaultExecutor` implements `Executor` and can be used to spawn futures
-/// without referencing a specific executor.
-///
-/// When an executor starts, it sets the `DefaultExecutor` handle to point to an
-/// executor (usually itself) that is used to spawn new tasks.
-///
-/// The current `DefaultExecutor` reference is tracked using a thread-local
-/// variable and is set using `tokio_executor::with_default`
-#[derive(Debug, Clone)]
-pub struct DefaultExecutor {
-    _dummy: (),
-}
-
-impl DefaultExecutor {
-    /// Returns a handle to the default executor for the current context.
-    ///
-    /// Futures may be spawned onto the default executor using this handle.
-    ///
-    /// The returned handle will reference whichever executor is configured as
-    /// 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 { _dummy: () }
-    }
-
-    #[inline]
-    fn with_current<F: FnOnce(&mut 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,
-            },
-        )
-    }
-}
-
-#[derive(Clone, Copy)]
-enum State {
-    // default executor not defined
-    Empty,
-    // default executor is defined and ready to be used
-    Ready(*mut 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> {
-        DefaultExecutor::with_current(|executor| executor.spawn(future))
-            .unwrap_or_else(|| Err(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(())
-    }
-}
-
-// ===== global spawn fns =====
-
-/// Submits a future for execution on the default executor -- usually a
-/// threadpool.
-///
-/// Futures are lazy constructs. When they are defined, no work happens. In
-/// order for the logic defined by the future to be run, the future must be
-/// spawned on an executor. This function is the easiest way to do so.
-///
-/// This function must be called from an execution context, i.e. from a future
-/// that has been already spawned onto an executor.
-///
-/// Once spawned, the future will execute. The details of how that happens is
-/// left up to the executor instance. If the executor is a thread pool, the
-/// future will be pushed onto a queue that a worker thread polls from. If the
-/// executor is a "current thread" executor, the future might be polled
-/// immediately from within the call to `spawn` or it might be pushed onto an
-/// internal queue.
-///
-/// # 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 the
-/// `DefaultExecutor` handle directly.
-///
-/// # Examples
-///
-/// ```rust
-/// # extern crate futures;
-/// # extern crate tokio_executor;
-/// # use tokio_executor::spawn;
-/// # pub fn dox() {
-/// use futures::future::lazy;
-///
-/// spawn(lazy(|| {
-///     println!("running on the default executor");
-///     Ok(())
-/// }));
-/// # }
-/// # pub fn main() {}
-/// ```
-pub fn spawn<T>(future: T)
-where
-    T: Future<Item = (), Error = ()> + Send + 'static,
-{
-    DefaultExecutor::current().spawn(Box::new(future)).unwrap()
-}
-
-/// Set the default executor for the duration of the closure
-///
-/// # Panics
-///
-/// 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,
-{
-    EXECUTOR.with(|cell| {
-        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<State>);
-
-        impl<'a> Drop for Reset<'a> {
-            fn drop(&mut self) {
-                self.0.set(State::Empty);
-            }
-        }
-
-        let _reset = Reset(cell);
-
-        // While scary, this is safe. The function takes a
-        // `&mut Executor`, which guarantees that the reference lives for the
-        // duration of `with_default`.
-        //
-        // Because we are always clearing the TLS value at the end of the
-        // function, we can cast the reference to 'static which thread-local
-        // cells require.
-        let executor = unsafe { hide_lt(executor as &mut _ as *mut _) };
-
-        cell.set(State::Ready(executor));
-
-        f(enter)
-    })
-}
-
-unsafe fn hide_lt<'a>(p: *mut (Executor + 'a)) -> *mut (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())
-    }
-}
@@ -1,68 +0,0 @@
-#![deny(missing_docs, missing_debug_implementations, warnings)]
-#![doc(html_root_url = "https://docs.rs/tokio-executor/0.1.7")]
-
-//! Task execution related traits and 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 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.
-//!
-//! This crate provides traits and utilities that are necessary for building an
-//! executor, including:
-//!
-//! * The [`Executor`] trait spawns future object onto an executor.
-//!
-//! * 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.
-//!
-//! * [`DefaultExecutor`] spawns tasks onto the default executor for the current
-//!   context.
-//!
-//! * [`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
-
-extern crate crossbeam_utils;
-extern crate futures;
-
-mod enter;
-mod error;
-mod executor;
-mod global;
-pub mod park;
-mod typed;
-
-pub use enter::{enter, Enter, EnterError};
-pub use error::SpawnError;
-pub use executor::Executor;
-pub use global::{spawn, with_default, DefaultExecutor};
-pub use typed::TypedExecutor;
@@ -1,226 +0,0 @@
-//! Abstraction over blocking and unblocking the current thread.
-//!
-//! Provides an abstraction over blocking the current thread. This is similar to
-//! the park / unpark constructs provided by [`std`] but made generic. This
-//! allows embedding custom functionality to perform when the thread is blocked.
-//!
-//! A blocked [`Park`][p] instance is unblocked by calling [`unpark`] on its
-//! [`Unpark`][up] handle.
-//!
-//! The [`ParkThread`] struct implements [`Park`][p] using
-//! [`thread::park`][`std`] to put the thread to sleep. The Tokio reactor also
-//! implements park, but uses [`mio::Poll`][mio] to block the thread instead.
-//!
-//! The [`Park`][p] trait is composable. A timer implementation might decorate a
-//! [`Park`][p] implementation by checking if any timeouts have elapsed after
-//! the inner [`Park`][p] implementation unblocks.
-//!
-//! # Model
-//!
-//! Conceptually, each [`Park`][p] instance has an associated token, which is
-//! initially not present:
-//!
-//! * The [`park`] method blocks the current thread unless or until the token
-//!   is available, at which point it atomically consumes the token.
-//! * The [`unpark`] method atomically makes the token available if it wasn't
-//!   already.
-//!
-//! Some things to note:
-//!
-//! * If [`unpark`] is called before [`park`], the next call to [`park`] will
-//! **not** block the thread.
-//! * **Spurious** wakeups are permitted, i.e., the [`park`] method may unblock
-//!   even if [`unpark`] was not called.
-//! * [`park_timeout`] does the same as [`park`] but allows specifying a maximum
-//!   time to block the thread for.
-//!
-//! [`std`]: https://doc.rust-lang.org/std/thread/fn.park.html
-//! [`thread::park`]: https://doc.rust-lang.org/std/thread/fn.park.html
-//! [`ParkThread`]: struct.ParkThread.html
-//! [p]: trait.Park.html
-//! [`park`]: trait.Park.html#tymethod.park
-//! [`park_timeout`]: trait.Park.html#tymethod.park_timeout
-//! [`unpark`]: trait.Unpark.html#tymethod.unpark
-//! [up]: trait.Unpark.html
-//! [mio]: https://docs.rs/mio/0.6/mio/struct.Poll.html
-
-use std::marker::PhantomData;
-use std::rc::Rc;
-use std::sync::Arc;
-use std::time::Duration;
-
-use crossbeam_utils::sync::{Parker, Unparker};
-
-/// Block the current thread.
-///
-/// See [module documentation][mod] for more details.
-///
-/// [mod]: ../index.html
-pub trait Park {
-    /// Unpark handle type for the `Park` implementation.
-    type Unpark: Unpark;
-
-    /// Error returned by `park`
-    type Error;
-
-    /// Get a new `Unpark` handle associated with this `Park` instance.
-    fn unpark(&self) -> Self::Unpark;
-
-    /// Block the current thread unless or until the token is available.
-    ///
-    /// A call to `park` does not guarantee that the thread will remain blocked
-    /// forever, and callers should be prepared for this possibility. This
-    /// function may wakeup spuriously for any reason.
-    ///
-    /// See [module documentation][mod] for more details.
-    ///
-    /// # Panics
-    ///
-    /// This function **should** not panic, but ultimately, panics are left as
-    /// an implementation detail. Refer to the documentation for the specific
-    /// `Park` implementation
-    ///
-    /// [mod]: ../index.html
-    fn park(&mut self) -> Result<(), Self::Error>;
-
-    /// Park the current thread for at most `duration`.
-    ///
-    /// This function is the same as `park` but allows specifying a maximum time
-    /// to block the thread for.
-    ///
-    /// Same as `park`, there is no guarantee that the thread will remain
-    /// blocked for any amount of time. Spurious wakeups are permitted for any
-    /// reason.
-    ///
-    /// See [module documentation][mod] for more details.
-    ///
-    /// # Panics
-    ///
-    /// This function **should** not panic, but ultimately, panics are left as
-    /// an implementation detail. Refer to the documentation for the specific
-    /// `Park` implementation
-    ///
-    /// [mod]: ../index.html
-    fn park_timeout(&mut self, duration: Duration) -> Result<(), Self::Error>;
-}
-
-/// Unblock a thread blocked by the associated [`Park`] instance.
-///
-/// See [module documentation][mod] for more details.
-///
-/// [mod]: ../index.html
-/// [`Park`]: trait.Park.html
-pub trait Unpark: Sync + Send + 'static {
-    /// Unblock a thread that is blocked by the associated `Park` handle.
-    ///
-    /// Calling `unpark` atomically makes available the unpark token, if it is
-    /// not already available.
-    ///
-    /// See [module documentation][mod] for more details.
-    ///
-    /// # Panics
-    ///
-    /// This function **should** not panic, but ultimately, panics are left as
-    /// an implementation detail. Refer to the documentation for the specific
-    /// `Unpark` implementation
-    ///
-    /// [mod]: ../index.html
-    fn unpark(&self);
-}
-
-impl Unpark for Box<Unpark> {
-    fn unpark(&self) {
-        (**self).unpark()
-    }
-}
-
-impl Unpark for Arc<Unpark> {
-    fn unpark(&self) {
-        (**self).unpark()
-    }
-}
-
-/// Blocks the current thread using a condition variable.
-///
-/// Implements the [`Park`] functionality by using a condition variable. An
-/// atomic variable is also used to avoid using the condition variable if
-/// possible.
-///
-/// The condition variable is cached in a thread-local variable and is shared
-/// across all `ParkThread` instances created on the same thread. This also
-/// means that an instance of `ParkThread` might be unblocked by a handle
-/// associated with a different `ParkThread` instance.
-#[derive(Debug)]
-pub struct ParkThread {
-    _anchor: PhantomData<Rc<()>>,
-}
-
-/// Error returned by [`ParkThread`]
-///
-/// This currently is never returned, but might at some point in the future.
-///
-/// [`ParkThread`]: struct.ParkThread.html
-#[derive(Debug)]
-pub struct ParkError {
-    _p: (),
-}
-
-/// Unblocks a thread that was blocked by `ParkThread`.
-#[derive(Clone, Debug)]
-pub struct UnparkThread {
-    inner: Unparker,
-}
-
-thread_local! {
-    static CURRENT_PARKER: Parker = Parker::new();
-}
-
-// ===== impl ParkThread =====
-
-impl ParkThread {
-    /// Create a new `ParkThread` handle for the current thread.
-    ///
-    /// This type cannot be moved to other threads, so it should be created on
-    /// the thread that the caller intends to park.
-    pub fn new() -> ParkThread {
-        ParkThread {
-            _anchor: PhantomData,
-        }
-    }
-
-    /// Get a reference to the `ParkThread` handle for this thread.
-    fn with_current<F, R>(&self, f: F) -> R
-    where
-        F: FnOnce(&Parker) -> R,
-    {
-        CURRENT_PARKER.with(|inner| f(inner))
-    }
-}
-
-impl Park for ParkThread {
-    type Unpark = UnparkThread;
-    type Error = ParkError;
-
-    fn unpark(&self) -> Self::Unpark {
-        let inner = self.with_current(|inner| inner.unparker().clone());
-        UnparkThread { inner }
-    }
-
-    fn park(&mut self) -> Result<(), Self::Error> {
-        self.with_current(|inner| inner.park());
-        Ok(())
-    }
-
-    fn park_timeout(&mut self, duration: Duration) -> Result<(), Self::Error> {
-        self.with_current(|inner| inner.park_timeout(duration));
-        Ok(())
-    }
-}
-
-// ===== impl UnparkThread =====
-
-impl Unpark for UnparkThread {
-    fn unpark(&self) {
-        self.inner.unpark();
-    }
-}
@@ -1,181 +0,0 @@
-use SpawnError;
-
-/// A value that spawns futures of a specific type.
-///
-/// The trait is generic over `T`: the type of future that can be spawened. This
-/// is useful for implementing an executor that is only able to spawn a specific
-/// type of future.
-///
-/// The [`spawn`] function is used to submit the future to the executor. Once
-/// submitted, the executor takes ownership of the future and becomes
-/// responsible for driving the future to completion.
-///
-/// This trait is useful as a bound for applications and libraries in order to
-/// be generic over futures that are `Send` vs. `!Send`.
-///
-/// # Examples
-///
-/// Consider a function that provides an API for draining a `Stream` in the
-/// background. To do this, a task must be spawned to perform the draining. As
-/// such, the function takes a stream and an executor on which the background
-/// task is spawned.
-///
-/// ```rust
-/// #[macro_use]
-/// extern crate futures;
-/// extern crate tokio;
-///
-/// use futures::{Future, Stream, Poll};
-/// use tokio::executor::TypedExecutor;
-/// use tokio::sync::oneshot;
-///
-/// pub fn drain<T, E>(stream: T, executor: &mut E)
-///     -> impl Future<Item = (), Error = ()>
-/// where
-///     T: Stream,
-///     E: TypedExecutor<Drain<T>>
-/// {
-///     let (tx, rx) = oneshot::channel();
-///
-///     executor.spawn(Drain {
-///         stream,
-///         tx: Some(tx),
-///     }).unwrap();
-///
-///     rx.map_err(|_| ())
-/// }
-///
-/// // The background task
-/// pub struct Drain<T: Stream> {
-///     stream: T,
-///     tx: Option<oneshot::Sender<()>>,
-/// }
-///
-/// impl<T: Stream> Future for Drain<T> {
-///     type Item = ();
-///     type Error = ();
-///
-///     fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-///         loop {
-///             let item = try_ready!(
-///                 self.stream.poll()
-///                     .map_err(|_| ())
-///             );
-///
-///             if item.is_none() { break; }
-///         }
-///
-///         self.tx.take().unwrap().send(()).map_err(|_| ());
-///         Ok(().into())
-///     }
-/// }
-/// # pub fn main() {}
-/// ```
-///
-/// By doing this, the `drain` fn can accept a stream that is `!Send` as long as
-/// the supplied executor is able to spawn `!Send` types.
-pub trait TypedExecutor<T> {
-    /// Spawns a future to run on this executor.
-    ///
-    /// `future` is passed to the executor, which will begin running it. The
-    /// executor takes ownership of the future and becomes responsible for
-    /// driving the future to completion.
-    ///
-    /// # 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::TypedExecutor;
-    /// # use futures::{Future, Poll};
-    /// fn example<T>(my_executor: &mut T)
-    /// where
-    ///     T: TypedExecutor<MyFuture>,
-    /// {
-    ///     my_executor.spawn(MyFuture).unwrap();
-    /// }
-    ///
-    /// struct MyFuture;
-    ///
-    /// impl Future for MyFuture {
-    ///     type Item = ();
-    ///     type Error = ();
-    ///
-    ///     fn poll(&mut self) -> Poll<(), ()> {
-    ///         println!("running on the executor");
-    ///         Ok(().into())
-    ///     }
-    /// }
-    /// # fn main() {}
-    /// ```
-    fn spawn(&mut self, future: T) -> 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::TypedExecutor;
-    /// # use futures::{Future, Poll};
-    /// fn example<T>(my_executor: &mut T)
-    /// where
-    ///     T: TypedExecutor<MyFuture>,
-    /// {
-    ///     if my_executor.status().is_ok() {
-    ///         my_executor.spawn(MyFuture).unwrap();
-    ///     } else {
-    ///         println!("the executor is not in a good state");
-    ///     }
-    /// }
-    ///
-    /// struct MyFuture;
-    ///
-    /// impl Future for MyFuture {
-    ///     type Item = ();
-    ///     type Error = ();
-    ///
-    ///     fn poll(&mut self) -> Poll<(), ()> {
-    ///         println!("running on the executor");
-    ///         Ok(().into())
-    ///     }
-    /// }
-    /// # fn main() {}
-    /// ```
-    fn status(&self) -> Result<(), SpawnError> {
-        Ok(())
-    }
-}
-
-impl<E, T> TypedExecutor<T> for Box<E>
-where
-    E: TypedExecutor<T>,
-{
-    fn spawn(&mut self, future: T) -> Result<(), SpawnError> {
-        (**self).spawn(future)
-    }
-
-    fn status(&self) -> Result<(), SpawnError> {
-        (**self).status()
-    }
-}
@@ -1,29 +0,0 @@
-extern crate futures;
-extern crate tokio_executor;
-
-use futures::{future::lazy, Future};
-use tokio_executor::DefaultExecutor;
-
-mod out_of_executor_context {
-    use super::*;
-    use tokio_executor::Executor;
-
-    fn test<F, E>(spawn: F)
-    where
-        F: Fn(Box<Future<Item = (), Error = ()> + Send>) -> Result<(), E>,
-    {
-        let res = spawn(Box::new(lazy(|| Ok(()))));
-        assert!(res.is_err());
-    }
-
-    #[test]
-    fn spawn() {
-        test(|f| DefaultExecutor::current().spawn(f));
-    }
-
-    #[test]
-    fn execute() {
-        use futures::future::Executor as FuturesExecutor;
-        test(|f| DefaultExecutor::current().execute(f));
-    }
-}
@@ -1,32 +0,0 @@
-# 0.1.6 (March 1, 2019)
-
-### Added
- File::try_clone() (#850).
- Async equivalent of read / write file helpers being added to `std` (#896).
-
-# 0.1.5 (January 6, 2019)
-
-* Add examples to `File` API docs (#786).
-
-# 0.1.4 (October 23, 2018)
-
-* Provide `File::from_std` (#696).
-
-# 0.1.3 (August 6, 2018)
-
-* Add async equivalents to most of `std::fs` (#494).
-
-# 0.1.2 (July 11, 2018)
-
-* Add `metadata` and `File::metadata` ([#433](https://github.com/tokio-rs/tokio/pull/433), [#385](https://github.com/tokio-rs/tokio/pull/385))
-* Add `File::seek` ([#434](https://github.com/tokio-rs/tokio/pull/434))
-
-# 0.1.1 (June 13, 2018)
-
-* Add `OpenOptions` ([#390](https://github.com/tokio-rs/tokio/pull/390))
-* Add `into_std` to `File` ([#403](https://github.com/tokio-rs/tokio/pull/403))
-* Use `tokio-codec` in examples
-
-# 0.1.0 (May 2, 2018)
-
-* Initial release
@@ -1,35 +0,0 @@
-[package]
-name = "tokio-fs"
-# 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"
-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-fs/0.1.6/tokio_fs"
-description = """
-Filesystem API for Tokio.
-"""
-keywords = ["tokio", "futures", "fs", "file", "async"]
-categories = ["asynchronous", "network-programming", "filesystem"]
-
-[dependencies]
-futures = "0.1.21"
-tokio-threadpool = "0.1.3"
-tokio-io = "0.1.6"
-
-[dev-dependencies]
-rand = "0.6"
-tempfile = "3"
-tempdir = "0.3"
-tokio-io = "0.1.6"
-tokio-codec = "0.1.0"
-tokio = "0.1.7"
@@ -1,25 +0,0 @@
-Copyright (c) 2019 Tokio Contributors
-
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
@@ -1,19 +0,0 @@
-# Tokio FS
-
-Asynchronous filesystem manipulation operations (and stdin, stdout, stderr).
-
-[Documentation](https://docs.rs/tokio-fs/0.1.6/tokio_fs)
-
-## Overview
-
-This crate provides filesystem manipulation facilities for usage with Tokio.
-
-## 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.
@@ -1,47 +0,0 @@
-//! Echo everything received on STDIN to STDOUT.
-#![deny(deprecated, warnings)]
-
-extern crate futures;
-extern crate tokio_codec;
-extern crate tokio_fs;
-extern crate tokio_threadpool;
-
-use tokio_codec::{FramedRead, FramedWrite, LinesCodec};
-use tokio_fs::{stderr, stdin, stdout};
-use tokio_threadpool::Builder;
-
-use futures::{Future, Sink, Stream};
-
-use std::io;
-
-pub fn main() -> Result<(), Box<std::error::Error>> {
-    let pool = Builder::new().pool_size(1).build();
-
-    pool.spawn({
-        let input = FramedRead::new(stdin(), LinesCodec::new());
-
-        let output = FramedWrite::new(stdout(), LinesCodec::new()).with(|line: String| {
-            let mut out = "OUT: ".to_string();
-            out.push_str(&line);
-            Ok::<_, io::Error>(out)
-        });
-
-        let error = FramedWrite::new(stderr(), LinesCodec::new()).with(|line: String| {
-            let mut out = "ERR: ".to_string();
-            out.push_str(&line);
-            Ok::<_, io::Error>(out)
-        });
-
-        let dst = output.fanout(error);
-
-        input
-            .forward(dst)
-            .map(|_| ())
-            .map_err(|e| panic!("io error = {:?}", e))
-    });
-
-    pool.shutdown_on_idle()
-        .wait()
-        .map_err(|_| "failed to shutdown the thread pool")?;
-    Ok(())
-}
@@ -1,44 +0,0 @@
-use std::fs;
-use std::io;
-use std::path::Path;
-
-use futures::{Future, Poll};
-
-/// Creates a new, empty directory at the provided path
-///
-/// This is an async version of [`std::fs::create_dir`][std]
-///
-/// [std]: https://doc.rust-lang.org/std/fs/fn.create_dir.html
-pub fn create_dir<P: AsRef<Path>>(path: P) -> CreateDirFuture<P> {
-    CreateDirFuture::new(path)
-}
-
-/// Future returned by `create_dir`.
-#[derive(Debug)]
-pub struct CreateDirFuture<P>
-where
-    P: AsRef<Path>,
-{
-    path: P,
-}
-
-impl<P> CreateDirFuture<P>
-where
-    P: AsRef<Path>,
-{
-    fn new(path: P) -> CreateDirFuture<P> {
-        CreateDirFuture { path: path }
-    }
-}
-
-impl<P> Future for CreateDirFuture<P>
-where
-    P: AsRef<Path>,
-{
-    type Item = ();
-    type Error = io::Error;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        ::blocking_io(|| fs::create_dir(&self.path))
-    }
-}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Alex Crichton	cf9398ef61	Bump to 0.1.1	2017-01-11 18:56:15 -08:00
Alex Crichton	b726610e7f	Ignore errors in signal handler Closes #3	2017-01-11 10:21:01 -08:00
Alex Crichton	338567ca80	Update travis token	2016-11-19 09:15:38 -08:00
Alex Crichton	3181ebfda6	Merge pull request #2 from jugglerchris/patch-1 Trivial typo fix.	2016-11-07 14:25:06 -08:00
Chris Emerson	424be889a4	Trivial typo fix.	2016-11-07 22:04:08 +00:00
Alex Crichton	72283f178a	Remove SIGKILL reexport	2016-10-05 13:55:45 -07:00
Alex Crichton	202220034e	Add symbolic reexports for common signals Means you don't have to import libc! Closes #1	2016-10-05 08:58:06 -07:00
Alex Crichton	0c0c0bb177	Update deps to point to crates.io	2016-09-09 22:04:04 -07:00
Alex Crichton	69ced1b6da	Start adding windows support	2016-09-08 17:28:44 -07:00
Alex Crichton	17481a3a54	Track tokio-core master	2016-09-07 22:14:54 -07:00
Alex Crichton	93e7d9759a	Fix travis token	2016-09-07 00:14:23 -07:00
Alex Crichton	85d6d43d18	Update travis link	2016-09-07 00:06:14 -07:00
Alex Crichton	e74b728ecf	Update Cargo metadata	2016-09-07 00:05:45 -07:00
Alex Crichton	9acd70b7e3	Add licenses	2016-09-07 00:04:49 -07:00
Alex Crichton	a531721b1c	Add a README	2016-09-07 00:04:44 -07:00
Alex Crichton	06153d0f28	Add docs and travis	2016-09-07 00:03:43 -07:00
Alex Crichton	50973e0734	Initial commit	2016-09-06 23:00:17 -07:00