prepare v0.2.0-alpha.4 (#1509)

A sealed `net::ToSocketAddrs` trait is added. This trait is not intended
to be used by users. Instead, it is an argument to `connect` and `bind`
functions.

The operating system's DNS lookup functionality is used. Blocking
operations are performed on a thread pool in order to avoid blocking the
runtime.

.appveyor.yml

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

.cirrus.yml

@@ -0,0 +1,43 @@
+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_PREEMPTIONS: 2
+    RUSTFLAGS: -Dwarnings
+  setup_script:
+    - pkg install -y curl
+    - curl https://sh.rustup.rs -sSf --output rustup.sh
+    # TODO: switch back to nightly
+    - sh rustup.sh -y --default-toolchain nightly-2019-08-21
+    - . $HOME/.cargo/env
+    - rustup target add i686-unknown-freebsd
+    - |
+      echo "~~~~ rustc --version ~~~~"
+      rustc --version
+
+      # Remove any existing patch statements
+      mv Cargo.toml Cargo.toml.bck
+      sed -n '/\[patch.crates-io\]/q;p' Cargo.toml.bck > Cargo.toml
+
+      # Patch all crates
+      cat ci/patch.toml >> Cargo.toml
+
+      # Print `Cargo.toml` for debugging
+      echo "~~~~ Cargo.toml ~~~~"
+      cat Cargo.toml
+      echo "~~~~~~~~~~~~~~~~~~~~"
+  test_script:
+    - . $HOME/.cargo/env
+    - cargo test --all
+    - cargo doc --all --no-deps
+  # TODO: Re-enable
+  # i686_test_script:
+  #   - . $HOME/.cargo/env
+  #   - |
+  #     cargo test --all --exclude tokio-tls --exclude tokio-macros --target i686-unknown-freebsd

.github/ISSUE_TEMPLATE.md

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

.github/PULL_REQUEST_TEMPLATE.md

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

.travis.yml

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

CHANGELOG.md

@@ -1,21 +0,0 @@
-# 0.1.3 (March 09, 2018)
-
-* Fix `CurrentThread::turn` to block on idle (#212).
-
-# 0.1.2 (March 09, 2018)
-
-* Introduce Tokio Runtime (#141)
-* Provide `CurrentThread` for more flexible usage of current thread executor (#141).
-* Add Lio for platforms that support it (#142).
-* I/O resources now lazily bind to the reactor (#160).
-* Extract Reactor to dedicated crate (#169)
-* Add facade to sub crates and add prelude (#166).
-* Switch TCP/UDP fns to poll_ -> Poll<...> style (#175)
-
-# 0.1.1 (February 09, 2018)
-
-* Doc fixes
-
-# 0.1.0 (February 07, 2018)
-
-* Initial crate released based on [RFC](https://github.com/tokio-rs/tokio-rfcs/pull/3).

CONTRIBUTING.md

@@ -0,0 +1,443 @@
+# 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:
+
+```
+/// // 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:
+
+```
+/// 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
+
+## Releasing
+
+Since the Tokio project consists of a number of crates, many of which depend on
+each other, releasing new versions to crates.io can involve some complexities.
+When releasing a new version of a crate, follow these steps:
+
+1. **Ensure that the release crate has no path dependencies.** When the HEAD
+   version of a Tokio crate requires unreleased changes in another Tokio crate,
+   the crates.io dependency on the second crate will be replaced with a path
+   dependency. Crates with path dependencies cannot be published, so before
+   publishing the dependent crate, any path dependencies must also be published.
+   This should be done through a form of depth-first tree traversal:
+
+   1. Starting with the first path dependency in the crate to be released,
+      inspect the `Cargo.toml` for the dependency. If the dependency has any
+      path dependencies of its own, repeat this step with the first such
+      dependency.
+   2. Begin the release process for the path dependency.
+   3. Once the path dependency has been published to crates.io, update the
+      dependent crate to depend on the crates.io version.
+   4. When all path dependencies have been published, the dependent crate may
+      be published.
+
+   To verify that a crate is ready to publish, run:
+
+   ```bash
+   bin/publish --dry-run <CRATE NAME> <CRATE VERSION>
+   ```
+
+2. **Update Cargo metadata.** After releasing any path dependencies, update the
+   `version` field in `Cargo.toml` to the new version, and the `documentation`
+   field to the docs.rs URL of the new version.
+3. **Update other documentation links.** Update the `#![doc(html_root_url)]`
+   attribute in the crate's `lib.rs` and the "Documentation" link in the crate's
+   `README.md` to point to the docs.rs URL of the new version.
+4. **Update the changelog for the crate.** Each crate in the Tokio repository
+   has its own `CHANGELOG.md` in that crate's subdirectory. Any changes to that
+   crate since the last release should be added to the changelog. Change
+   descriptions may be taken from the Git history, but should be edited to
+   ensure a consistent format, based on [Keep A Changelog][keep-a-changelog].
+   Other entries in that crate's changelog may also be used for reference.
+5. **Perform a final audit for breaking changes.** Compare the HEAD version of
+   crate with the Git tag for the most recent release version. If there are any
+   breaking API changes, determine if those changes can be made without breaking
+   existing APIs. If so, resolve those issues. Otherwise, if it is necessary to
+   make a breaking release, update the version numbers to reflect this.
+6. **Open a pull request with your changes.** Once that pull request has been
+   approved by a maintainer and the pull request has been merged, continue to
+   the next step.
+7. **Release the crate.** Run the following command:
+
+   ```bash
+   bin/publish <NAME OF CRATE> <VERSION>
+   ```
+
+   Your editor and prompt you to edit a message for the tag. Copy the changelog
+   entry for that release version into your editor and close the window.
+
+[keep-a-changelog]: https://github.com/olivierlacan/keep-a-changelog/blob/master/CHANGELOG.md

Cargo.toml

@@ -1,62 +1,17 @@
-[package]
-name = "tokio"
-
-# When releasing to crates.io:
-# - Update html_root_url.
-# - Update CHANGELOG.md.
-# - Create "v0.1.x" git tag.
-version = "0.1.3"
-authors = ["Carl Lerche <[email protected]>"]
-license = "MIT/Apache-2.0"
-readme = "README.md"
-repository = "https://github.com/tokio-rs/tokio"
-homepage = "https://tokio.rs"
-documentation = "https://docs.rs/tokio/0.1"
-description = """
-An event-driven, non-blocking I/O platform for writing asynchronous I/O
-backed applications.
-"""
-categories = ["asynchronous", "network-programming"]
-keywords = ["io", "async", "non-blocking", "futures"]
-
 [workspace]
 
 members = [
-  "./",
+  "tokio",
+  "tokio-buf",
+  "tokio-codec",
   "tokio-executor",
+  "tokio-fs",
   "tokio-io",
-  "tokio-reactor",
-  "tokio-threadpool",
+  "tokio-macros",
+  "tokio-net",
+  "tokio-sync",
+  "tokio-test",
+  "tokio-timer",
+  "tokio-tls",
+  "build-tests",
 ]
-
-[badges]
-travis-ci = { repository = "tokio-rs/tokio" }
-appveyor = { repository = "carllerche/tokio" }
-
-[dependencies]
-tokio-io = { version = "0.1.6", path = "tokio-io" }
-tokio-executor = { version = "0.1.0", path = "tokio-executor" }
-tokio-reactor = { version = "0.1.0", path = "tokio-reactor" }
-tokio-threadpool = { version = "0.1.0", path = "tokio-threadpool" }
-bytes = "0.4"
-log = "0.4"
-mio = "0.6.14"
-slab = "0.4"
-iovec = "0.1"
-futures = "0.1.18"
-
-[dev-dependencies]
-env_logger = { version = "0.4", default-features = false }
-flate2 = { version = "1", features = ["tokio"] }
-futures-cpupool = "0.1"
-http = "0.1"
-httparse = "1.0"
-libc = "0.2"
-num_cpus = "1.0"
-serde = "1.0"
-serde_derive = "1.0"
-serde_json = "1.0"
-time = "0.1"
-
-[patch.crates-io]
-tokio-io = { path = "tokio-io" }

LICENSE

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

LICENSE-APACHE

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

README.md

@@ -1,5 +1,7 @@
 # Tokio
 
+ _NOTE_: Tokio's [`master`](https://github.com/tokio-rs/tokio) branch is currently in the process of moving to [`std::future::Future`](https://doc.rust-lang.org/std/future/trait.Future.html), for `v0.1.x` based tokio releases please check out the [`v0.1.x`](https://github.com/tokio-rs/tokio/tree/v0.1.x) branch.
+
 A runtime for writing reliable, asynchronous, and slim applications with
 the Rust programming language. It is:
 
@@ -14,25 +16,22 @@ the Rust programming language. It is:
 
 [![Crates.io][crates-badge]][crates-url]
 [![MIT licensed][mit-badge]][mit-url]
-[![Travis Build Status][travis-badge]][travis-url]
-[![Appveyor Build Status][appveyor-badge]][appveyor-url]
+[![Build Status][azure-badge]][azure-url]
+[![Gitter chat][gitter-badge]][gitter-url]
 
 [crates-badge]: https://img.shields.io/crates/v/tokio.svg
 [crates-url]: https://crates.io/crates/tokio
 [mit-badge]: https://img.shields.io/badge/license-MIT-blue.svg
-[mit-url]: LICENSE-MIT
-[travis-badge]: https://travis-ci.org/tokio-rs/tokio.svg?branch=master
-[travis-url]: https://travis-ci.org/tokio-rs/tokio
-[appveyor-badge]: https://ci.appveyor.com/api/projects/status/s83yxhy9qeb58va7/branch/master?svg=true
-[appveyor-url]: https://ci.appveyor.com/project/carllerche/tokio/branch/master
+[mit-url]: LICENSE
+[azure-badge]: https://dev.azure.com/tokio-rs/Tokio/_apis/build/status/tokio-rs.tokio?branchName=master
+[azure-url]: https://dev.azure.com/tokio-rs/Tokio/_build/latest?definitionId=1&branchName=master
+[gitter-badge]: https://img.shields.io/gitter/room/tokio-rs/tokio.svg
+[gitter-url]: https://gitter.im/tokio-rs/tokio
 
 [Website](https://tokio.rs) |
-[Guides](https://tokio.rs/docs/getting-started/hello-world/) |
-[API Docs](https://docs.rs/tokio)
-
-The API docs for the master branch are published [here][master-dox].
-
-[master-dox]: https://tokio-rs.github.io/tokio/tokio/
+[Guides](https://tokio.rs/docs/) |
+[API Docs](https://docs.rs/tokio/0.2.0-alpha.2/tokio) |
+[Chat](https://gitter.im/tokio-rs/tokio)
 
 ## Overview
 
@@ -41,63 +40,83 @@ asynchronous applications with the Rust programming language. At a high
 level, it provides a few major components:
 
 * A multithreaded, work-stealing based task [scheduler].
-* A [reactor] backed by the operating system's event queue (epoll, kqueue,
+* A reactor backed by the operating system's event queue (epoll, kqueue,
   IOCP, etc...).
 * Asynchronous [TCP and UDP][net] sockets.
 
 These components provide the runtime components necessary for building
 an asynchronous application.
 
-[net]: https://docs.rs/tokio/0.1/tokio/net/index.html
-[reactor]: https://docs.rs/tokio/0.1.1/tokio/reactor/index.html
-[scheduler]: https://tokio-rs.github.io/tokio/tokio/runtime/index.html
+[net]: https://docs.rs/tokio/0.2.0-alpha.2/tokio/net/index.html
+[scheduler]: https://docs.rs/tokio/0.2.0-alpha.2/tokio/runtime/index.html
 
 ## Example
 
 A basic TCP echo server with Tokio:
 
 ```rust
-extern crate tokio;
-
-use tokio::prelude::*;
-use tokio::io::copy;
 use tokio::net::TcpListener;
+use tokio::prelude::*;
 
-fn main() {
-    // Bind the server's socket.
-    let addr = "127.0.0.1:12345".parse().unwrap();
-    let listener = TcpListener::bind(&addr)
-        .expect("unable to bind TCP listener");
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let addr = "127.0.0.1:8080".parse()?;
+    let mut listener = TcpListener::bind(&addr).unwrap();
 
-    // Pull out a stream of sockets for incoming connections
-    let server = listener.incoming()
-        .map_err(|e| eprintln!("accept failed = {:?}", e))
-        .for_each(|sock| {
-            // Split up the reading and writing parts of the
-            // socket.
-            let (reader, writer) = sock.split();
+    loop {
+        let (mut socket, _) = listener.accept().await?;
 
-            // A future that echos the data and returns how
-            // many bytes were copied...
-            let bytes_copied = copy(reader, writer);
+        tokio::spawn(async move {
+            let mut buf = [0; 1024];
 
-            // ... after which we'll print what happened.
-            let handle_conn = bytes_copied.map(|amt| {
-                println!("wrote {:?} bytes", amt)
-            }).map_err(|err| {
-                eprintln!("IO error {:?}", err)
-            });
+            // In a loop, read data from the socket and write the data back.
+            loop {
+                let n = match socket.read(&mut buf).await {
+                    // socket closed
+                    Ok(n) if n == 0 => return,
+                    Ok(n) => n,
+                    Err(e) => {
+                        println!("failed to read from socket; err = {:?}", e);
+                        return;
+                    }
+                };
 
-            // Spawn the future as a concurrent task.
-            tokio::spawn(handle_conn)
+                // Write the data back
+                if let Err(e) = socket.write_all(&buf[0..n]).await {
+                    println!("failed to write to socket; err = {:?}", e);
+                    return;
+                }
+            }
         });
-
-    // Start the Tokio runtime
-    tokio::run(server);
+    }
 }
 ```
 
-More examples can be found [here](examples).
+More examples can be found [here](tokio/examples). Note that the `master` branch
+is currently being updated to use `async` / `await`.  The examples are
+not fully ported. Examples for stable Tokio can be found
+[here](https://github.com/tokio-rs/tokio/tree/v0.1.x/tokio/examples).
+
+
+## Getting Help
+
+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.
+
+[Guides]: https://tokio.rs/docs/
+[API documentation]: https://docs.rs/tokio/0.2.0-alpha.2/tokio
+[chat]: https://gitter.im/tokio-rs/tokio
+[issue]: https://github.com/tokio-rs/tokio/issues/new
+
+## Contributing
+
+:balloon: Thanks for your help improving the project! We are so happy to have
+you! We have a [contributing guide][guide] to help you get involved in the Tokio
+project.
+
+[guide]: CONTRIBUTING.md
 
 ## Project layout
 
@@ -107,34 +126,62 @@ have greater guarantees of stability.
 
 The crates included as part of Tokio are:
 
-* [`tokio-executor`]: Task execution related traits and utilities.
+* [`tokio-executor`]: Task executors and related utilities. Includes a
+  single-threaded executor and a multi-threaded, work-stealing, executor.
+
+* [`tokio-fs`]: Filesystem (and standard in / out) APIs.
+
+* [`tokio-codec`]: Utilities for encoding and decoding protocol frames.
 
 * [`tokio-io`]: Asynchronous I/O related traits and utilities.
 
-* [`tokio-reactor`]: Event loop that drives I/O resources (like TCP and UDP
-  sockets).
+* [`tokio-macros`]: Macros for usage with Tokio.
 
-* [`tokio-threadpool`]: Schedules the execution of futures across a pool of
-  threads.
+* [`tokio-net`]: Event loop that drives I/O resources as well as TCP, UDP, and
+  unix domain socket apis.
 
+* [ `tokio-timer`]: Time related APIs.
+
+[`tokio-codec`]: tokio-codec
+[`tokio-current-thread`]: tokio-current-thread
 [`tokio-executor`]: tokio-executor
+[`tokio-fs`]: tokio-fs
 [`tokio-io`]: tokio-io
-[`tokio-reactor`]: tokio-reactor
-[`tokio-threadpool`]: tokio-threadpool
+[`tokio-macros`]: tokio-macros
+[`tokio-net`]: tokio-net
+[`tokio-timer`]: tokio-timer
+
+## Related Projects
+
+In addition to the crates in this repository, the Tokio project also maintains
+several other libraries, including:
+
+* [`tracing`] (formerly `tokio-trace`): A framework for application-level
+  tracing and async-aware diagnostics.
+
+* [`mio`]: A low-level, cross-platform abstraction over OS I/O APIs that powers
+  `tokio`.
+
+* [`bytes`]: Utilities for working with bytes, including efficient byte buffers.
+
+[`tracing`]: https://github.com/tokio-rs/tracing
+[`mio`]: https://github.com/tokio-rs/mio
+[`bytes`]: https://github.com/tokio-rs/bytes
+
+## Supported Rust Versions
+
+Tokio is built against the latest stable, nightly, and beta Rust releases. The
+minimum version supported is the stable release from three months before the
+current stable release version. For example, if the latest stable Rust is 1.29,
+the minimum version supported is 1.26. The current Tokio version is not
+guaranteed to build on Rust versions earlier than the minimum supported version.
 
 ## License
 
-This project is licensed under either of
-
- * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
-   http://www.apache.org/licenses/LICENSE-2.0)
- * MIT license ([LICENSE-MIT](LICENSE-MIT) or
-   http://opensource.org/licenses/MIT)
-
-at your option.
+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, as defined in the Apache-2.0 license, shall be
-dual licensed as above, without any additional terms or conditions.
+for inclusion in Tokio by you, shall be licensed as MIT, without any additional
+terms or conditions.

azure-pipelines.yml

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

bin/publish

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

bin/update-doc

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

build-tests/Cargo.toml

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

build-tests/README.md

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

build-tests/src/lib.rs

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

build-tests/tests/fail/executor_without_current_thread.rs

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

build-tests/tests/fail/executor_without_current_thread.stderr

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

build-tests/tests/fail/net_without_tcp_missing_tcp.rs

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

build-tests/tests/fail/net_without_tcp_missing_tcp.stderr

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

build-tests/tests/fail/net_without_udp_missing_udp.rs

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

build-tests/tests/fail/net_without_udp_missing_udp.stderr

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

build-tests/tests/fail/net_without_uds_missing_uds.rs

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

build-tests/tests/fail/net_without_uds_missing_uds.stderr

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

build-tests/tests/fail/tokio_without_net_missing_net.rs

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

build-tests/tests/fail/tokio_without_net_missing_net.stderr

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

build-tests/tests/features.rs

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

ci/azure-cargo-check.yml

@@ -0,0 +1,29 @@
+parameters:
+  noDefaultFeatures: '--no-default-features'
+
+jobs:
+- job: ${{ parameters.name }}
+  displayName: ${{ parameters.displayName }}
+  pool:
+    vmImage: ubuntu-16.04
+  steps:
+  - template: azure-install-rust.yml
+    parameters:
+      rust_version: ${{ parameters.rust }}
+
+  - template: azure-is-release.yml
+
+  - ${{ each crate in parameters.crates }}:
+    - ${{ each feature in crate.value }}:
+      - script: cargo check ${{ parameters.noDefaultFeatures }} --features ${{ feature }}
+        displayName: Check `${{ crate.key }}`, features = ${{ feature }}
+        workingDirectory: $(Build.SourcesDirectory)/${{ crate.key }}
+        condition: and(succeeded(), not(variables['isRelease']))
+
+  - template: azure-patch-crates.yml
+
+  - ${{ each crate in parameters.crates }}:
+    - ${{ each feature in crate.value }}:
+      - script: cargo check ${{ parameters.noDefaultFeatures }} --features ${{ feature }}
+        displayName: Check `${{ crate.key }}`, features = ${{ feature }}
+        workingDirectory: $(Build.SourcesDirectory)/${{ crate.key }}

ci/azure-check-minrust.yml

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

ci/azure-clippy.yml

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

ci/azure-cross-compile.yml

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

ci/azure-deploy-docs.yml

@@ -0,0 +1,39 @@
+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
+      rust_version: ${{ parameters.rust }}
+  - script: |
+      cargo doc --all --no-deps --all-features
+      cp -R target/doc '$(Build.BinariesDirectory)'
+    displayName: 'Generate Documentation'
+  - script: |
+      set -e
+
+      git --version
+      ls -la
+      git init
+      git config user.name 'Deployment Bot (from Azure Pipelines)'
+      git config user.email '[email protected]'
+      git config --global credential.helper 'store --file ~/.my-credentials'
+      printf "protocol=https\nhost=github.com\nusername=carllerche\npassword=%s\n\n" "$GITHUB_TOKEN" | git credential-store --file ~/.my-credentials store
+      git remote add origin https://github.com/tokio-rs/tokio
+      git checkout -b gh-pages
+      git add .
+      git commit -m 'Deploy Tokio API documentation'
+      git push -f origin gh-pages
+    env:
+      GITHUB_TOKEN: $(githubPersonalToken)
+    workingDirectory: '$(Build.BinariesDirectory)'
+    displayName: 'Deploy Documentation'

ci/azure-install-rust.yml

@@ -0,0 +1,33 @@
+steps:
+  # Linux and macOS.
+  - script: |
+      set -e
+      curl https://sh.rustup.rs -sSf | sh -s -- -y --default-toolchain none
+      export PATH=$PATH:$HOME/.cargo/bin
+      rustup toolchain install $RUSTUP_TOOLCHAIN
+      rustup default $RUSTUP_TOOLCHAIN
+      echo "##vso[task.setvariable variable=PATH;]$PATH:$HOME/.cargo/bin"
+    env:
+      RUSTUP_TOOLCHAIN: ${{parameters.rust_version}}
+    displayName: "Install rust (*nix)"
+    condition: not(eq(variables['Agent.OS'], 'Windows_NT'))
+
+  # Windows.
+  - script: |
+      curl -sSf -o rustup-init.exe https://win.rustup.rs
+      rustup-init.exe -y --default-toolchain none
+      set PATH=%PATH%;%USERPROFILE%\.cargo\bin
+      rustup toolchain install %RUSTUP_TOOLCHAIN%
+      rustup default %RUSTUP_TOOLCHAIN%
+      echo "##vso[task.setvariable variable=PATH;]%PATH%;%USERPROFILE%\.cargo\bin"
+    env:
+      RUSTUP_TOOLCHAIN: ${{parameters.rust_version}}
+    displayName: "Install rust (windows)"
+    condition: eq(variables['Agent.OS'], 'Windows_NT')
+
+  # All platforms.
+  - script: |
+        rustup toolchain list
+        rustc -Vv
+        cargo -V
+    displayName: Query rust and cargo versions

ci/azure-is-release.yml

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

ci/azure-patch-crates.yml

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

ci/azure-rustfmt.yml

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

ci/azure-test-nightly.yml

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

ci/azure-test-stable.yml

@@ -0,0 +1,61 @@
+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
+      rust_version: ${{ parameters.rust }}
+
+  - template: azure-is-release.yml
+
+  - ${{ each crate in parameters.crates }}:
+    # Run with default crate features
+    - script: cargo test
+      env:
+        LOOM_MAX_PREEMPTIONS: 2
+        CI: 'True'
+      displayName: ${{ crate.key }} - cargo test
+      workingDirectory: $(Build.SourcesDirectory)/${{ crate.key }}
+
+    # Run with each specified feature
+    - ${{ each feature in crate.value }}:
+      - script: cargo test --no-default-features --features ${{ feature }}
+        env:
+          LOOM_MAX_PREEMPTIONS: 2
+          CI: 'True'
+        displayName: ${{ crate.key }} - cargo test --features ${{ feature }}
+        workingDirectory: $(Build.SourcesDirectory)/${{ crate.key }}
+
+  - template: azure-patch-crates.yml
+
+  - ${{ each crate in parameters.crates }}:
+    # Run with default crate features
+    - script: cargo test
+      env:
+        LOOM_MAX_PREEMPTIONS: 2
+        CI: 'True'
+      displayName: ${{ crate.key }} - cargo test
+      workingDirectory: $(Build.SourcesDirectory)/${{ crate.key }}
+
+    # Run with each specified feature
+    - ${{ each feature in crate.value }}:
+      - script: cargo test --no-default-features --features ${{ feature }}
+        env:
+          LOOM_MAX_PREEMPTIONS: 2
+          CI: 'True'
+        displayName: ${{ crate.key }} - cargo test --features ${{ feature }}
+        workingDirectory: $(Build.SourcesDirectory)/${{ crate.key }}

ci/azure-tsan.yml

@@ -0,0 +1,36 @@
+jobs:
+- job: ${{ parameters.name }}
+  displayName: TSAN
+  strategy:
+    matrix:
+      Timer:
+        cmd: cargo test -p tokio-timer --test hammer
+      Threadpool:
+        cmd: cargo test -p tokio-executor --tests --features threadpool
+  pool:
+    vmImage: ubuntu-16.04
+  steps:
+  - template: azure-install-rust.yml
+    parameters:
+      rust_version: ${{ parameters.rust }}
+
+  - template: azure-patch-crates.yml
+  - script: |
+        set -e
+
+        # Make sure the benchmarks compile
+        export ASAN_OPTIONS="detect_odr_violation=0 detect_leaks=0"
+        export TSAN_OPTIONS="suppressions=`pwd`/ci/tsan"
+        export RUST_BACKTRACE=1
+
+        # Run address sanitizer
+        RUSTFLAGS="-Z sanitizer=address" \
+        $(cmd) --target x86_64-unknown-linux-gnu
+
+        # Run thread sanitizer
+        RUSTFLAGS="-Z sanitizer=thread" \
+        $(cmd) --target x86_64-unknown-linux-gnu
+    displayName: TSAN / MSAN
+    env:
+      TSAN: yes
+

ci/patch.toml

@@ -0,0 +1,14 @@
+# 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-executor = { path = "tokio-executor" }
+tokio-fs = { path = "tokio-fs" }
+tokio-io = { path = "tokio-io" }
+tokio-macros = { path = "tokio-macros" }
+tokio-net = { path = "tokio-net" }
+tokio-sync = { path = "tokio-sync" }
+tokio-timer = { path = "tokio-timer" }
+tokio-tls = { path = "tokio-tls" }

ci/tsan

@@ -0,0 +1,39 @@
+# 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
+race:std*lang_start
+race:drop*std::thread*
+
+# 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

examples/README.md

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

examples/chat-combinator.rs

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

examples/chat.rs

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

examples/connect.rs

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

examples/echo.rs

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

examples/hello_world.rs

@@ -1,70 +0,0 @@
-//! Hello world server.
-//!
-//! A simple server that accepts connections, writes "hello world\n", and closes
-//! the connection.
-//!
-//! You can test this out by running:
-//!
-//!     cargo run --example hello_world
-//!
-//! And then in another terminal run:
-//!
-//!     telnet localhost 6142
-//!
-
-#![deny(warnings)]
-
-extern crate tokio;
-
-use tokio::io;
-use tokio::net::TcpListener;
-use tokio::prelude::*;
-
-pub fn main() {
-    let addr = "127.0.0.1:6142".parse().unwrap();
-
-    // Bind a TCP listener to the socket address.
-    //
-    // Note that this is the Tokio TcpListener, which is fully async.
-    let listener = TcpListener::bind(&addr).unwrap();
-
-    // The server task asynchronously iterates over and processes each
-    // incoming connection.
-    let server = listener.incoming().for_each(|socket| {
-        println!("accepted socket; addr={:?}", socket.peer_addr().unwrap());
-
-        let connection = io::write_all(socket, "hello world\n")
-            .then(|res| {
-                println!("wrote message; success={:?}", res.is_ok());
-                Ok(())
-            });
-
-        // Spawn a new task that processes the socket:
-        tokio::spawn(connection);
-
-        Ok(())
-    })
-    .map_err(|err| {
-        // All tasks must have an `Error` type of `()`. This forces error
-        // handling and helps avoid silencing failures.
-        //
-        // In our example, we are only going to log the error to STDOUT.
-        println!("accept error = {:?}", err);
-    });
-
-    println!("server running on localhost:6142");
-
-    // Start the Tokio runtime.
-    //
-    // The Tokio is a pre-configured "out of the box" runtime for building
-    // asynchronous applications. It includes both a reactor and a task
-    // scheduler. This means applications are multithreaded by default.
-    //
-    // This function blocks until the runtime reaches an idle state. Idle is
-    // defined as all spawned tasks have completed and all I/O resources (TCP
-    // sockets in our case) have been dropped.
-    //
-    // In our example, we have not defined a shutdown strategy, so this will
-    // block until `ctrl-c` is pressed at the terminal.
-    tokio::run(server);
-}

examples/proxy.rs

@@ -1,128 +0,0 @@
-//! A proxy that forwards data to another server and forwards that server's
-//! responses back to clients.
-//!
-//! Because the Tokio runtime uses a thread poool, each TCP connection is
-//! processed concurrently with all other TCP connections across multiple
-//! threads.
-//!
-//! You can showcase this by running this in one terminal:
-//!
-//!     cargo run --example proxy
-//!
-//! This in another terminal
-//!
-//!     cargo run --example echo
-//!
-//! And finally this in another terminal
-//!
-//!     cargo run --example connect 127.0.0.1:8081
-//!
-//! This final terminal will connect to our proxy, which will in turn connect to
-//! the echo server, and you'll be able to see data flowing between them.
-
-#![deny(warnings)]
-
-extern crate tokio;
-
-use std::sync::{Arc, Mutex};
-use std::env;
-use std::net::{Shutdown, SocketAddr};
-use std::io::{self, Read, Write};
-
-use tokio::io::{copy, shutdown};
-use tokio::net::{TcpListener, TcpStream};
-use tokio::prelude::*;
-
-fn main() {
-    let listen_addr = env::args().nth(1).unwrap_or("127.0.0.1:8081".to_string());
-    let listen_addr = listen_addr.parse::<SocketAddr>().unwrap();
-
-    let server_addr = env::args().nth(2).unwrap_or("127.0.0.1:8080".to_string());
-    let server_addr = server_addr.parse::<SocketAddr>().unwrap();
-
-    // Create a TCP listener which will listen for incoming connections.
-    let socket = TcpListener::bind(&listen_addr).unwrap();
-    println!("Listening on: {}", listen_addr);
-    println!("Proxying to: {}", server_addr);
-
-    let done = socket.incoming()
-        .map_err(|e| println!("error accepting socket; error = {:?}", e))
-        .for_each(move |client| {
-            let server = TcpStream::connect(&server_addr);
-            let amounts = server.and_then(move |server| {
-                // Create separate read/write handles for the TCP clients that we're
-                // proxying data between. Note that typically you'd use
-                // `AsyncRead::split` for this operation, but we want our writer
-                // handles to have a custom implementation of `shutdown` which
-                // actually calls `TcpStream::shutdown` to ensure that EOF is
-                // transmitted properly across the proxied connection.
-                //
-                // As a result, we wrap up our client/server manually in arcs and
-                // use the impls below on our custom `MyTcpStream` type.
-                let client_reader = MyTcpStream(Arc::new(Mutex::new(client)));
-                let client_writer = client_reader.clone();
-                let server_reader = MyTcpStream(Arc::new(Mutex::new(server)));
-                let server_writer = server_reader.clone();
-
-                // Copy the data (in parallel) between the client and the server.
-                // After the copy is done we indicate to the remote side that we've
-                // finished by shutting down the connection.
-                let client_to_server = copy(client_reader, server_writer)
-                    .and_then(|(n, _, server_writer)| {
-                        shutdown(server_writer).map(move |_| n)
-                    });
-
-                let server_to_client = copy(server_reader, client_writer)
-                    .and_then(|(n, _, client_writer)| {
-                        shutdown(client_writer).map(move |_| n)
-                    });
-
-                client_to_server.join(server_to_client)
-            });
-
-            let msg = amounts.map(move |(from_client, from_server)| {
-                println!("client wrote {} bytes and received {} bytes",
-                         from_client, from_server);
-            }).map_err(|e| {
-                // Don't panic. Maybe the client just disconnected too soon.
-                println!("error: {}", e);
-            });
-
-            tokio::spawn(msg);
-
-            Ok(())
-        });
-
-    tokio::run(done);
-}
-
-// This is a custom type used to have a custom implementation of the
-// `AsyncWrite::shutdown` method which actually calls `TcpStream::shutdown` to
-// notify the remote end that we're done writing.
-#[derive(Clone)]
-struct MyTcpStream(Arc<Mutex<TcpStream>>);
-
-impl Read for MyTcpStream {
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        self.0.lock().unwrap().read(buf)
-    }
-}
-
-impl Write for MyTcpStream {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.0.lock().unwrap().write(buf)
-    }
-
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-impl AsyncRead for MyTcpStream {}
-
-impl AsyncWrite for MyTcpStream {
-    fn shutdown(&mut self) -> Poll<(), io::Error> {
-        try!(self.0.lock().unwrap().shutdown(Shutdown::Write));
-        Ok(().into())
-    }
-}

examples/tinydb.rs

@@ -1,206 +0,0 @@
-//! A "tiny database" and accompanying protocol
-//!
-//! This example shows the usage of shared state amongst all connected clients,
-//! namely a database of key/value pairs. Each connected client can send a
-//! series of GET/SET commands to query the current value of a key or set the
-//! value of a key.
-//!
-//! This example has a simple protocol you can use to interact with the server.
-//! To run, first run this in one terminal window:
-//!
-//!     cargo run --example tinydb
-//!
-//! and next in another windows run:
-//!
-//!     cargo run --example connect 127.0.0.1:8080
-//!
-//! In the `connect` window you can type in commands where when you hit enter
-//! you'll get a response from the server for that command. An example session
-//! is:
-//!
-//!
-//!     $ cargo run --example connect 127.0.0.1:8080
-//!     GET foo
-//!     foo = bar
-//!     GET FOOBAR
-//!     error: no key FOOBAR
-//!     SET FOOBAR my awesome string
-//!     set FOOBAR = `my awesome string`, previous: None
-//!     SET foo tokio
-//!     set foo = `tokio`, previous: Some("bar")
-//!     GET foo
-//!     foo = tokio
-//!
-//! Namely you can issue two forms of commands:
-//!
-//! * `GET $key` - this will fetch the value of `$key` from the database and
-//!   return it. The server's database is initially populated with the key `foo`
-//!   set to the value `bar`
-//! * `SET $key $value` - this will set the value of `$key` to `$value`,
-//!   returning the previous value, if any.
-
-#![deny(warnings)]
-
-extern crate tokio;
-
-use std::collections::HashMap;
-use std::io::BufReader;
-use std::env;
-use std::net::SocketAddr;
-use std::sync::{Arc, Mutex};
-
-use tokio::io::{lines, write_all};
-use tokio::net::TcpListener;
-use tokio::prelude::*;
-
-/// The in-memory database shared amongst all clients.
-///
-/// This database will be shared via `Arc`, so to mutate the internal map we're
-/// also going to use a `RefCell` for interior mutability.
-struct Database {
-    map: Mutex<HashMap<String, String>>,
-}
-
-/// Possible requests our clients can send us
-enum Request {
-    Get { key: String },
-    Set { key: String, value: String },
-}
-
-/// Responses to the `Request` commands above
-enum Response {
-    Value { key: String, value: String },
-    Set { key: String, value: String, previous: Option<String> },
-    Error { msg: String },
-}
-
-fn main() {
-    // Parse the address we're going to run this server on
-    // and set up our TCP listener to accept connections.
-    let addr = env::args().nth(1).unwrap_or("127.0.0.1:8080".to_string());
-    let addr = addr.parse::<SocketAddr>().unwrap();
-    let listener = TcpListener::bind(&addr).expect("failed to bind");
-    println!("Listening on: {}", addr);
-
-    // Create the shared state of this server that will be shared amongst all
-    // clients. We populate the initial database and then create the `Database`
-    // structure. Note the usage of `Arc` here which will be used to ensure that
-    // each independently spawned client will have a reference to the in-memory
-    // database.
-    let mut initial_db = HashMap::new();
-    initial_db.insert("foo".to_string(), "bar".to_string());
-    let db = Arc::new(Database {
-        map: Mutex::new(initial_db),
-    });
-
-    let done = listener.incoming()
-        .map_err(|e| println!("error accepting socket; error = {:?}", e))
-        .for_each(move |socket| {
-            // As with many other small examples, the first thing we'll do is
-            // *split* this TCP stream into two separately owned halves. This'll
-            // allow us to work with the read and write halves independently.
-            let (reader, writer) = socket.split();
-
-            // Since our protocol is line-based we use `tokio_io`'s `lines` utility
-            // to convert our stream of bytes, `reader`, into a `Stream` of lines.
-            let lines = lines(BufReader::new(reader));
-
-            // Here's where the meat of the processing in this server happens. First
-            // we see a clone of the database being created, which is creating a
-            // new reference for this connected client to use. Also note the `move`
-            // keyword on the closure here which moves ownership of the reference
-            // into the closure, which we'll need for spawning the client below.
-            //
-            // The `map` function here means that we'll run some code for all
-            // requests (lines) we receive from the client. The actual handling here
-            // is pretty simple, first we parse the request and if it's valid we
-            // generate a response based on the values in the database.
-            let db = db.clone();
-            let responses = lines.map(move |line| {
-                let request = match Request::parse(&line) {
-                    Ok(req) => req,
-                    Err(e) => return Response::Error { msg: e },
-                };
-
-                let mut db = db.map.lock().unwrap();
-                match request {
-                    Request::Get { key } => {
-                        match db.get(&key) {
-                            Some(value) => Response::Value { key, value: value.clone() },
-                            None => Response::Error { msg: format!("no key {}", key) },
-                        }
-                    }
-                    Request::Set { key, value } => {
-                        let previous = db.insert(key.clone(), value.clone());
-                        Response::Set { key, value, previous }
-                    }
-                }
-            });
-
-            // At this point `responses` is a stream of `Response` types which we
-            // now want to write back out to the client. To do that we use
-            // `Stream::fold` to perform a loop here, serializing each response and
-            // then writing it out to the client.
-            let writes = responses.fold(writer, |writer, response| {
-                let mut response = response.serialize();
-                response.push('\n');
-                write_all(writer, response.into_bytes()).map(|(w, _)| w)
-            });
-
-            // Like with other small servers, we'll `spawn` this client to ensure it
-            // runs concurrently with all other clients, for now ignoring any errors
-            // that we see.
-            let msg = writes.then(move |_| Ok(()));
-
-            tokio::spawn(msg)
-        });
-
-    tokio::run(done);
-}
-
-impl Request {
-    fn parse(input: &str) -> Result<Request, String> {
-        let mut parts = input.splitn(3, " ");
-        match parts.next() {
-            Some("GET") => {
-                let key = match parts.next() {
-                    Some(key) => key,
-                    None => return Err(format!("GET must be followed by a key")),
-                };
-                if parts.next().is_some() {
-                    return Err(format!("GET's key must not be followed by anything"))
-                }
-                Ok(Request::Get { key: key.to_string() })
-            }
-            Some("SET") => {
-                let key = match parts.next() {
-                    Some(key) => key,
-                    None => return Err(format!("SET must be followed by a key")),
-                };
-                let value = match parts.next() {
-                    Some(value) => value,
-                    None => return Err(format!("SET needs a value")),
-                };
-                Ok(Request::Set { key: key.to_string(), value: value.to_string() })
-            }
-            Some(cmd) => Err(format!("unknown command: {}", cmd)),
-            None => Err(format!("empty input")),
-        }
-    }
-}
-
-impl Response {
-    fn serialize(&self) -> String {
-        match *self {
-            Response::Value { ref key, ref value } => {
-                format!("{} = {}", key, value)
-            }
-            Response::Set { ref key, ref value, ref previous } => {
-                format!("set {} = `{}`, previous: {:?}", key, value, previous)
-            }
-            Response::Error { ref msg } => {
-                format!("error: {}", msg)
-            }
-        }
-    }
-}

examples/udp-codec.rs

@@ -1,63 +0,0 @@
-//! This example leverages `BytesCodec` to create a UDP client and server which
-//! speak a custom protocol.
-//!
-//! Here we're using the codec from tokio-io to convert a UDP socket to a stream of
-//! client messages. These messages are then processed and returned back as a
-//! new message with a new destination. Overall, we then use this to construct a
-//! "ping pong" pair where two sockets are sending messages back and forth.
-
-#![deny(warnings)]
-
-extern crate tokio;
-extern crate tokio_io;
-extern crate env_logger;
-
-use std::net::SocketAddr;
-
-use tokio::prelude::*;
-use tokio::net::{UdpSocket, UdpFramed};
-use tokio_io::codec::BytesCodec;
-
-fn main() {
-    let _ = env_logger::init();
-
-    let addr: SocketAddr = "127.0.0.1:0".parse().unwrap();
-
-    // Bind both our sockets and then figure out what ports we got.
-    let a = UdpSocket::bind(&addr).unwrap();
-    let b = UdpSocket::bind(&addr).unwrap();
-    let b_addr = b.local_addr().unwrap();
-
-    // We're parsing each socket with the `LineCodec` defined above, and then we
-    // `split` each codec into the sink/stream halves.
-    let (a_sink, a_stream) = UdpFramed::new(a, BytesCodec::new()).split();
-    let (b_sink, b_stream) = UdpFramed::new(b, BytesCodec::new()).split();
-
-    // Start off by sending a ping from a to b, afterwards we just print out
-    // what they send us and continually send pings
-    // let pings = stream::iter((0..5).map(Ok));
-    let a = a_sink.send(("PING".into(), b_addr)).and_then(|a_sink| {
-        let mut i = 0;
-        let a_stream = a_stream.take(4).map(move |(msg, addr)| {
-            i += 1;
-            println!("[a] recv: {}", String::from_utf8_lossy(&msg));
-            (format!("PING {}", i).into(), addr)
-        });
-        a_sink.send_all(a_stream)
-    });
-
-    // The second client we have will receive the pings from `a` and then send
-    // back pongs.
-    let b_stream = b_stream.map(|(msg, addr)| {
-        println!("[b] recv: {}", String::from_utf8_lossy(&msg));
-        ("PONG".into(), addr)
-    });
-    let b = b_sink.send_all(b_stream);
-
-    // Spawn the sender of pongs and then wait for our pinger to finish.
-    tokio::run({
-        b.join(a)
-            .map(|_| ())
-            .map_err(|e| println!("error = {:?}", e))
-    });
-}

rust-toolchain

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

src/executor/current_thread/mod.rs

@@ -1,713 +0,0 @@
-//! Execute many tasks concurrently on the current thread.
-//!
-//! [`CurrentThread`] is an executor that keeps tasks on the same thread that
-//! they were spawned from. This allows it to execute futures that are not
-//! `Send`.
-//!
-//! A single [`CurrentThread`] instance is able to efficiently manage a large
-//! number of tasks and will attempt to schedule all tasks fairly.
-//!
-//! All tasks that are being managed by a [`CurrentThread`] executor are able to
-//! spawn additional tasks by calling [`spawn`]. This function only works from
-//! within the context of a running [`CurrentThread`] instance.
-//!
-//! The easiest way to start a new [`CurrentThread`] executor is to call
-//! [`block_on_all`] with an initial task to seed the executor.
-//!
-//! For example:
-//!
-//! ```
-//! # extern crate tokio;
-//! # extern crate futures;
-//! # use tokio::executor::current_thread;
-//! use futures::future::lazy;
-//!
-//! // Calling execute here results in a panic
-//! // current_thread::spawn(my_future);
-//!
-//! # pub fn main() {
-//! current_thread::block_on_all(lazy(|| {
-//!     // The execution context is setup, futures may be executed.
-//!     current_thread::spawn(lazy(|| {
-//!         println!("called from the current thread executor");
-//!         Ok(())
-//!     }));
-//!
-//!     Ok::<_, ()>(())
-//! }));
-//! # }
-//! ```
-//!
-//! The `block_on_all` function will block the current thread until **all**
-//! tasks that have been spawned onto the [`CurrentThread`] instance have
-//! completed.
-//!
-//! More fine-grain control can be achieved by using [`CurrentThread`] directly.
-//!
-//! ```
-//! # extern crate tokio;
-//! # extern crate futures;
-//! # use tokio::executor::current_thread::CurrentThread;
-//! use futures::future::{lazy, empty};
-//! use std::time::Duration;
-//!
-//! // Calling execute here results in a panic
-//! // current_thread::spawn(my_future);
-//!
-//! # pub fn main() {
-//! let mut current_thread = CurrentThread::new();
-//!
-//! // Spawn a task, the task is not executed yet.
-//! current_thread.spawn(lazy(|| {
-//!     println!("Spawning a task");
-//!     Ok(())
-//! }));
-//!
-//! // Spawn a task that never completes
-//! current_thread.spawn(empty());
-//!
-//! // Run the executor, but only until the provided future completes. This
-//! // provides the opportunity to start executing previously spawned tasks.
-//! let res = current_thread.block_on(lazy(|| {
-//!     Ok::<_, ()>("Hello")
-//! })).unwrap();
-//!
-//! // Now, run the executor for *at most* 1 second. Since a task was spawned
-//! // that never completes, this function will return with an error.
-//! current_thread.run_timeout(Duration::from_secs(1)).unwrap_err();
-//! # }
-//! ```
-//!
-//! # Execution model
-//!
-//! Internally, [`CurrentThread`] maintains a queue. When one of its tasks is
-//! notified, the task gets added to the queue. The executor will pop tasks from
-//! the queue and call [`Future::poll`]. If the task gets notified while it is
-//! being executed, it won't get re-executed until all other tasks currently in
-//! the queue get polled.
-//!
-//! Before the task is polled, a thread-local variable referencing the current
-//! [`CurrentThread`] instance is set. This enables [`spawn`] to spawn new tasks
-//! onto the same executor without having to thread through a handle value.
-//!
-//! If the [`CurrentThread`] instance still has uncompleted tasks, but none of
-//! these tasks are ready to be polled, the current thread is put to sleep. When
-//! a task is notified, the thread is woken up and processing resumes.
-//!
-//! All tasks managed by [`CurrentThread`] remain on the current thread. When a
-//! task completes, it is dropped.
-//!
-//! [`spawn`]: fn.spawn.html
-//! [`block_on_all`]: fn.block_on_all.html
-//! [`CurrentThread`]: struct.CurrentThread.html
-//! [`Future::poll`]: https://docs.rs/futures/0.1/futures/future/trait.Future.html#tymethod.poll
-
-#![allow(deprecated)]
-
-mod scheduler;
-use self::scheduler::Scheduler;
-
-use tokio_executor::{self, Enter, SpawnError};
-use tokio_executor::park::{Park, Unpark, ParkThread};
-
-use futures::{executor, Async, Future};
-use futures::future::{self, Executor, ExecuteError, ExecuteErrorKind};
-
-use std::fmt;
-use std::cell::Cell;
-use std::marker::PhantomData;
-use std::rc::Rc;
-use std::time::{Duration, Instant};
-
-/// Executes tasks on the current thread
-pub struct CurrentThread<P: Park = ParkThread> {
-    /// Execute futures and receive unpark notifications.
-    scheduler: Scheduler<P::Unpark>,
-
-    /// Current number of futures being executed
-    num_futures: usize,
-
-    /// Thread park handle
-    park: P,
-}
-
-/// Executes futures on the current thread.
-///
-/// All futures executed using this executor will be executed on the current
-/// thread. As such, `run` will wait for these futures to complete before
-/// returning.
-///
-/// For more details, see the [module level](index.html) documentation.
-#[derive(Debug, Clone)]
-pub struct TaskExecutor {
-    // Prevent the handle from moving across threads.
-    _p: ::std::marker::PhantomData<Rc<()>>,
-}
-
-/// Returned by the `turn` function
-#[derive(Debug)]
-pub struct Turn(());
-
-/// A `CurrentThread` instance bound to a supplied execution conext.
-pub struct Entered<'a, P: Park + 'a> {
-    executor: &'a mut CurrentThread<P>,
-    enter: &'a mut Enter,
-}
-
-#[deprecated(since = "0.1.2", note = "use block_on_all instead")]
-#[doc(hidden)]
-#[derive(Debug)]
-pub struct Context<'a> {
-    cancel: Cell<bool>,
-    _p: PhantomData<&'a ()>,
-}
-
-/// Error returned by the `run` function.
-#[derive(Debug)]
-pub struct RunError {
-    _p: (),
-}
-
-/// Error returned by the `run_timeout` function.
-#[derive(Debug)]
-pub struct RunTimeoutError {
-    timeout: bool,
-}
-
-/// Error returned by the `turn` function.
-#[derive(Debug)]
-pub struct TurnError {
-    _p: (),
-}
-
-/// Error returned by the `block_on` function.
-#[derive(Debug)]
-pub struct BlockError<T> {
-    inner: Option<T>,
-}
-
-/// This is mostly split out to make the borrow checker happy.
-struct Borrow<'a, U: 'a> {
-    scheduler: &'a mut Scheduler<U>,
-    num_futures: &'a mut usize,
-}
-
-trait SpawnLocal {
-    fn spawn_local(&mut self, future: Box<Future<Item = (), Error = ()>>);
-}
-
-struct CurrentRunner {
-    spawn: Cell<Option<*mut SpawnLocal>>,
-}
-
-/// Current thread's task runner. This is set in `TaskRunner::with`
-thread_local!(static CURRENT: CurrentRunner = CurrentRunner {
-    spawn: Cell::new(None),
-});
-
-#[deprecated(since = "0.1.2", note = "use block_on_all instead")]
-#[doc(hidden)]
-#[allow(deprecated)]
-pub fn run<F, R>(f: F) -> R
-where F: FnOnce(&mut Context) -> R
-{
-    let mut context = Context {
-        cancel: Cell::new(false),
-        _p: PhantomData,
-    };
-
-    let mut current_thread = CurrentThread::new();
-
-    let ret = current_thread
-        .block_on(future::lazy(|| Ok::<_, ()>(f(&mut context))))
-        .unwrap();
-
-    if context.cancel.get() {
-        return ret;
-    }
-
-    current_thread.run().unwrap();
-    ret
-}
-
-/// Run the executor bootstrapping the execution with the provided future.
-///
-/// This creates a new [`CurrentThread`] executor, spawns the provided future,
-/// and blocks the current thread until the provided future and **all**
-/// subsequently spawned futures complete. In other words:
-///
-/// * If the provided boostrap future does **not** spawn any additional tasks,
-///   `block_on_all` returns once `future` completes.
-/// * If the provided bootstrap future **does** spawn additional tasks, then
-///   `block_on_all` returns once **all** spawned futures complete.
-///
-/// See [module level][mod] documentation for more details.
-///
-/// [`CurrentThread`]: struct.CurrentThread.html
-/// [mod]: index.html
-pub fn block_on_all<F>(future: F) -> Result<F::Item, F::Error>
-where F: Future,
-{
-    let mut current_thread = CurrentThread::new();
-
-    let ret = current_thread.block_on(future);
-    current_thread.run().unwrap();
-
-    ret.map_err(|e| e.into_inner().expect("unexpected execution error"))
-}
-
-/// Executes a future on the current thread.
-///
-/// The provided future must complete or be canceled before `run` will return.
-///
-/// Unlike [`tokio::spawn`], this function will always spawn on a
-/// `CurrentThread` executor and is able to spawn futures that are not `Send`.
-///
-/// # Panics
-///
-/// This function can only be invoked from the context of a `run` call; any
-/// other use will result in a panic.
-///
-/// [`tokio::spawn`]: ../fn.spawn.html
-pub fn spawn<F>(future: F)
-where F: Future<Item = (), Error = ()> + 'static
-{
-    TaskExecutor::current()
-        .spawn_local(Box::new(future))
-        .unwrap();
-}
-
-// ===== impl CurrentThread =====
-
-impl CurrentThread<ParkThread> {
-    /// Create a new instance of `CurrentThread`.
-    pub fn new() -> Self {
-        CurrentThread::new_with_park(ParkThread::new())
-    }
-}
-
-impl<P: Park> CurrentThread<P> {
-    /// Create a new instance of `CurrentThread` backed by the given park
-    /// handle.
-    pub fn new_with_park(park: P) -> Self {
-        let unpark = park.unpark();
-
-        CurrentThread {
-            scheduler: Scheduler::new(unpark),
-            num_futures: 0,
-            park,
-        }
-    }
-
-    /// Returns `true` if the executor is currently idle.
-    ///
-    /// An idle executor is defined by not currently having any spawned tasks.
-    pub fn is_idle(&self) -> bool {
-        self.num_futures == 0
-    }
-
-    /// Spawn the future on the executor.
-    ///
-    /// This internally queues the future to be executed once `run` is called.
-    pub fn spawn<F>(&mut self, future: F) -> &mut Self
-    where F: Future<Item = (), Error = ()> + 'static,
-    {
-        self.borrow().spawn_local(Box::new(future));
-        self
-    }
-
-    /// Synchronously waits for the provided `future` to complete.
-    ///
-    /// This function can be used to synchronously block the current thread
-    /// until the provided `future` has resolved either successfully or with an
-    /// error. The result of the future is then returned from this function
-    /// call.
-    ///
-    /// Note that this function will **also** execute any spawned futures on the
-    /// current thread, but will **not** block until these other spawned futures
-    /// have completed.
-    ///
-    /// The caller is responsible for ensuring that other spawned futures
-    /// complete execution.
-    pub fn block_on<F>(&mut self, future: F)
-        -> Result<F::Item, BlockError<F::Error>>
-    where F: Future
-    {
-        let mut enter = tokio_executor::enter().unwrap();
-        self.enter(&mut enter).block_on(future)
-    }
-
-    /// Run the executor to completion, blocking the thread until **all**
-    /// spawned futures have completed.
-    pub fn run(&mut self) -> Result<(), RunError> {
-        let mut enter = tokio_executor::enter().unwrap();
-        self.enter(&mut enter).run()
-    }
-
-    /// Run the executor to completion, blocking the thread until all
-    /// spawned futures have completed **or** `duration` time has elapsed.
-    pub fn run_timeout(&mut self, duration: Duration)
-        -> Result<(), RunTimeoutError>
-    {
-        let mut enter = tokio_executor::enter().unwrap();
-        self.enter(&mut enter).run_timeout(duration)
-    }
-
-    /// Perform a single iteration of the event loop.
-    ///
-    /// This function blocks the current thread even if the executor is idle.
-    pub fn turn(&mut self, duration: Option<Duration>)
-        -> Result<Turn, TurnError>
-    {
-        let mut enter = tokio_executor::enter().unwrap();
-        self.enter(&mut enter).turn(duration)
-    }
-
-    /// Bind `CurrentThread` instance with an execution context.
-    pub fn enter<'a>(&'a mut self, enter: &'a mut Enter) -> Entered<'a, P> {
-        Entered {
-            executor: self,
-            enter,
-        }
-    }
-
-    fn borrow(&mut self) -> Borrow<P::Unpark> {
-        Borrow {
-            scheduler: &mut self.scheduler,
-            num_futures: &mut self.num_futures,
-        }
-    }
-}
-
-impl tokio_executor::Executor for CurrentThread {
-    fn spawn(&mut self, future: Box<Future<Item = (), Error = ()> + Send>)
-        -> Result<(), SpawnError>
-    {
-        self.borrow().spawn_local(future);
-        Ok(())
-    }
-}
-
-impl<P: Park> fmt::Debug for CurrentThread<P> {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        fmt.debug_struct("CurrentThread")
-            .field("scheduler", &self.scheduler)
-            .field("num_futures", &self.num_futures)
-            .finish()
-    }
-}
-
-// ===== impl Entered =====
-
-impl<'a, P: Park> Entered<'a, P> {
-    /// Spawn the future on the executor.
-    ///
-    /// This internally queues the future to be executed once `run` is called.
-    pub fn spawn<F>(&mut self, future: F) -> &mut Self
-    where F: Future<Item = (), Error = ()> + 'static,
-    {
-        self.executor.borrow().spawn_local(Box::new(future));
-        self
-    }
-
-    /// Synchronously waits for the provided `future` to complete.
-    ///
-    /// This function can be used to synchronously block the current thread
-    /// until the provided `future` has resolved either successfully or with an
-    /// error. The result of the future is then returned from this function
-    /// call.
-    ///
-    /// Note that this function will **also** execute any spawned futures on the
-    /// current thread, but will **not** block until these other spawned futures
-    /// have completed.
-    ///
-    /// The caller is responsible for ensuring that other spawned futures
-    /// complete execution.
-    pub fn block_on<F>(&mut self, future: F)
-        -> Result<F::Item, BlockError<F::Error>>
-    where F: Future
-    {
-        let mut future = executor::spawn(future);
-        let notify = self.executor.scheduler.notify();
-
-        loop {
-            let res = self.executor.borrow().enter(self.enter, || {
-                future.poll_future_notify(&notify, 0)
-            });
-
-            match res {
-                Ok(Async::Ready(e)) => return Ok(e),
-                Err(e) => return Err(BlockError { inner: Some(e) }),
-                Ok(Async::NotReady) => {}
-            }
-
-            self.tick();
-
-            if let Err(_) = self.executor.park.park() {
-                return Err(BlockError { inner: None });
-            }
-        }
-    }
-
-    /// Run the executor to completion, blocking the thread until **all**
-    /// spawned futures have completed.
-    pub fn run(&mut self) -> Result<(), RunError> {
-        self.run_timeout2(None)
-            .map_err(|_| RunError { _p: () })
-    }
-
-    /// Run the executor to completion, blocking the thread until all
-    /// spawned futures have completed **or** `duration` time has elapsed.
-    pub fn run_timeout(&mut self, duration: Duration)
-        -> Result<(), RunTimeoutError>
-    {
-        self.run_timeout2(Some(duration))
-    }
-
-    /// Perform a single iteration of the event loop.
-    ///
-    /// This function blocks the current thread even if the executor is idle.
-    pub fn turn(&mut self, duration: Option<Duration>)
-        -> Result<Turn, TurnError>
-    {
-        if !self.tick() {
-            let res = match duration {
-                Some(duration) => self.executor.park.park_timeout(duration),
-                None => self.executor.park.park(),
-            };
-
-            if res.is_err() {
-                return Err(TurnError { _p: () });
-            }
-
-            self.tick();
-        }
-
-        Ok(Turn(()))
-    }
-
-    fn run_timeout2(&mut self, dur: Option<Duration>)
-        -> Result<(), RunTimeoutError>
-    {
-        if self.executor.is_idle() {
-            // Nothing to do
-            return Ok(());
-        }
-
-        let mut time = dur.map(|dur| (Instant::now() + dur, dur));
-
-        loop {
-            self.tick();
-
-            if self.executor.is_idle() {
-                return Ok(());
-            }
-
-            match time {
-                Some((until, rem)) => {
-                    if let Err(_) = self.executor.park.park_timeout(rem) {
-                        return Err(RunTimeoutError::new(false));
-                    }
-
-                    let now = Instant::now();
-
-                    if now >= until {
-                        return Err(RunTimeoutError::new(true));
-                    }
-
-                    time = Some((until, until - now));
-                }
-                None => {
-                    if let Err(_) = self.executor.park.park() {
-                        return Err(RunTimeoutError::new(false));
-                    }
-                }
-            }
-        }
-    }
-
-    /// Returns `true` if any futures were processed
-    fn tick(&mut self) -> bool {
-        self.executor.scheduler.tick(
-            &mut *self.enter,
-            &mut self.executor.num_futures)
-    }
-}
-
-impl<'a, P: Park> fmt::Debug for Entered<'a, P> {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        fmt.debug_struct("Entered")
-            .field("executor", &self.executor)
-            .field("enter", &self.enter)
-            .finish()
-    }
-}
-
-// ===== impl TaskExecutor =====
-
-#[deprecated(since = "0.1.2", note = "use TaskExecutor::current instead")]
-#[doc(hidden)]
-pub fn task_executor() -> TaskExecutor {
-    TaskExecutor {
-        _p: ::std::marker::PhantomData,
-    }
-}
-
-impl TaskExecutor {
-    /// Returns an executor that executes futures on the current thread.
-    ///
-    /// The user of `TaskExecutor` must ensure that when a future is submitted,
-    /// that it is done within the context of a call to `run`.
-    ///
-    /// For more details, see the [module level](index.html) documentation.
-    pub fn current() -> TaskExecutor {
-        TaskExecutor {
-            _p: ::std::marker::PhantomData,
-        }
-    }
-
-    /// Spawn a future onto the current `CurrentThread` instance.
-    pub fn spawn_local(&mut self, future: Box<Future<Item = (), Error = ()>>)
-        -> Result<(), SpawnError>
-    {
-        CURRENT.with(|current| {
-            match current.spawn.get() {
-                Some(spawn) => {
-                    unsafe { (*spawn).spawn_local(future) };
-                    Ok(())
-                }
-                None => {
-                    Err(SpawnError::shutdown())
-                }
-            }
-        })
-    }
-}
-
-impl tokio_executor::Executor for TaskExecutor {
-    fn spawn(&mut self, future: Box<Future<Item = (), Error = ()> + Send>)
-        -> Result<(), SpawnError>
-    {
-        self.spawn_local(future)
-    }
-
-    fn status(&self) -> Result<(), SpawnError> {
-        CURRENT.with(|current| {
-            if current.spawn.get().is_some() {
-                Ok(())
-            } else {
-                Err(SpawnError::shutdown())
-            }
-        })
-    }
-}
-
-impl<F> Executor<F> for TaskExecutor
-where F: Future<Item = (), Error = ()> + 'static
-{
-    fn execute(&self, future: F) -> Result<(), ExecuteError<F>> {
-        CURRENT.with(|current| {
-            match current.spawn.get() {
-                Some(spawn) => {
-                    unsafe { (*spawn).spawn_local(Box::new(future)) };
-                    Ok(())
-                }
-                None => {
-                    Err(ExecuteError::new(ExecuteErrorKind::Shutdown, future))
-                }
-            }
-        })
-    }
-}
-
-// ===== impl Context =====
-
-impl<'a> Context<'a> {
-    /// Cancels *all* executing futures.
-    pub fn cancel_all_spawned(&self) {
-        self.cancel.set(true);
-    }
-}
-
-// ===== impl Borrow =====
-
-impl<'a, U: Unpark> Borrow<'a, U> {
-    fn enter<F, R>(&mut self, _: &mut Enter, f: F) -> R
-    where F: FnOnce() -> R,
-    {
-        CURRENT.with(|current| {
-            current.set_spawn(self, || {
-                f()
-            })
-        })
-    }
-}
-
-impl<'a, U: Unpark> SpawnLocal for Borrow<'a, U> {
-    fn spawn_local(&mut self, future: Box<Future<Item = (), Error = ()>>) {
-        *self.num_futures += 1;
-        self.scheduler.schedule(future);
-    }
-}
-
-// ===== impl CurrentRunner =====
-
-impl CurrentRunner {
-    fn set_spawn<F, R>(&self, spawn: &mut SpawnLocal, f: F) -> R
-    where F: FnOnce() -> R
-    {
-        struct Reset<'a>(&'a CurrentRunner);
-
-        impl<'a> Drop for Reset<'a> {
-            fn drop(&mut self) {
-                self.0.spawn.set(None);
-            }
-        }
-
-        let _reset = Reset(self);
-
-        let spawn = unsafe { hide_lt(spawn as *mut SpawnLocal) };
-        self.spawn.set(Some(spawn));
-
-        f()
-    }
-}
-
-unsafe fn hide_lt<'a>(p: *mut (SpawnLocal + 'a)) -> *mut (SpawnLocal + 'static) {
-    use std::mem;
-    mem::transmute(p)
-}
-
-// ===== impl RunTimeoutError =====
-
-impl RunTimeoutError {
-    fn new(timeout: bool) -> Self {
-        RunTimeoutError { timeout }
-    }
-
-    /// Returns `true` if the error was caused by the operation timeing out.
-    pub fn is_timeout(&self) -> bool {
-        self.timeout
-    }
-}
-
-impl From<tokio_executor::EnterError> for RunTimeoutError {
-    fn from(_: tokio_executor::EnterError) -> Self {
-        RunTimeoutError::new(false)
-    }
-}
-
-// ===== impl BlockError =====
-
-impl<T> BlockError<T> {
-    /// Returns the error yielded by the future being blocked on
-    pub fn into_inner(self) -> Option<T> {
-        self.inner
-    }
-}
-
-impl<T> From<tokio_executor::EnterError> for BlockError<T> {
-    fn from(_: tokio_executor::EnterError) -> Self {
-        BlockError { inner: None }
-    }
-}

src/executor/mod.rs

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

src/lib.rs

@@ -1,189 +0,0 @@
-//! A runtime for writing reliable, asynchronous, and slim applications.
-//!
-//! Tokio is an event-driven, non-blocking I/O platform for writing asynchronous
-//! applications with the Rust programming language. At a high level, it
-//! provides a few major components:
-//!
-//! * A multi threaded, work-stealing based task [scheduler][runtime].
-//! * A [reactor][reactor] backed by the operating system's event queue (epoll, kqueue,
-//!   IOCP, etc...).
-//! * Asynchronous [TCP and UDP][net] sockets.
-//!
-//! Tokio is built using futures (provided by the [futures] crate) as the
-//! abstraction for managing the complexity of asynchronous programming.
-//!
-//! Guide level documentation is found on the [website].
-//!
-//! [website]: https://tokio.rs/docs/getting-started/hello-world/
-//! [futures]: http://docs.rs/futures
-//!
-//! # Examples
-//!
-//! A simple TCP echo server:
-//!
-//! ```no_run
-//! extern crate tokio;
-//!
-//! use tokio::prelude::*;
-//! use tokio::io::copy;
-//! use tokio::net::TcpListener;
-//!
-//! fn main() {
-//!     // Bind the server's socket.
-//!     let addr = "127.0.0.1:12345".parse().unwrap();
-//!     let listener = TcpListener::bind(&addr)
-//!         .expect("unable to bind TCP listener");
-//!
-//!     // Pull out a stream of sockets for incoming connections
-//!     let server = listener.incoming()
-//!         .map_err(|e| eprintln!("accept failed = {:?}", e))
-//!         .for_each(|sock| {
-//!             // Split up the reading and writing parts of the
-//!             // socket.
-//!             let (reader, writer) = sock.split();
-//!
-//!             // A future that echos the data and returns how
-//!             // many bytes were copied...
-//!             let bytes_copied = copy(reader, writer);
-//!
-//!             // ... after which we'll print what happened.
-//!             let handle_conn = bytes_copied.map(|amt| {
-//!                 println!("wrote {:?} bytes", amt)
-//!             }).map_err(|err| {
-//!                 eprintln!("IO error {:?}", err)
-//!             });
-//!
-//!             // Spawn the future as a concurrent task.
-//!             tokio::spawn(handle_conn)
-//!         });
-//!
-//!     // Start the Tokio runtime
-//!     tokio::run(server);
-//! }
-//! ```
-
-#![doc(html_root_url = "https://docs.rs/tokio/0.1.3")]
-#![deny(missing_docs, warnings, missing_debug_implementations)]
-
-extern crate bytes;
-#[macro_use]
-extern crate futures;
-extern crate iovec;
-extern crate mio;
-extern crate slab;
-extern crate tokio_io;
-extern crate tokio_executor;
-extern crate tokio_reactor;
-extern crate tokio_threadpool;
-
-#[macro_use]
-extern crate log;
-
-pub mod executor;
-pub mod net;
-pub mod reactor;
-pub mod runtime;
-
-pub use executor::spawn;
-pub use runtime::run;
-
-pub mod io {
-    //! Asynchronous I/O.
-    //!
-    //! This module is the asynchronous version of `std::io`. Primarily, it
-    //! defines two traits, [`AsyncRead`] and [`AsyncWrite`], which extend the
-    //! `Read` and `Write` traits of the standard library.
-    //!
-    //! [`AsyncRead`] and [`AsyncWrite`] must only be implemented for
-    //! non-blocking I/O types that integrate with the futures type system. In
-    //! other words, these types must never block the thread, and instead the
-    //! current task is notified when the I/O resource is ready.
-    //!
-    //! Utilities functions are provided for working with [`AsyncRead`] /
-    //! [`AsyncWrite`] types. For example, [`copy`] asynchronously copies all
-    //! data from a source to a destination.
-    //!
-    //! Additionally, [`Read`], [`Write`], [`Error`], [`ErrorKind`], and
-    //! [`Result`] are re-exported from `std::io` for ease of use.
-    //!
-    //! [`AsyncRead`]: trait.AsyncRead.html
-    //! [`AsyncWrite`]: trait.AsyncWrite.html
-    //! [`copy`]: fn.copy.html
-    //! [`Read`]: trait.Read.html
-    //! [`Write`]: trait.Write.html
-    //! [`Error`]: struct.Error.html
-    //! [`ErrorKind`]: enum.ErrorKind.html
-    //! [`Result`]: type.Result.html
-
-    pub use tokio_io::{
-        AsyncRead,
-        AsyncWrite,
-    };
-
-    // Utils
-    pub use tokio_io::io::{
-        copy,
-        Copy,
-        flush,
-        Flush,
-        lines,
-        Lines,
-        read_exact,
-        ReadExact,
-        read_to_end,
-        ReadToEnd,
-        read_until,
-        ReadUntil,
-        shutdown,
-        Shutdown,
-        write_all,
-        WriteAll,
-    };
-
-    // Re-export io::Error so that users don't have to deal
-    // with conflicts when `use`ing `futures::io` and `std::io`.
-    pub use ::std::io::{
-        Error,
-        ErrorKind,
-        Result,
-        Read,
-        Write,
-    };
-}
-
-pub mod prelude {
-    //! A "prelude" for users of the `tokio` crate.
-    //!
-    //! This prelude is similar to the standard library's prelude in that you'll
-    //! almost always want to import its entire contents, but unlike the standard
-    //! library's prelude you'll have to do so manually:
-    //!
-    //! ```
-    //! use tokio::prelude::*;
-    //! ```
-    //!
-    //! The prelude may grow over time as additional items see ubiquitous use.
-
-    pub use tokio_io::{
-        AsyncRead,
-        AsyncWrite,
-    };
-
-    pub use ::std::io::{
-        Read,
-        Write,
-    };
-
-    pub use futures::{
-        Future,
-        future,
-        Stream,
-        stream,
-        Sink,
-        IntoFuture,
-        Async,
-        AsyncSink,
-        Poll,
-        task,
-    };
-}

src/net/mod.rs

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

src/net/tcp/listener.rs

@@ -1,213 +0,0 @@
-use net::tcp::Incoming;
-use net::tcp::TcpStream;
-
-use std::fmt;
-use std::io;
-use std::net::{self, SocketAddr};
-
-use futures::{Poll, Async};
-use mio;
-
-use reactor::{Handle, PollEvented2};
-
-/// An I/O object representing a TCP socket listening for incoming connections.
-///
-/// This object can be converted into a stream of incoming connections for
-/// various forms of processing.
-pub struct TcpListener {
-    io: PollEvented2<mio::net::TcpListener>,
-}
-
-impl TcpListener {
-    /// Create a new TCP listener associated with this event loop.
-    ///
-    /// The TCP listener will bind to the provided `addr` address, if available.
-    /// If the result is `Ok`, the socket has successfully bound.
-    pub fn bind(addr: &SocketAddr) -> io::Result<TcpListener> {
-        let l = mio::net::TcpListener::bind(addr)?;
-        Ok(TcpListener::new(l))
-    }
-
-    #[deprecated(since = "0.1.2", note = "use poll_accept instead")]
-    #[doc(hidden)]
-    pub fn accept(&mut self) -> io::Result<(TcpStream, SocketAddr)> {
-        match self.poll_accept()? {
-            Async::Ready(ret) => Ok(ret),
-            Async::NotReady => Err(io::ErrorKind::WouldBlock.into()),
-        }
-    }
-
-    /// Attempt to accept a connection and create a new connected `TcpStream` if
-    /// successful.
-    ///
-    /// Note that typically for simple usage it's easier to treat incoming
-    /// connections as a `Stream` of `TcpStream`s with the `incoming` method
-    /// below.
-    ///
-    /// # Return
-    ///
-    /// On success, returns `Ok(Async::Ready((socket, addr)))`.
-    ///
-    /// If the listener is not ready to accept, the method returns
-    /// `Ok(Async::NotReady)` and arranges for the current task to receive a
-    /// notification when the listener becomes ready to accept.
-    ///
-    /// # Panics
-    ///
-    /// This function will panic if called from outside of a task context.
-    pub fn poll_accept(&mut self) -> Poll<(TcpStream, SocketAddr), io::Error> {
-        let (io, addr) = try_ready!(self.poll_accept_std());
-
-        let io = mio::net::TcpStream::from_stream(io)?;
-        let io = TcpStream::new(io);
-
-        Ok((io, addr).into())
-    }
-
-    #[deprecated(since = "0.1.2", note = "use poll_accept_std instead")]
-    #[doc(hidden)]
-    pub fn accept_std(&mut self) -> io::Result<(net::TcpStream, SocketAddr)> {
-        match self.poll_accept_std()? {
-            Async::Ready(ret) => Ok(ret),
-            Async::NotReady => Err(io::ErrorKind::WouldBlock.into()),
-        }
-    }
-
-    /// Attempt to accept a connection and create a new connected `TcpStream` if
-    /// successful.
-    ///
-    /// This function is the asme as `accept` above except that it returns a
-    /// `std::net::TcpStream` instead of a `tokio::net::TcpStream`. This in turn
-    /// can then allow for the TCP stream to be assoiated with a different
-    /// reactor than the one this `TcpListener` is associated with.
-    ///
-    /// # Return
-    ///
-    /// On success, returns `Ok(Async::Ready((socket, addr)))`.
-    ///
-    /// If the listener is not ready to accept, the method returns
-    /// `Ok(Async::NotReady)` and arranges for the current task to receive a
-    /// notification when the listener becomes ready to accept.
-    ///
-    /// # Panics
-    ///
-    /// This function will panic if called from outside of a task context.
-    pub fn poll_accept_std(&mut self) -> Poll<(net::TcpStream, SocketAddr), io::Error> {
-        try_ready!(self.io.poll_read_ready(mio::Ready::readable()));
-
-        match self.io.get_ref().accept_std() {
-            Ok(pair) => Ok(pair.into()),
-            Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
-                self.io.clear_read_ready(mio::Ready::readable())?;
-                Ok(Async::NotReady)
-            }
-            Err(e) => Err(e),
-        }
-    }
-
-    /// Create a new TCP listener from the standard library's TCP listener.
-    ///
-    /// This method can be used when the `Handle::tcp_listen` method isn't
-    /// sufficient because perhaps some more configuration is needed in terms of
-    /// before the calls to `bind` and `listen`.
-    ///
-    /// This API is typically paired with the `net2` crate and the `TcpBuilder`
-    /// type to build up and customize a listener before it's shipped off to the
-    /// backing event loop. This allows configuration of options like
-    /// `SO_REUSEPORT`, binding to multiple addresses, etc.
-    ///
-    /// The `addr` argument here is one of the addresses that `listener` is
-    /// bound to and the listener will only be guaranteed to accept connections
-    /// of the same address type currently.
-    ///
-    /// Finally, the `handle` argument is the event loop that this listener will
-    /// be bound to.
-    ///
-    /// The platform specific behavior of this function looks like:
-    ///
-    /// * On Unix, the socket is placed into nonblocking mode and connections
-    ///   can be accepted as normal
-    ///
-    /// * On Windows, the address is stored internally and all future accepts
-    ///   will only be for the same IP version as `addr` specified. That is, if
-    ///   `addr` is an IPv4 address then all sockets accepted will be IPv4 as
-    ///   well (same for IPv6).
-    pub fn from_std(listener: net::TcpListener, handle: &Handle)
-        -> io::Result<TcpListener>
-    {
-        let io = mio::net::TcpListener::from_std(listener)?;
-        let io = PollEvented2::new_with_handle(io, handle)?;
-        Ok(TcpListener { io })
-    }
-
-    fn new(listener: mio::net::TcpListener) -> TcpListener {
-        let io = PollEvented2::new(listener);
-        TcpListener { io }
-    }
-
-    /// Returns the local address that this listener is bound to.
-    ///
-    /// This can be useful, for example, when binding to port 0 to figure out
-    /// which port was actually bound.
-    pub fn local_addr(&self) -> io::Result<SocketAddr> {
-        self.io.get_ref().local_addr()
-    }
-
-    /// Consumes this listener, returning a stream of the sockets this listener
-    /// accepts.
-    ///
-    /// This method returns an implementation of the `Stream` trait which
-    /// resolves to the sockets the are accepted on this listener.
-    pub fn incoming(self) -> Incoming {
-        Incoming::new(self)
-    }
-
-    /// Gets the value of the `IP_TTL` option for this socket.
-    ///
-    /// For more information about this option, see [`set_ttl`].
-    ///
-    /// [`set_ttl`]: #method.set_ttl
-    pub fn ttl(&self) -> io::Result<u32> {
-        self.io.get_ref().ttl()
-    }
-
-    /// Sets the value for the `IP_TTL` option on this socket.
-    ///
-    /// This value sets the time-to-live field that is used in every packet sent
-    /// from this socket.
-    pub fn set_ttl(&self, ttl: u32) -> io::Result<()> {
-        self.io.get_ref().set_ttl(ttl)
-    }
-}
-
-impl fmt::Debug for TcpListener {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.io.get_ref().fmt(f)
-    }
-}
-
-#[cfg(all(unix, not(target_os = "fuchsia")))]
-mod sys {
-    use std::os::unix::prelude::*;
-    use super::TcpListener;
-
-    impl AsRawFd for TcpListener {
-        fn as_raw_fd(&self) -> RawFd {
-            self.io.get_ref().as_raw_fd()
-        }
-    }
-}
-
-#[cfg(windows)]
-mod sys {
-    // TODO: let's land these upstream with mio and then we can add them here.
-    //
-    // use std::os::windows::prelude::*;
-    // use super::{TcpListener;
-    //
-    // impl AsRawHandle for TcpListener {
-    //     fn as_raw_handle(&self) -> RawHandle {
-    //         self.listener.io().as_raw_handle()
-    //     }
-    // }
-}

src/net/tcp/mod.rs

@@ -1,8 +0,0 @@
-mod incoming;
-mod listener;
-mod stream;
-
-pub use self::incoming::Incoming;
-pub use self::listener::TcpListener;
-pub use self::stream::TcpStream;
-pub use self::stream::ConnectFuture;

src/net/tcp/stream.rs

@@ -1,565 +0,0 @@
-use std::fmt;
-use std::io::{self, Read, Write};
-use std::mem;
-use std::net::{self, SocketAddr, Shutdown};
-use std::time::Duration;
-
-use bytes::{Buf, BufMut};
-use futures::{Future, Poll, Async};
-use iovec::IoVec;
-use mio;
-use tokio_io::{AsyncRead, AsyncWrite};
-
-use reactor::{Handle, PollEvented2};
-
-/// An I/O object representing a TCP stream connected to a remote endpoint.
-///
-/// A TCP stream can either be created by connecting to an endpoint, via the
-/// [`connect`] method, or by [accepting] a connection from a [listener].
-///
-/// [`connect`]: struct.TcpStream.html#method.connect
-/// [accepting]: struct.TcpListener.html#method.accept
-/// [listener]: struct.TcpListener.html
-pub struct TcpStream {
-    io: PollEvented2<mio::net::TcpStream>,
-}
-
-/// Future returned by `TcpStream::connect` which will resolve to a `TcpStream`
-/// when the stream is connected.
-#[must_use = "futures do nothing unless polled"]
-#[derive(Debug)]
-pub struct ConnectFuture {
-    inner: ConnectFutureState,
-}
-
-#[must_use = "futures do nothing unless polled"]
-#[derive(Debug)]
-enum ConnectFutureState {
-    Waiting(TcpStream),
-    Error(io::Error),
-    Empty,
-}
-
-impl TcpStream {
-    /// Create a new TCP stream connected to the specified address.
-    ///
-    /// This function will create a new TCP socket and attempt to connect it to
-    /// the `addr` provided. The returned future will be resolved once the
-    /// stream has successfully connected, or it wil return an error if one
-    /// occurs.
-    pub fn connect(addr: &SocketAddr) -> ConnectFuture {
-        use self::ConnectFutureState::*;
-
-        let inner = match mio::net::TcpStream::connect(addr) {
-            Ok(tcp) => Waiting(TcpStream::new(tcp)),
-            Err(e) => Error(e),
-        };
-
-        ConnectFuture { inner }
-    }
-
-    pub(crate) fn new(connected: mio::net::TcpStream) -> TcpStream {
-        let io = PollEvented2::new(connected);
-        TcpStream { io }
-    }
-
-    /// Create a new `TcpStream` from a `net::TcpStream`.
-    ///
-    /// This function will convert a TCP stream created by the standard library
-    /// to a TCP stream ready to be used with the provided event loop handle.
-    /// The stream returned is associated with the event loop and ready to
-    /// perform I/O.
-    pub fn from_std(stream: net::TcpStream, handle: &Handle)
-        -> io::Result<TcpStream>
-    {
-        let io = mio::net::TcpStream::from_stream(stream)?;
-        let io = PollEvented2::new_with_handle(io, handle)?;
-
-        Ok(TcpStream { io })
-    }
-
-    /// Creates a new `TcpStream` from the pending socket inside the given
-    /// `std::net::TcpStream`, connecting it to the address specified.
-    ///
-    /// This constructor allows configuring the socket before it's actually
-    /// connected, and this function will transfer ownership to the returned
-    /// `TcpStream` if successful. An unconnected `TcpStream` can be created
-    /// with the `net2::TcpBuilder` type (and also configured via that route).
-    ///
-    /// The platform specific behavior of this function looks like:
-    ///
-    /// * On Unix, the socket is placed into nonblocking mode and then a
-    ///   `connect` call is issued.
-    ///
-    /// * On Windows, the address is stored internally and the connect operation
-    ///   is issued when the returned `TcpStream` is registered with an event
-    ///   loop. Note that on Windows you must `bind` a socket before it can be
-    ///   connected, so if a custom `TcpBuilder` is used it should be bound
-    ///   (perhaps to `INADDR_ANY`) before this method is called.
-    pub fn connect_std(stream: net::TcpStream,
-                       addr: &SocketAddr,
-                       handle: &Handle)
-        -> ConnectFuture
-    {
-        use self::ConnectFutureState::*;
-
-        let io = mio::net::TcpStream::connect_stream(stream, addr)
-            .and_then(|io| PollEvented2::new_with_handle(io, handle));
-
-        let inner = match io {
-            Ok(io) => Waiting(TcpStream { io }),
-            Err(e) => Error(e),
-        };
-
-        ConnectFuture { inner: inner }
-    }
-
-    /// Check the TCP stream's read readiness state.
-    ///
-    /// The mask argument allows specifying what readiness to notify on. This
-    /// can be any value, including platform specific readiness, **except**
-    /// `writable`. HUP is always implicitly included on platforms that support
-    /// it.
-    ///
-    /// If the resource is not ready for a read then `Async::NotReady` is
-    /// returned and the current task is notified once a new event is received.
-    ///
-    /// The stream will remain in a read-ready state until calls to `poll_read`
-    /// return `NotReady`.
-    ///
-    /// # Panics
-    ///
-    /// This function panics if:
-    ///
-    /// * `ready` includes writable.
-    /// * called from outside of a task context.
-    pub fn poll_read_ready(&self, mask: mio::Ready) -> Poll<mio::Ready, io::Error> {
-        self.io.poll_read_ready(mask)
-    }
-
-    /// Check the TCP stream's write readiness state.
-    ///
-    /// This always checks for writable readiness and also checks for HUP
-    /// readiness on platforms that support it.
-    ///
-    /// If the resource is not ready for a write then `Async::NotReady` is
-    /// returned and the current task is notified once a new event is received.
-    ///
-    /// The I/O resource will remain in a write-ready state until calls to
-    /// `poll_write` return `NotReady`.
-    ///
-    /// # Panics
-    ///
-    /// This function panics if:
-    ///
-    /// * `ready` contains bits besides `writable` and `hup`.
-    /// * called from outside of a task context.
-    pub fn poll_write_ready(&self) -> Poll<mio::Ready, io::Error> {
-        self.io.poll_write_ready()
-    }
-
-    /// Returns the local address that this stream is bound to.
-    pub fn local_addr(&self) -> io::Result<SocketAddr> {
-        self.io.get_ref().local_addr()
-    }
-
-    /// Returns the remote address that this stream is connected to.
-    pub fn peer_addr(&self) -> io::Result<SocketAddr> {
-        self.io.get_ref().peer_addr()
-    }
-
-    #[deprecated(since = "0.1.2", note = "use poll_peek instead")]
-    #[doc(hidden)]
-    pub fn peek(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        match self.poll_peek(buf)? {
-            Async::Ready(n) => Ok(n),
-            Async::NotReady => Err(io::ErrorKind::WouldBlock.into()),
-        }
-    }
-
-    /// Receives data on the socket from the remote address to which it is
-    /// connected, without removing that data from the queue. On success,
-    /// returns the number of bytes peeked.
-    ///
-    /// Successive calls return the same data. This is accomplished by passing
-    /// `MSG_PEEK` as a flag to the underlying recv system call.
-    ///
-    /// # Return
-    ///
-    /// On success, returns `Ok(Async::Ready(num_bytes_read))`.
-    ///
-    /// If no data is available for reading, the method returns
-    /// `Ok(Async::NotReady)` and arranges for the current task to receive a
-    /// notification when the socket becomes readable or is closed.
-    ///
-    /// # Panics
-    ///
-    /// This function will panic if called from outside of a task context.
-    pub fn poll_peek(&mut self, buf: &mut [u8]) -> Poll<usize, io::Error> {
-        try_ready!(self.io.poll_read_ready(mio::Ready::readable()));
-
-        match self.io.get_ref().peek(buf) {
-            Ok(ret) => Ok(ret.into()),
-            Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
-                self.io.clear_read_ready(mio::Ready::readable())?;
-                Ok(Async::NotReady)
-            }
-            Err(e) => Err(e),
-        }
-    }
-
-    /// Shuts down the read, write, or both halves of this connection.
-    ///
-    /// This function will cause all pending and future I/O on the specified
-    /// portions to return immediately with an appropriate value (see the
-    /// documentation of `Shutdown`).
-    pub fn shutdown(&self, how: Shutdown) -> io::Result<()> {
-        self.io.get_ref().shutdown(how)
-    }
-
-    /// Gets the value of the `TCP_NODELAY` option on this socket.
-    ///
-    /// For more information about this option, see [`set_nodelay`].
-    ///
-    /// [`set_nodelay`]: #method.set_nodelay
-    pub fn nodelay(&self) -> io::Result<bool> {
-        self.io.get_ref().nodelay()
-    }
-
-    /// Sets the value of the `TCP_NODELAY` option on this socket.
-    ///
-    /// If set, this option disables the Nagle algorithm. This means that
-    /// segments are always sent as soon as possible, even if there is only a
-    /// small amount of data. When not set, data is buffered until there is a
-    /// sufficient amount to send out, thereby avoiding the frequent sending of
-    /// small packets.
-    pub fn set_nodelay(&self, nodelay: bool) -> io::Result<()> {
-        self.io.get_ref().set_nodelay(nodelay)
-    }
-
-    /// Gets the value of the `SO_RCVBUF` option on this socket.
-    ///
-    /// For more information about this option, see [`set_recv_buffer_size`].
-    ///
-    /// [`set_recv_buffer_size`]: #tymethod.set_recv_buffer_size
-    pub fn recv_buffer_size(&self) -> io::Result<usize> {
-        self.io.get_ref().recv_buffer_size()
-    }
-
-    /// Sets the value of the `SO_RCVBUF` option on this socket.
-    ///
-    /// Changes the size of the operating system's receive buffer associated
-    /// with the socket.
-    pub fn set_recv_buffer_size(&self, size: usize) -> io::Result<()> {
-        self.io.get_ref().set_recv_buffer_size(size)
-    }
-
-    /// Gets the value of the `SO_SNDBUF` option on this socket.
-    ///
-    /// For more information about this option, see [`set_send_buffer`].
-    ///
-    /// [`set_send_buffer`]: #tymethod.set_send_buffer
-    pub fn send_buffer_size(&self) -> io::Result<usize> {
-        self.io.get_ref().send_buffer_size()
-    }
-
-    /// Sets the value of the `SO_SNDBUF` option on this socket.
-    ///
-    /// Changes the size of the operating system's send buffer associated with
-    /// the socket.
-    pub fn set_send_buffer_size(&self, size: usize) -> io::Result<()> {
-        self.io.get_ref().set_send_buffer_size(size)
-    }
-
-    /// Returns whether keepalive messages are enabled on this socket, and if so
-    /// the duration of time between them.
-    ///
-    /// For more information about this option, see [`set_keepalive`].
-    ///
-    /// [`set_keepalive`]: #tymethod.set_keepalive
-    pub fn keepalive(&self) -> io::Result<Option<Duration>> {
-        self.io.get_ref().keepalive()
-    }
-
-    /// Sets whether keepalive messages are enabled to be sent on this socket.
-    ///
-    /// On Unix, this option will set the `SO_KEEPALIVE` as well as the
-    /// `TCP_KEEPALIVE` or `TCP_KEEPIDLE` option (depending on your platform).
-    /// On Windows, this will set the `SIO_KEEPALIVE_VALS` option.
-    ///
-    /// If `None` is specified then keepalive messages are disabled, otherwise
-    /// the duration specified will be the time to remain idle before sending a
-    /// TCP keepalive probe.
-    ///
-    /// Some platforms specify this value in seconds, so sub-second
-    /// specifications may be omitted.
-    pub fn set_keepalive(&self, keepalive: Option<Duration>) -> io::Result<()> {
-        self.io.get_ref().set_keepalive(keepalive)
-    }
-
-    /// Gets the value of the `IP_TTL` option for this socket.
-    ///
-    /// For more information about this option, see [`set_ttl`].
-    ///
-    /// [`set_ttl`]: #tymethod.set_ttl
-    pub fn ttl(&self) -> io::Result<u32> {
-        self.io.get_ref().ttl()
-    }
-
-    /// Sets the value for the `IP_TTL` option on this socket.
-    ///
-    /// This value sets the time-to-live field that is used in every packet sent
-    /// from this socket.
-    pub fn set_ttl(&self, ttl: u32) -> io::Result<()> {
-        self.io.get_ref().set_ttl(ttl)
-    }
-
-    /// Reads the linger duration for this socket by getting the `SO_LINGER`
-    /// option.
-    ///
-    /// For more information about this option, see [`set_linger`].
-    ///
-    /// [`set_linger`]: #tymethod.set_linger
-    pub fn linger(&self) -> io::Result<Option<Duration>> {
-        self.io.get_ref().linger()
-    }
-
-    /// Sets the linger duration of this socket by setting the `SO_LINGER`
-    /// option.
-    ///
-    /// This option controls the action taken when a stream has unsent messages
-    /// and the stream is closed. If `SO_LINGER` is set, the system
-    /// shall block the process  until it can transmit the data or until the
-    /// time expires.
-    ///
-    /// If `SO_LINGER` is not specified, and the stream is closed, the system
-    /// handles the call in a way that allows the process to continue as quickly
-    /// as possible.
-    pub fn set_linger(&self, dur: Option<Duration>) -> io::Result<()> {
-        self.io.get_ref().set_linger(dur)
-    }
-}
-
-// ===== impl Read / Write =====
-
-impl Read for TcpStream {
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        self.io.read(buf)
-    }
-}
-
-impl Write for TcpStream {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.io.write(buf)
-    }
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-impl AsyncRead for TcpStream {
-    unsafe fn prepare_uninitialized_buffer(&self, _: &mut [u8]) -> bool {
-        false
-    }
-
-    fn read_buf<B: BufMut>(&mut self, buf: &mut B) -> Poll<usize, io::Error> {
-        <&TcpStream>::read_buf(&mut &*self, buf)
-    }
-}
-
-impl AsyncWrite for TcpStream {
-    fn shutdown(&mut self) -> Poll<(), io::Error> {
-        <&TcpStream>::shutdown(&mut &*self)
-    }
-
-    fn write_buf<B: Buf>(&mut self, buf: &mut B) -> Poll<usize, io::Error> {
-        <&TcpStream>::write_buf(&mut &*self, buf)
-    }
-}
-
-// ===== impl Read / Write for &'a =====
-
-impl<'a> Read for &'a TcpStream {
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        (&self.io).read(buf)
-    }
-}
-
-impl<'a> Write for &'a TcpStream {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        (&self.io).write(buf)
-    }
-
-    fn flush(&mut self) -> io::Result<()> {
-        (&self.io).flush()
-    }
-}
-
-impl<'a> AsyncRead for &'a TcpStream {
-    unsafe fn prepare_uninitialized_buffer(&self, _: &mut [u8]) -> bool {
-        false
-    }
-
-    fn read_buf<B: BufMut>(&mut self, buf: &mut B) -> Poll<usize, io::Error> {
-        if let Async::NotReady = self.io.poll_read_ready(mio::Ready::readable())? {
-            return Ok(Async::NotReady)
-        }
-
-        let r = unsafe {
-            // The `IoVec` type can't have a 0-length size, so we create a bunch
-            // of dummy versions on the stack with 1 length which we'll quickly
-            // overwrite.
-            let b1: &mut [u8] = &mut [0];
-            let b2: &mut [u8] = &mut [0];
-            let b3: &mut [u8] = &mut [0];
-            let b4: &mut [u8] = &mut [0];
-            let b5: &mut [u8] = &mut [0];
-            let b6: &mut [u8] = &mut [0];
-            let b7: &mut [u8] = &mut [0];
-            let b8: &mut [u8] = &mut [0];
-            let b9: &mut [u8] = &mut [0];
-            let b10: &mut [u8] = &mut [0];
-            let b11: &mut [u8] = &mut [0];
-            let b12: &mut [u8] = &mut [0];
-            let b13: &mut [u8] = &mut [0];
-            let b14: &mut [u8] = &mut [0];
-            let b15: &mut [u8] = &mut [0];
-            let b16: &mut [u8] = &mut [0];
-            let mut bufs: [&mut IoVec; 16] = [
-                b1.into(), b2.into(), b3.into(), b4.into(),
-                b5.into(), b6.into(), b7.into(), b8.into(),
-                b9.into(), b10.into(), b11.into(), b12.into(),
-                b13.into(), b14.into(), b15.into(), b16.into(),
-            ];
-            let n = buf.bytes_vec_mut(&mut bufs);
-            self.io.get_ref().read_bufs(&mut bufs[..n])
-        };
-
-        match r {
-            Ok(n) => {
-                unsafe { buf.advance_mut(n); }
-                Ok(Async::Ready(n))
-            }
-            Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
-                self.io.clear_read_ready(mio::Ready::readable())?;
-                Ok(Async::NotReady)
-            }
-            Err(e) => Err(e),
-        }
-    }
-}
-
-impl<'a> AsyncWrite for &'a TcpStream {
-    fn shutdown(&mut self) -> Poll<(), io::Error> {
-        Ok(().into())
-    }
-
-    fn write_buf<B: Buf>(&mut self, buf: &mut B) -> Poll<usize, io::Error> {
-        if let Async::NotReady = self.io.poll_write_ready()? {
-            return Ok(Async::NotReady)
-        }
-
-        let r = {
-            // The `IoVec` type can't have a zero-length size, so create a dummy
-            // version from a 1-length slice which we'll overwrite with the
-            // `bytes_vec` method.
-            static DUMMY: &[u8] = &[0];
-            let iovec = <&IoVec>::from(DUMMY);
-            let mut bufs = [iovec; 64];
-            let n = buf.bytes_vec(&mut bufs);
-            self.io.get_ref().write_bufs(&bufs[..n])
-        };
-        match r {
-            Ok(n) => {
-                buf.advance(n);
-                Ok(Async::Ready(n))
-            }
-            Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
-                self.io.clear_write_ready()?;
-                Ok(Async::NotReady)
-            }
-            Err(e) => Err(e),
-        }
-    }
-}
-
-impl fmt::Debug for TcpStream {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.io.get_ref().fmt(f)
-    }
-}
-
-
-impl Future for ConnectFuture {
-    type Item = TcpStream;
-    type Error = io::Error;
-
-    fn poll(&mut self) -> Poll<TcpStream, io::Error> {
-        self.inner.poll()
-    }
-}
-
-impl Future for ConnectFutureState {
-    type Item = TcpStream;
-    type Error = io::Error;
-
-    fn poll(&mut self) -> Poll<TcpStream, io::Error> {
-        {
-            let stream = match *self {
-                ConnectFutureState::Waiting(ref mut s) => s,
-                ConnectFutureState::Error(_) => {
-                    let e = match mem::replace(self, ConnectFutureState::Empty) {
-                        ConnectFutureState::Error(e) => e,
-                        _ => panic!(),
-                    };
-                    return Err(e)
-                }
-                ConnectFutureState::Empty => panic!("can't poll TCP stream twice"),
-            };
-
-            // Once we've connected, wait for the stream to be writable as
-            // that's when the actual connection has been initiated. Once we're
-            // writable we check for `take_socket_error` to see if the connect
-            // actually hit an error or not.
-            //
-            // If all that succeeded then we ship everything on up.
-            if let Async::NotReady = stream.io.poll_write_ready()? {
-                return Ok(Async::NotReady)
-            }
-
-            if let Some(e) = try!(stream.io.get_ref().take_error()) {
-                return Err(e)
-            }
-        }
-        match mem::replace(self, ConnectFutureState::Empty) {
-            ConnectFutureState::Waiting(stream) => Ok(Async::Ready(stream)),
-            _ => panic!(),
-        }
-    }
-}
-
-#[cfg(all(unix, not(target_os = "fuchsia")))]
-mod sys {
-    use std::os::unix::prelude::*;
-    use super::TcpStream;
-
-    impl AsRawFd for TcpStream {
-        fn as_raw_fd(&self) -> RawFd {
-            self.io.get_ref().as_raw_fd()
-        }
-    }
-}
-
-#[cfg(windows)]
-mod sys {
-    // TODO: let's land these upstream with mio and then we can add them here.
-    //
-    // use std::os::windows::prelude::*;
-    // use super::TcpStream;
-    //
-    // impl AsRawHandle for TcpStream {
-    //     fn as_raw_handle(&self) -> RawHandle {
-    //         self.io.get_ref().as_raw_handle()
-    //     }
-    // }
-}

src/net/udp/mod.rs

@@ -1,9 +0,0 @@
-mod frame;
-mod socket;
-mod send_dgram;
-mod recv_dgram;
-
-pub use self::frame::UdpFramed;
-pub use self::socket::UdpSocket;
-pub use self::send_dgram::SendDgram;
-pub use self::recv_dgram::RecvDgram;

src/net/udp/recv_dgram.rs

@@ -1,52 +0,0 @@
-use net::udp::socket::UdpSocket;
-
-use std::io;
-use std::net::SocketAddr;
-
-use futures::{Async, Future, Poll};
-
-/// A future used to receive a datagram from a UDP socket.
-///
-/// This is created by the `UdpSocket::recv_dgram` method.
-#[must_use = "futures do nothing unless polled"]
-#[derive(Debug)]
-pub struct RecvDgram<T> {
-    /// None means future was completed
-    state: Option<RecvDgramInner<T>>
-}
-
-/// A struct is used to represent the full info of RecvDgram.
-#[derive(Debug)]
-struct RecvDgramInner<T> {
-    /// Rx socket
-    socket: UdpSocket,
-    /// The received data will be put in the buffer
-    buffer: T
-}
-
-impl<T> RecvDgram<T> {
-    /// Create a new future to receive UDP Datagram
-    pub(crate) fn new(socket: UdpSocket, buffer: T) -> RecvDgram<T> {
-        let inner = RecvDgramInner { socket: socket, buffer: buffer };
-        RecvDgram { state: Some(inner) }
-    }
-}
-
-impl<T> Future for RecvDgram<T>
-    where T: AsMut<[u8]>,
-{
-    type Item = (UdpSocket, T, usize, SocketAddr);
-    type Error = io::Error;
-
-    fn poll(&mut self) -> Poll<Self::Item, io::Error> {
-        let (n, addr) = {
-            let ref mut inner =
-                self.state.as_mut().expect("RecvDgram polled after completion");
-
-            try_ready!(inner.socket.poll_recv_from(inner.buffer.as_mut()))
-        };
-
-        let inner = self.state.take().unwrap();
-        Ok(Async::Ready((inner.socket, inner.buffer, n, addr)))
-    }
-}

src/net/udp/send_dgram.rs

@@ -1,61 +0,0 @@
-use net::udp::socket::UdpSocket;
-
-use std::io;
-use std::net::SocketAddr;
-
-use futures::{Async, Future, Poll};
-
-/// A future used to write the entire contents of some data to a UDP socket.
-///
-/// This is created by the `UdpSocket::send_dgram` method.
-#[must_use = "futures do nothing unless polled"]
-#[derive(Debug)]
-pub struct SendDgram<T> {
-    /// None means future was completed
-    state: Option<SendDgramInner<T>>
-}
-
-/// A struct is used to represent the full info of SendDgram.
-#[derive(Debug)]
-struct SendDgramInner<T> {
-    /// Tx socket
-    socket: UdpSocket,
-    /// The whole buffer will be sent
-    buffer: T,
-    /// Destination addr
-    addr: SocketAddr,
-}
-
-impl<T> SendDgram<T> {
-    /// Create a new future to send UDP Datagram
-    pub(crate) fn new(socket: UdpSocket, buffer: T, addr: SocketAddr) -> SendDgram<T> {
-        let inner = SendDgramInner { socket: socket, buffer: buffer, addr: addr };
-        SendDgram { state: Some(inner) }
-    }
-}
-
-fn incomplete_write(reason: &str) -> io::Error {
-    io::Error::new(io::ErrorKind::Other, reason)
-}
-
-impl<T> Future for SendDgram<T>
-    where T: AsRef<[u8]>,
-{
-    type Item = (UdpSocket, T);
-    type Error = io::Error;
-
-    fn poll(&mut self) -> Poll<(UdpSocket, T), io::Error> {
-        {
-            let ref mut inner =
-                self.state.as_mut().expect("SendDgram polled after completion");
-            let n = try_ready!(inner.socket.poll_send_to(inner.buffer.as_ref(), &inner.addr));
-            if n != inner.buffer.as_ref().len() {
-                return Err(incomplete_write("failed to send entire message \
-                                             in datagram"))
-            }
-        }
-
-        let inner = self.state.take().unwrap();
-        Ok(Async::Ready((inner.socket, inner.buffer)))
-    }
-}

src/reactor/poll_evented.rs

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

src/runtime.rs

@@ -1,444 +0,0 @@
-//! A batteries included runtime for applications using Tokio.
-//!
-//! Applications using Tokio require some runtime support in order to work:
-//!
-//! * A [reactor] to drive I/O resources.
-//! * An [executor] to execute tasks that use these I/O resources.
-//!
-//! While it is possible to setup each component manually, this involves a bunch
-//! of boilerplate.
-//!
-//! [`Runtime`] bundles all of these various runtime components into a single
-//! handle that can be started and shutdown together, eliminating the necessary
-//! boilerplate to run a Tokio application.
-//!
-//! Most applications wont need to use [`Runtime`] directly. Instead, they will
-//! use the [`run`] function, which uses [`Runtime`] under the hood.
-//!
-//! Creating a [`Runtime`] does the following:
-//!
-//! * Spawn a background thread running a [`Reactor`] instance.
-//! * Start a [`ThreadPool`] for executing futures.
-//!
-//! The thread pool uses a work-stealing strategy and is configured to start a
-//! worker thread for each CPU core available on the system. This tends to be
-//! the ideal setup for Tokio applications.
-//!
-//! # Usage
-//!
-//! Most applications will use the [`run`] function. This takes a future to
-//! "seed" the application, blocking the thread until the runtime becomes
-//! [idle].
-//!
-//! ```rust
-//! # extern crate tokio;
-//! # extern crate futures;
-//! # use futures::{Future, Stream};
-//! use tokio::net::TcpListener;
-//!
-//! # fn process<T>(_: T) -> Box<Future<Item = (), Error = ()> + Send> {
-//! # unimplemented!();
-//! # }
-//! # fn dox() {
-//! # let addr = "127.0.0.1:8080".parse().unwrap();
-//! let listener = TcpListener::bind(&addr).unwrap();
-//!
-//! let server = listener.incoming()
-//!     .map_err(|e| println!("error = {:?}", e))
-//!     .for_each(|socket| {
-//!         tokio::spawn(process(socket))
-//!     });
-//!
-//! tokio::run(server);
-//! # }
-//! # pub fn main() {}
-//! ```
-//!
-//! In this function, the `run` function blocks until the runtime becomes idle.
-//! See [`shutdown_on_idle`][idle] for more shutdown details.
-//!
-//! From within the context of the runtime, additional tasks are spawned using
-//! the [`tokio::spawn`] function. Futures spawned using this function will be
-//! executed on the same thread pool used by the [`Runtime`].
-//!
-//! A [`Runtime`] instance can also be used directly.
-//!
-//! ```rust
-//! # extern crate tokio;
-//! # extern crate futures;
-//! # use futures::{Future, Stream};
-//! use tokio::runtime::Runtime;
-//! use tokio::net::TcpListener;
-//!
-//! # fn process<T>(_: T) -> Box<Future<Item = (), Error = ()> + Send> {
-//! # unimplemented!();
-//! # }
-//! # fn dox() {
-//! # let addr = "127.0.0.1:8080".parse().unwrap();
-//! let listener = TcpListener::bind(&addr).unwrap();
-//!
-//! let server = listener.incoming()
-//!     .map_err(|e| println!("error = {:?}", e))
-//!     .for_each(|socket| {
-//!         tokio::spawn(process(socket))
-//!     });
-//!
-//! // Create the runtime
-//! let mut rt = Runtime::new().unwrap();
-//!
-//! // Spawn the server task
-//! rt.spawn(server);
-//!
-//! // Wait until the runtime becomes idle and shut it down.
-//! rt.shutdown_on_idle()
-//!     .wait().unwrap();
-//! # }
-//! # pub fn main() {}
-//! ```
-//!
-//! [reactor]: ../reactor/struct.Reactor.html
-//! [executor]: https://tokio.rs/docs/getting-started/runtime-model/#executors
-//! [`Runtime`]: struct.Runtime.html
-//! [`ThreadPool`]: ../executor/thread_pool/struct.ThreadPool.html
-//! [`run`]: fn.run.html
-//! [idle]: struct.Runtime.html#method.shutdown_on_idle
-//! [`tokio::spawn`]: ../executor/fn.spawn.html
-
-use reactor::{Reactor, Handle, Background};
-
-use tokio_threadpool::{self as threadpool, ThreadPool, Sender};
-use futures::Poll;
-use futures::future::{self, Future};
-
-use std::{fmt, io};
-
-/// Handle to the Tokio runtime.
-///
-/// The Tokio runtime includes a reactor as well as an executor for running
-/// tasks.
-///
-/// See [module level][mod] documentation for more details.
-///
-/// [mod]: index.html
-#[derive(Debug)]
-pub struct Runtime {
-    inner: Option<Inner>,
-}
-
-/// Executes futures on the runtime
-///
-/// All futures spawned using this executor will be submitted to the associated
-/// Runtime's executor. This executor is usually a thread pool.
-///
-/// For more details, see the [module level](index.html) documentation.
-#[derive(Debug, Clone)]
-pub struct TaskExecutor {
-    inner: Sender,
-}
-
-/// A future that resolves when the Tokio `Runtime` is shut down.
-pub struct Shutdown {
-    inner: Box<Future<Item = (), Error = ()> + Send>,
-}
-
-#[derive(Debug)]
-struct Inner {
-    /// Reactor running on a background thread.
-    reactor: Background,
-
-    /// Task execution pool.
-    pool: ThreadPool,
-}
-
-// ===== impl Runtime =====
-
-/// Start the Tokio runtime using the supplied future to bootstrap execution.
-///
-/// This function is used to bootstrap the execution of a Tokio application. It
-/// does the following:
-///
-/// * Start the Tokio runtime using a default configuration.
-/// * Spawn the given future onto the thread pool.
-/// * Block the current thread until the runtime shuts down.
-///
-/// Note that the function will not return immediately once `future` has
-/// completed. Instead it waits for the entire runtime to become idle.
-///
-/// See the [module level][mod] documentation for more details.
-///
-/// # Examples
-///
-/// ```rust
-/// # extern crate tokio;
-/// # extern crate futures;
-/// # use futures::{Future, Stream};
-/// use tokio::net::TcpListener;
-///
-/// # fn process<T>(_: T) -> Box<Future<Item = (), Error = ()> + Send> {
-/// # unimplemented!();
-/// # }
-/// # fn dox() {
-/// # let addr = "127.0.0.1:8080".parse().unwrap();
-/// let listener = TcpListener::bind(&addr).unwrap();
-///
-/// let server = listener.incoming()
-///     .map_err(|e| println!("error = {:?}", e))
-///     .for_each(|socket| {
-///         tokio::spawn(process(socket))
-///     });
-///
-/// tokio::run(server);
-/// # }
-/// # pub fn main() {}
-/// ```
-///
-/// # Panics
-///
-/// This function panics if called from the context of an executor.
-///
-/// [mod]: ../index.html
-pub fn run<F>(future: F)
-where F: Future<Item = (), Error = ()> + Send + 'static,
-{
-    let mut runtime = Runtime::new().unwrap();
-    runtime.spawn(future);
-    runtime.shutdown_on_idle().wait().unwrap();
-}
-
-impl Runtime {
-    /// Create a new runtime instance with default configuration values.
-    ///
-    /// See [module level][mod] documentation for more details.
-    ///
-    /// [mod]: index.html
-    pub fn new() -> io::Result<Self> {
-        // Spawn a reactor on a background thread.
-        let reactor = Reactor::new()?.background()?;
-
-        // Get a handle to the reactor.
-        let handle = reactor.handle().clone();
-
-        let pool = threadpool::Builder::new()
-            .around_worker(move |w, enter| {
-                ::tokio_reactor::with_default(&handle, enter, |_| {
-                    w.run();
-                });
-            })
-            .build();
-
-        Ok(Runtime {
-            inner: Some(Inner {
-                reactor,
-                pool,
-            }),
-        })
-    }
-
-    /// Return a reference to the reactor handle for this runtime instance.
-    pub fn handle(&self) -> &Handle {
-        self.inner().reactor.handle()
-    }
-
-    /// Return a handle to the runtime's executor.
-    pub fn executor(&self) -> TaskExecutor {
-        let inner = self.inner().pool.sender().clone();
-        TaskExecutor { inner }
-    }
-
-    /// Spawn a future onto the Tokio runtime.
-    ///
-    /// This spawns the given future onto the runtime's executor, usually a
-    /// thread pool. The thread pool is then responsible for polling the future
-    /// until it completes.
-    ///
-    /// See [module level][mod] documentation for more details.
-    ///
-    /// [mod]: index.html
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # extern crate tokio;
-    /// # extern crate futures;
-    /// # use futures::{future, Future, Stream};
-    /// use tokio::runtime::Runtime;
-    ///
-    /// # fn dox() {
-    /// // Create the runtime
-    /// let mut rt = Runtime::new().unwrap();
-    ///
-    /// // Spawn a future onto the runtime
-    /// rt.spawn(future::lazy(|| {
-    ///     println!("now running on a worker thread");
-    ///     Ok(())
-    /// }));
-    /// # }
-    /// # pub fn main() {}
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if the spawn fails. Failure occurs if the executor
-    /// is currently at capacity and is unable to spawn a new future.
-    pub fn spawn<F>(&mut self, future: F) -> &mut Self
-    where F: Future<Item = (), Error = ()> + Send + 'static,
-    {
-        self.inner_mut().pool.sender().spawn(future).unwrap();
-        self
-    }
-
-    /// Signals the runtime to shutdown once it becomes idle.
-    ///
-    /// Returns a future that completes once the shutdown operation has
-    /// completed.
-    ///
-    /// This function can be used to perform a graceful shutdown of the runtime.
-    ///
-    /// The runtime enters an idle state once **all** of the following occur.
-    ///
-    /// * The thread pool has no tasks to execute, i.e., all tasks that were
-    ///   spawned have completed.
-    /// * The reactor is not managing any I/O resources.
-    ///
-    /// See [module level][mod] documentation for more details.
-    ///
-    /// [mod]: index.html
-    pub fn shutdown_on_idle(mut self) -> Shutdown {
-        let inner = self.inner.take().unwrap();
-
-        let inner = Box::new({
-            let pool = inner.pool;
-            let reactor = inner.reactor;
-
-            pool.shutdown_on_idle().and_then(|_| {
-                reactor.shutdown_on_idle()
-            })
-        });
-
-        Shutdown { inner }
-    }
-
-    /// Signals the runtime to shutdown immediately.
-    ///
-    /// Returns a future that completes once the shutdown operation has
-    /// completed.
-    ///
-    /// This function will forcibly shutdown the runtime, causing any
-    /// in-progress work to become canceled. The shutdown steps are:
-    ///
-    /// * Drain any scheduled work queues.
-    /// * Drop any futures that have not yet completed.
-    /// * Drop the reactor.
-    ///
-    /// Once the reactor has dropped, any outstanding I/O resources bound to
-    /// that reactor will no longer function. Calling any method on them will
-    /// result in an error.
-    ///
-    /// See [module level][mod] documentation for more details.
-    ///
-    /// [mod]: index.html
-    pub fn shutdown_now(mut self) -> Shutdown {
-        let inner = self.inner.take().unwrap();
-
-        let inner = Box::new({
-            let pool = inner.pool;
-            let reactor = inner.reactor;
-
-            pool.shutdown_now().and_then(|_| {
-                reactor.shutdown_now()
-            })
-        });
-
-        Shutdown { inner }
-    }
-
-    fn inner(&self) -> &Inner {
-        self.inner.as_ref().unwrap()
-    }
-
-    fn inner_mut(&mut self) -> &mut Inner {
-        self.inner.as_mut().unwrap()
-    }
-}
-
-// ===== impl TaskExecutor =====
-
-impl TaskExecutor {
-    /// Spawn a future onto the Tokio runtime.
-    ///
-    /// This spawns the given future onto the runtime's executor, usually a
-    /// thread pool. The thread pool is then responsible for polling the future
-    /// until it completes.
-    ///
-    /// See [module level][mod] documentation for more details.
-    ///
-    /// [mod]: index.html
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # extern crate tokio;
-    /// # extern crate futures;
-    /// # use futures::{future, Future, Stream};
-    /// use tokio::runtime::Runtime;
-    ///
-    /// # fn dox() {
-    /// // Create the runtime
-    /// let mut rt = Runtime::new().unwrap();
-    /// let executor = rt.executor();
-    ///
-    /// // Spawn a future onto the runtime
-    /// executor.spawn(future::lazy(|| {
-    ///     println!("now running on a worker thread");
-    ///     Ok(())
-    /// }));
-    /// # }
-    /// # pub fn main() {}
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if the spawn fails. Failure occurs if the executor
-    /// is currently at capacity and is unable to spawn a new future.
-    pub fn spawn<F>(&self, future: F)
-    where F: Future<Item = (), Error = ()> + Send + 'static,
-    {
-        self.inner.spawn(future).unwrap();
-    }
-}
-
-impl<T> future::Executor<T> for TaskExecutor
-where T: Future<Item = (), Error = ()> + Send + 'static,
-{
-    fn execute(&self, future: T) -> Result<(), future::ExecuteError<T>> {
-        self.inner.execute(future)
-    }
-}
-
-impl ::executor::Executor for TaskExecutor {
-    fn spawn(&mut self, future: Box<Future<Item = (), Error = ()> + Send>)
-        -> Result<(), ::executor::SpawnError>
-    {
-        self.inner.spawn(future)
-    }
-}
-
-// ===== impl Shutdown =====
-
-impl Future for Shutdown {
-    type Item = ();
-    type Error = ();
-
-    fn poll(&mut self) -> Poll<(), ()> {
-        try_ready!(self.inner.poll());
-        Ok(().into())
-    }
-}
-
-impl fmt::Debug for Shutdown {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        fmt.debug_struct("Shutdown")
-            .field("inner", &"Box<Future<Item = (), Error = ()>>")
-            .finish()
-    }
-}

tests/buffered.rs

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

tests/chain.rs

@@ -1,49 +0,0 @@
-extern crate futures;
-extern crate tokio;
-extern crate tokio_io;
-
-use std::net::TcpStream;
-use std::thread;
-use std::io::{Write, Read};
-
-use futures::Future;
-use futures::stream::Stream;
-use tokio_io::io::read_to_end;
-use tokio::net::TcpListener;
-
-macro_rules! t {
-    ($e:expr) => (match $e {
-        Ok(e) => e,
-        Err(e) => panic!("{} failed with {:?}", stringify!($e), e),
-    })
-}
-
-#[test]
-fn chain_clients() {
-    let srv = t!(TcpListener::bind(&t!("127.0.0.1:0".parse())));
-    let addr = t!(srv.local_addr());
-
-    let t = thread::spawn(move || {
-        let mut s1 = TcpStream::connect(&addr).unwrap();
-        s1.write_all(b"foo ").unwrap();
-        let mut s2 = TcpStream::connect(&addr).unwrap();
-        s2.write_all(b"bar ").unwrap();
-        let mut s3 = TcpStream::connect(&addr).unwrap();
-        s3.write_all(b"baz").unwrap();
-    });
-
-    let clients = srv.incoming().take(3);
-    let copied = clients.collect().and_then(|clients| {
-        let mut clients = clients.into_iter();
-        let a = clients.next().unwrap();
-        let b = clients.next().unwrap();
-        let c = clients.next().unwrap();
-
-        read_to_end(a.chain(b).chain(c), Vec::new())
-    });
-
-    let (_, data) = t!(copied.wait());
-    t.join().unwrap();
-
-    assert_eq!(data, b"foo bar baz");
-}

tests/current_thread.rs

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

tests/drop-core.rs

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

tests/echo.rs

@@ -1,51 +0,0 @@
-extern crate env_logger;
-extern crate futures;
-extern crate tokio;
-extern crate tokio_io;
-
-use std::io::{Read, Write};
-use std::net::TcpStream;
-use std::thread;
-
-use futures::Future;
-use futures::stream::Stream;
-use tokio::net::TcpListener;
-use tokio_io::AsyncRead;
-use tokio_io::io::copy;
-
-macro_rules! t {
-    ($e:expr) => (match $e {
-        Ok(e) => e,
-        Err(e) => panic!("{} failed with {:?}", stringify!($e), e),
-    })
-}
-
-#[test]
-fn echo_server() {
-    drop(env_logger::init());
-
-    let srv = t!(TcpListener::bind(&t!("127.0.0.1:0".parse())));
-    let addr = t!(srv.local_addr());
-
-    let msg = "foo bar baz";
-    let t = thread::spawn(move || {
-        let mut s = TcpStream::connect(&addr).unwrap();
-
-        for _i in 0..1024 {
-            assert_eq!(t!(s.write(msg.as_bytes())), msg.len());
-            let mut buf = [0; 1024];
-            assert_eq!(t!(s.read(&mut buf)), msg.len());
-            assert_eq!(&buf[..msg.len()], msg.as_bytes());
-        }
-    });
-
-    let clients = srv.incoming();
-    let client = clients.into_future().map(|e| e.0.unwrap()).map_err(|e| e.0);
-    let halves = client.map(|s| s.split());
-    let copied = halves.and_then(|(a, b)| copy(a, b));
-
-    let (amt, _, _) = t!(copied.wait());
-    t.join().unwrap();
-
-    assert_eq!(amt, msg.len() as u64 * 1024);
-}

tests/global.rs

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

tests/limit.rs

@@ -1,43 +0,0 @@
-extern crate futures;
-extern crate tokio;
-extern crate tokio_io;
-
-use std::net::TcpStream;
-use std::thread;
-use std::io::{Write, Read};
-
-use futures::Future;
-use futures::stream::Stream;
-use tokio_io::io::read_to_end;
-use tokio::net::TcpListener;
-
-macro_rules! t {
-    ($e:expr) => (match $e {
-        Ok(e) => e,
-        Err(e) => panic!("{} failed with {:?}", stringify!($e), e),
-    })
-}
-
-#[test]
-fn limit() {
-    let srv = t!(TcpListener::bind(&t!("127.0.0.1:0".parse())));
-    let addr = t!(srv.local_addr());
-
-    let t = thread::spawn(move || {
-        let mut s1 = TcpStream::connect(&addr).unwrap();
-        s1.write_all(b"foo bar baz").unwrap();
-    });
-
-    let clients = srv.incoming().take(1);
-    let copied = clients.collect().and_then(|clients| {
-        let mut clients = clients.into_iter();
-        let a = clients.next().unwrap();
-
-        read_to_end(a.take(4), Vec::new())
-    });
-
-    let (_, data) = t!(copied.wait());
-    t.join().unwrap();
-
-    assert_eq!(data, b"foo ");
-}

tests/line-frames.rs

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

tests/pipe-hup.rs

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

tests/runtime.rs

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

tests/stream-buffered.rs

@@ -1,54 +0,0 @@
-extern crate env_logger;
-extern crate futures;
-extern crate tokio;
-extern crate tokio_io;
-
-use std::io::{Read, Write};
-use std::net::TcpStream;
-use std::thread;
-
-use futures::Future;
-use futures::stream::Stream;
-use tokio_io::io::copy;
-use tokio_io::AsyncRead;
-use tokio::net::TcpListener;
-
-macro_rules! t {
-    ($e:expr) => (match $e {
-        Ok(e) => e,
-        Err(e) => panic!("{} failed with {:?}", stringify!($e), e),
-    })
-}
-
-#[test]
-fn echo_server() {
-    drop(env_logger::init());
-
-    let srv = t!(TcpListener::bind(&t!("127.0.0.1:0".parse())));
-    let addr = t!(srv.local_addr());
-
-    let t = thread::spawn(move || {
-        let mut s1 = t!(TcpStream::connect(&addr));
-        let mut s2 = t!(TcpStream::connect(&addr));
-
-        let msg = b"foo";
-        assert_eq!(t!(s1.write(msg)), msg.len());
-        assert_eq!(t!(s2.write(msg)), msg.len());
-        let mut buf = [0; 1024];
-        assert_eq!(t!(s1.read(&mut buf)), msg.len());
-        assert_eq!(&buf[..msg.len()], msg);
-        assert_eq!(t!(s2.read(&mut buf)), msg.len());
-        assert_eq!(&buf[..msg.len()], msg);
-    });
-
-    let future = srv.incoming()
-                    .map(|s| s.split())
-                    .map(|(a, b)| copy(a, b).map(|_| ()))
-                    .buffered(10)
-                    .take(2)
-                    .collect();
-
-    t!(future.wait());
-
-    t.join().unwrap();
-}

tests/tcp.rs

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

tests/udp.rs

@@ -1,261 +0,0 @@
-#![allow(deprecated)]
-
-extern crate futures;
-extern crate tokio;
-#[macro_use]
-extern crate tokio_io;
-extern crate bytes;
-extern crate env_logger;
-
-use std::io;
-use std::net::SocketAddr;
-
-use futures::{Future, Poll, Stream, Sink};
-
-use tokio::net::{UdpSocket, UdpFramed};
-use tokio_io::codec::{Encoder, Decoder};
-use bytes::{BytesMut, BufMut};
-
-macro_rules! t {
-    ($e:expr) => (match $e {
-        Ok(e) => e,
-        Err(e) => panic!("{} failed with {:?}", stringify!($e), e),
-    })
-}
-
-fn send_messages<S: SendFn + Clone, R: RecvFn + Clone>(send: S, recv: R) {
-    let mut a = t!(UdpSocket::bind(&([127, 0, 0, 1], 0).into()));
-    let mut b = t!(UdpSocket::bind(&([127, 0, 0, 1], 0).into()));
-    let a_addr = t!(a.local_addr());
-    let b_addr = t!(b.local_addr());
-
-    {
-        let send = SendMessage::new(a, send.clone(), b_addr, b"1234");
-        let recv = RecvMessage::new(b, recv.clone(), a_addr, b"1234");
-        let (sendt, received) = t!(send.join(recv).wait());
-        a = sendt;
-        b = received;
-    }
-
-    {
-        let send = SendMessage::new(a, send, b_addr, b"");
-        let recv = RecvMessage::new(b, recv, a_addr, b"");
-        t!(send.join(recv).wait());
-    }
-}
-
-#[test]
-fn send_to_and_recv_from() {
-   send_messages(SendTo {}, RecvFrom {});
-}
-
-#[test]
-fn send_and_recv() {
-    send_messages(Send {}, Recv {});
-}
-
-trait SendFn {
-    fn send(&self, &mut UdpSocket, &[u8], &SocketAddr) -> Result<usize, io::Error>;
-}
-
-#[derive(Debug, Clone)]
-struct SendTo {}
-
-impl SendFn for SendTo {
-    fn send(&self, socket: &mut UdpSocket, buf: &[u8], addr: &SocketAddr) -> Result<usize, io::Error> {
-        socket.send_to(buf, addr)
-    }
-}
-
-#[derive(Debug, Clone)]
-struct Send {}
-
-impl SendFn for Send {
-    fn send(&self, socket: &mut UdpSocket, buf: &[u8], addr: &SocketAddr) -> Result<usize, io::Error> {
-        socket.connect(addr).expect("could not connect");
-        socket.send(buf)
-    }
-}
-
-struct SendMessage<S> {
-    socket: Option<UdpSocket>,
-    send: S,
-    addr: SocketAddr,
-    data: &'static [u8],
-}
-
-impl<S: SendFn> SendMessage<S> {
-    fn new(socket: UdpSocket, send: S, addr: SocketAddr, data: &'static [u8]) -> SendMessage<S> {
-        SendMessage {
-            socket: Some(socket),
-            send: send,
-            addr: addr,
-            data: data,
-        }
-    }
-}
-
-impl<S: SendFn> Future for SendMessage<S> {
-    type Item = UdpSocket;
-    type Error = io::Error;
-
-    fn poll(&mut self) -> Poll<UdpSocket, io::Error> {
-        let n = try_nb!(self.send.send(self.socket.as_mut().unwrap(), &self.data[..], &self.addr));
-
-        assert_eq!(n, self.data.len());
-
-        Ok(self.socket.take().unwrap().into())
-    }
-}
-
-trait RecvFn {
-    fn recv(&self, &mut UdpSocket, &mut [u8], &SocketAddr) -> Result<usize, io::Error>;
-}
-
-#[derive(Debug, Clone)]
-struct RecvFrom {}
-
-impl RecvFn for RecvFrom {
-    fn recv(&self, socket: &mut UdpSocket, buf: &mut [u8],
-            expected_addr: &SocketAddr) -> Result<usize, io::Error> {
-        socket.recv_from(buf).map(|(s, addr)| {
-            assert_eq!(addr, *expected_addr);
-            s
-        })
-    }
-}
-
-#[derive(Debug, Clone)]
-struct Recv {}
-
-impl RecvFn for Recv {
-    fn recv(&self, socket: &mut UdpSocket, buf: &mut [u8], _: &SocketAddr) -> Result<usize, io::Error> {
-        socket.recv(buf)
-    }
-}
-
-struct RecvMessage<R> {
-    socket: Option<UdpSocket>,
-    recv: R,
-    expected_addr: SocketAddr,
-    expected_data: &'static [u8],
-}
-
-impl<R: RecvFn> RecvMessage<R> {
-    fn new(socket: UdpSocket, recv: R, expected_addr: SocketAddr,
-           expected_data: &'static [u8]) -> RecvMessage<R> {
-        RecvMessage {
-            socket: Some(socket),
-            recv: recv,
-            expected_addr: expected_addr,
-            expected_data: expected_data,
-        }
-    }
-}
-
-impl<R: RecvFn> Future for RecvMessage<R> {
-    type Item = UdpSocket;
-    type Error = io::Error;
-
-    fn poll(&mut self) -> Poll<UdpSocket, io::Error> {
-        let mut buf = vec![0u8; 10 + self.expected_data.len() * 10];
-        let n = try_nb!(self.recv.recv(&mut self.socket.as_mut().unwrap(), &mut buf[..],
-                                       &self.expected_addr));
-
-        assert_eq!(n, self.expected_data.len());
-        assert_eq!(&buf[..self.expected_data.len()], &self.expected_data[..]);
-
-        Ok(self.socket.take().unwrap().into())
-    }
-}
-
-#[test]
-fn send_dgrams() {
-    let mut a = t!(UdpSocket::bind(&t!("127.0.0.1:0".parse())));
-    let mut b = t!(UdpSocket::bind(&t!("127.0.0.1:0".parse())));
-    let mut buf = [0u8; 50];
-    let b_addr = t!(b.local_addr());
-
-    {
-        let send = a.send_dgram(&b"4321"[..], &b_addr);
-        let recv = b.recv_dgram(&mut buf[..]);
-        let (sendt, received) = t!(send.join(recv).wait());
-        assert_eq!(received.2, 4);
-        assert_eq!(&received.1[..4], b"4321");
-        a = sendt.0;
-        b = received.0;
-    }
-
-    {
-        let send = a.send_dgram(&b""[..], &b_addr);
-        let recv = b.recv_dgram(&mut buf[..]);
-        let received = t!(send.join(recv).wait()).1;
-        assert_eq!(received.2, 0);
-    }
-}
-
-pub struct ByteCodec;
-
-impl Decoder for ByteCodec {
-    type Item = Vec<u8>;
-    type Error = io::Error;
-
-    fn decode(&mut self, buf: &mut BytesMut) -> Result<Option<Vec<u8>>, io::Error> {
-        let len = buf.len();
-        Ok(Some(buf.split_to(len).to_vec()))
-    }
-}
-
-impl Encoder for ByteCodec {
-    type Item = Vec<u8>;
-    type Error = io::Error;
-
-    fn encode(&mut self, data: Vec<u8>, buf: &mut BytesMut) -> Result<(), io::Error> {
-        buf.reserve(data.len());
-        buf.put(data);
-        Ok(())
-    }
-}
-
-#[test]
-fn send_framed() {
-    drop(env_logger::init());
-
-    let mut a_soc = t!(UdpSocket::bind(&t!("127.0.0.1:0".parse())));
-    let mut b_soc = t!(UdpSocket::bind(&t!("127.0.0.1:0".parse())));
-    let a_addr = t!(a_soc.local_addr());
-    let b_addr = t!(b_soc.local_addr());
-
-    {
-        let a = UdpFramed::new(a_soc, ByteCodec);
-        let b = UdpFramed::new(b_soc, ByteCodec);
-
-        let msg = b"4567".to_vec();
-
-        let send = a.send((msg.clone(), b_addr));
-        let recv = b.into_future().map_err(|e| e.0);
-        let (sendt, received) = t!(send.join(recv).wait());
-
-        let (data, addr) = received.0.unwrap();
-        assert_eq!(msg, data);
-        assert_eq!(a_addr, addr);
-
-        a_soc = sendt.into_inner();
-        b_soc = received.1.into_inner();
-    }
-
-    {
-        let a = UdpFramed::new(a_soc, ByteCodec);
-        let b = UdpFramed::new(b_soc, ByteCodec);
-
-        let msg = b"".to_vec();
-
-        let send = a.send((msg.clone(), b_addr));
-        let recv = b.into_future().map_err(|e| e.0);
-        let received = t!(send.join(recv).wait()).1;
-
-        let (data, addr) = received.0.unwrap();
-        assert_eq!(msg, data);
-        assert_eq!(a_addr, addr);
-    }
-}

tokio-buf/CHANGELOG.md

@@ -0,0 +1,19 @@
+# 0.2.0-alpha.1 (August 8, 2019)
+
+### Changed
+- Switch to `async`, `await`, and `std::future`.
+
+# 0.1.1 (April 22, 2019)
+
+### Added
+- Utilities for creating a `BufStream` from iterators and streams (#1011).
+- Add `BufStream::into_stream` (#1048).
+- Implement `FromBufStream` for `Bytes` (#1009).
+- Implement `Error` for `CollectVecError` (#1010).
+
+### Fixed
+- Implement `size_hint` for string types (#1012).
+
+# 0.1.0 (February 23, 2019)
+
+* Initial release

tokio-buf/Cargo.toml

@@ -0,0 +1,34 @@
+[package]
+name = "tokio-buf"
+# When releasing to crates.io:
+# - Remove path dependencies
+# - Update html_root_url.
+# - Update doc url
+#   - Cargo.toml
+# - Update CHANGELOG.md.
+# - Create "v0.2.x" git tag.
+version = "0.2.0-alpha.1"
+edition = "2018"
+authors = ["Tokio Contributors <[email protected]>"]
+license = "MIT"
+repository = "https://github.com/tokio-rs/tokio"
+homepage = "https://tokio.rs"
+documentation = "https://docs.rs/tokio-buf/0.2.0-alpha.1/tokio_buf"
+description = """
+Asynchronous stream of byte buffers
+"""
+categories = ["asynchronous"]
+
+[dependencies]
+bytes = "0.4.10"
+either = { version =  "1.5", optional = true}
+
+[features]
+# default = ["util"]
+# util = ["bytes/either", "either"]
+
+[dev-dependencies]
+tokio-mock-task = "0.1.1"
+
+[package.metadata.docs.rs]
+all-features = true

tokio-buf/LICENSE

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

tokio-buf/README.md

@@ -0,0 +1,13 @@
+# tokio-buf
+
+Asynchronous stream of byte buffers
+
+## License
+
+This project is licensed under the [MIT license](LICENSE).
+
+### Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in Tokio by you, shall be licensed as MIT, without any additional
+terms or conditions.

tokio-buf/src/lib.rs

@@ -0,0 +1,98 @@
+#![doc(html_root_url = "https://docs.rs/tokio-buf/0.2.0-alpha.1")]
+#![warn(
+    missing_debug_implementations,
+    missing_docs,
+    rust_2018_idioms,
+    unreachable_pub
+)]
+#![doc(test(no_crate_inject, attr(deny(rust_2018_idioms))))]
+
+//! 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).
+
+// 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 crate::util::BufStreamExt;
+
+use bytes::Buf;
+use std::task::{Context, 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:
+    ///
+    /// - `Poll::Pending` 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.
+    ///
+    /// - `Poll::Ready(Some(Ok(buf)))` means that the stream has successfully
+    ///    produced a value, `buf`, and may produce further values on subsequent
+    ///    `poll_buf` calls.
+    ///
+    /// - `Poll::Ready(None)` means that the stream has terminated, and
+    ///   `poll_buf` should not be invoked again.
+    ///
+    /// # Panics
+    ///
+    /// Once a stream is finished, i.e. `Poll::Ready(None)` has been returned,
+    /// further calls to `poll_buf` may result in a panic or other "bad
+    /// behavior".
+    fn poll_buf(&mut self, cx: &mut Context<'_>) -> Poll<Option<Result<Self::Item, Self::Error>>>;
+
+    /// Returns the bounds on the remaining length of the stream.
+    ///
+    /// The size hint allows the caller to perform certain optimizations that
+    /// are dependent on the byte stream size. For example, `collect` uses the
+    /// size hint to pre-allocate enough capacity to store the entirety of the
+    /// data received from the byte stream.
+    ///
+    /// When `SizeHint::upper()` returns `Some` with a value equal to
+    /// `SizeHint::lower()`, this represents the exact number of bytes that will
+    /// be yielded by the `BufStream`.
+    ///
+    /// # Implementation notes
+    ///
+    /// While not enforced, implementations are expected to respect the values
+    /// returned from `SizeHint`. Any deviation is considered an implementation
+    /// bug. Consumers may rely on correctness in order to use the value as part
+    /// of protocol impelmentations. For example, an HTTP library may use the
+    /// size hint to set the `content-length` header.
+    ///
+    /// However, `size_hint` must not be trusted to omit bounds checks in unsafe
+    /// code. An incorrect implementation of `size_hint()` must not lead to
+    /// memory safety violations.
+    fn size_hint(&self) -> SizeHint {
+        SizeHint::default()
+    }
+}

tokio-buf/src/never.rs

@@ -0,0 +1,18 @@
+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 {}

tokio-buf/src/size_hint.rs

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

tokio-buf/src/str.rs

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

tokio-buf/src/u8.rs

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

tokio-buf/src/util/chain.rs

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

tokio-buf/src/util/collect.rs

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

tokio-buf/src/util/from.rs

@@ -0,0 +1,154 @@
+use crate::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 {}
+
+impl fmt::Display for CollectBytesError {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(fmt, "BufStream too big")
+    }
+}
+
+impl Error for CollectBytesError {}

tokio-buf/src/util/iter.rs

@@ -0,0 +1,50 @@
+use crate::BufStream;
+use bytes::Buf;
+use futures::Poll;
+use std::error::Error;
+use std::fmt;
+
+/// 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 {}

tokio-buf/src/util/limit.rs

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

tokio-buf/src/util/mod.rs

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

tokio-buf/src/util/stream.rs

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

tokio-buf/tests/buf_stream.rs

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

tokio-buf/tests/chain.rs

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

tokio-buf/tests/collect.rs

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

tokio-buf/tests/iter.rs

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

tokio-buf/tests/limit.rs

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

tokio-buf/tests/size_hint.rs

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

tokio-buf/tests/stream.rs

@@ -0,0 +1,44 @@
+#![cfg(feature = "broken")]
+use futures::sync::mpsc;
+use futures::Async::*;
+use std::io::Cursor;
+use tokio_buf::{util, BufStream};
+use tokio_mock_task::MockTask;
+
+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)
+}