Start work on compat feature

This makes it consistent with `TcpListener::poll_accept` and other
public poll methods the library provides. This particular method is
useful for writing generic code that accepts connections since async
functions can't easily be used with traits. It is possible to
generically accept connections with `Incoming`, however, this doesn't
return the incoming `SocketAddr`.

.cirrus.yml

@@ -1,17 +1,17 @@
 freebsd_instance:
-  image: freebsd-12-2-release-amd64
+  image: freebsd-12-1-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
+  name: FreeBSD 12.0
   env:
     LOOM_MAX_PREEMPTIONS: 2
     RUSTFLAGS: -Dwarnings
   setup_script:
-    - pkg install -y bash curl
+    - pkg install -y curl
     - curl https://sh.rustup.rs -sSf --output rustup.sh
     - sh rustup.sh -y --profile minimal --default-toolchain stable
     - . $HOME/.cargo/env
@@ -21,9 +21,10 @@ task:
       rustc --version
   test_script:
     - . $HOME/.cargo/env
-    - cargo test --all --all-features
+    - cargo test --all
     - cargo doc --all --no-deps
-  i686_test_script:
-    - . $HOME/.cargo/env
-    - |
-      cargo test --all --all-features --target i686-unknown-freebsd
+  # TODO: Re-enable
+  # i686_test_script:
+  #   - . $HOME/.cargo/env
+  #   - |
+  #     cargo test --all --exclude tokio-macros --target i686-unknown-freebsd

.github/ISSUE_TEMPLATE/bug_report.md

@@ -9,7 +9,12 @@ assignees: ''
 
 **Version**
 List the versions of all `tokio` crates you are using. The easiest way to get
-this information is using `cargo tree` subcommand:
+this information is using `cargo-tree`.
+
+`cargo install cargo-tree`
+(see install here: https://github.com/sfackler/cargo-tree)
+
+Then:
 
 `cargo tree | grep tokio`
 

.github/workflows/bench.yml

@@ -1,55 +0,0 @@
-name: Benchmark
-on:
-  push:
-    branches:
-      - master
-
-jobs:
-  benchmark:
-    name: Benchmark
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        bench:
-          - rt_multi_threaded
-          - sync_mpsc
-          - sync_rwlock
-          - sync_semaphore
-    steps:
-      - uses: actions/checkout@v2
-      - name: Install Rust
-        run: rustup update stable
-
-      # Run benchmark with `go test -bench` and stores the output to a file
-      - name: Run benchmark
-        run: cargo bench --bench ${{ matrix.bench }} | tee ../output.txt
-        working-directory: benches
-
-      # Download previous benchmark result from cache (if exists)
-      - name: Download previous benchmark data
-        uses: actions/cache@v1
-        with:
-          path: ./cache
-          key: ${{ runner.os }}-benchmark
-
-      # Run `github-action-benchmark` action
-      - name: Store benchmark result
-        uses: rhysd/github-action-benchmark@v1
-        with:
-          name: ${{ matrix.bench }}
-          # What benchmark tool the output.txt came from
-          tool: 'cargo'
-          # Where the output from the benchmark tool is stored
-          output-file-path: output.txt
-          # # Where the previous data file is stored
-          # external-data-json-path: ./cache/benchmark-data.json
-          # Workflow will fail when an alert happens
-          fail-on-alert: true
-          # GitHub API token to make a commit comment
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          # Enable alert commit comment
-          comment-on-alert: true
-          alert-comment-cc-users: '@tokio-rs/maintainers'
-          auto-push: true
-
-      # Upload the updated cache file for the next job by actions/cache

.github/workflows/ci.yml

@@ -1,16 +1,16 @@
 on:
   push:
-    branches: ["master", "tokio-*.x"]
+    branches: ["v0.2.x"]
   pull_request:
-    branches: ["master", "tokio-*.x"]
+    branches: ["v0.2.x"]
 
 name: CI
 
 env:
   RUSTFLAGS: -Dwarnings
   RUST_BACKTRACE: 1
-  nightly: nightly-2021-04-25
-  minrust: 1.45.2
+  nightly: nightly-2020-09-21
+  minrust: 1.39.0
 
 jobs:
   # Depends on all action sthat are required for a "successful" CI run.
@@ -28,7 +28,6 @@ jobs:
       - clippy
       - docs
       - loom
-      - valgrind
     steps:
       - run: exit 0
 
@@ -54,6 +53,11 @@ jobs:
         run: cargo test --features full
         working-directory: tokio
 
+      # Check `tokio` with `full + parking_lot` to make sure it compiles.
+      - name: check tokio full,parking_lot
+        run: cargo check --features full,parking_lot
+        working-directory: tokio
+
       # Test **all** crates in the workspace with all features.
       - name: test all --all-features
         run: cargo test --workspace --all-features
@@ -68,44 +72,6 @@ jobs:
         run: cargo hack test --each-feature
         working-directory: tests-build
 
-      # Build benchmarks. Run of benchmarks is done by bench.yml workflow.
-      - name: build benches
-        run: cargo build --benches
-        working-directory: benches
-        # bench.yml workflow runs benchmarks only on linux.
-        if: startsWith(matrix.os, 'ubuntu')
-
-  valgrind:
-    name: valgrind
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Install Rust
-        run: rustup update stable
-
-      - name: Install Valgrind
-        run: |
-          sudo apt-get update -y
-          sudo apt-get install -y valgrind
-
-      # Compile tests
-      - name: cargo build test-mem
-        run: cargo build --features rt-net --bin test-mem
-        working-directory: tests-integration
-
-      # Run with valgrind
-      - name: Run valgrind test-mem
-        run: valgrind  --leak-check=full --show-leak-kinds=all ./target/debug/test-mem
-
-      # Compile tests
-      - name: cargo build test-process-signal
-        run: cargo build --features rt-process-signal --bin test-process-signal
-        working-directory: tests-integration
-
-      # Run with valgrind
-      - name: Run valgrind test-process-signal
-        run: valgrind --leak-check=full --show-leak-kinds=all ./target/debug/test-process-signal
-
   test-unstable:
     name: test tokio full --unstable
     runs-on: ${{ matrix.os }}
@@ -125,7 +91,7 @@ jobs:
         run: cargo test --features full
         working-directory: tokio
         env:
-          RUSTFLAGS: --cfg tokio_unstable -Dwarnings
+          RUSTFLAGS: '--cfg tokio_unstable'
 
   miri:
     name: miri
@@ -144,23 +110,8 @@ jobs:
           rm -rf tokio/tests
 
       - name: miri
-        run: cargo miri test --features rt,rt-multi-thread,sync task
+        run: cargo miri test --features rt-core,rt-threaded,rt-util,sync task
         working-directory: tokio
-  san:
-    name: san
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions-rs/toolchain@v1
-        with:
-          toolchain: ${{ env.nightly }}
-          override: true
-      - name: asan
-        run: cargo test --all-features --target x86_64-unknown-linux-gnu --lib -- --test-threads 1
-        working-directory: tokio
-        env:
-          RUSTFLAGS: -Z sanitizer=address
-          ASAN_OPTIONS: detect_leaks=0
 
   cross:
     name: cross
@@ -205,7 +156,7 @@ jobs:
       - name: check --each-feature --unstable
         run: cargo hack check --all --each-feature -Z avoid-dev-deps
         env:
-          RUSTFLAGS: --cfg tokio_unstable -Dwarnings
+          RUSTFLAGS: --cfg tokio_unstable
 
   minrust:
     name: minrust
@@ -220,26 +171,6 @@ jobs:
       - name: "test --workspace --all-features"
         run: cargo check --workspace --all-features
 
-  minimal-versions:
-    name: minimal-versions
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions-rs/toolchain@v1
-        with:
-          toolchain: ${{ env.nightly }}
-          override: true
-      - name: Install cargo-hack
-        run: cargo install cargo-hack
-      - name: "check --all-features -Z minimal-versions"
-        run: |
-          # Remove dev-dependencies from Cargo.toml to prevent the next `cargo update`
-          # from determining minimal versions based on dev-dependencies.
-          cargo hack --remove-dev-deps --workspace
-          # Update Cargo.lock to minimal version dependencies.
-          cargo update -Z minimal-versions
-          cargo check --all-features
-
   fmt:
     name: fmt
     runs-on: ubuntu-latest
@@ -265,13 +196,13 @@ jobs:
     steps:
       - uses: actions/checkout@v2
       - name: Install Rust
-        run: rustup update ${{ env.minrust }} && rustup default ${{ env.minrust }}
+        run: rustup update stable
       - name: Install clippy
         run: rustup component add clippy
 
       # Run clippy
       - name: "clippy --all"
-        run: cargo clippy --all --tests --all-features
+        run: cargo clippy --all --tests
 
   docs:
     name: docs
@@ -284,9 +215,9 @@ jobs:
           override: true
 
       - name: "doc --lib --all-features"
-        run: cargo doc --lib --no-deps --all-features --document-private-items
+        run: cargo doc --lib --no-deps --all-features
         env:
-          RUSTDOCFLAGS: --cfg docsrs -Dwarnings
+          RUSTDOCFLAGS: --cfg docsrs
 
   loom:
     name: loom
@@ -299,7 +230,6 @@ jobs:
           - loom_pool::group_b
           - loom_pool::group_c
           - loom_pool::group_d
-          - time::driver
     steps:
       - uses: actions/checkout@v2
       - name: Install Rust
@@ -309,6 +239,6 @@ jobs:
         run: cargo test --lib --release --features full -- --nocapture $SCOPE
         working-directory: tokio
         env:
-          RUSTFLAGS: --cfg loom --cfg tokio_unstable -Dwarnings
+          RUSTFLAGS: --cfg loom --cfg tokio_unstable
           LOOM_MAX_PREEMPTIONS: 2
           SCOPE: ${{ matrix.scope }}

.github/workflows/stress-test.yml

@@ -1,32 +0,0 @@
-name: Stress Test
-on:
-  pull_request:
-  push:
-    branches:
-      - master
-
-jobs:
-  stess-test:
-    name: Stress Test
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        stress-test:
-          - simple_echo_tcp
-    steps:
-      - uses: actions/checkout@v2
-      - name: Install Rust
-        run: rustup update stable
-
-      - name: Install Valgrind
-        run: |
-          sudo apt-get update -y
-          sudo apt-get install -y valgrind
-
-      # Compiles each of the stress test examples.
-      - name: Compile stress test examples
-        run: cargo build -p stress-test --release --example ${{ matrix.stress-test }}
-
-      # Runs each of the examples using Valgrind. Detects leaks and displays them.
-      - name: Run valgrind
-        run: valgrind  --leak-check=full --show-leak-kinds=all ./target/release/examples/${{ matrix.stress-test }}

CONTRIBUTING.md

@@ -124,27 +124,17 @@ arguments to many common cargo commands. This section lists some commonly needed
 commands.
 
 Some commands just need the `--all-features` argument:
-
 ```
 cargo build --all-features
 cargo check --all-features
 cargo test --all-features
 ```
-
 When building documentation normally, the markers that list the features
 required for various parts of Tokio are missing. To build the documentation
 correctly, use this command:
-
 ```
 RUSTDOCFLAGS="--cfg docsrs" cargo +nightly doc --all-features
 ```
-
-There is currently a [bug in cargo] that means documentation cannot be built
-from the root of the workspace. If you `cd` into the `tokio` subdirectory the
-command shown above will work.
-
-[bug in cargo]: https://github.com/rust-lang/cargo/issues/9274
-
 The `cargo fmt` command does not work on the Tokio codebase. You can use the
 command below instead:
 
@@ -437,14 +427,11 @@ _Adapted from the [Node.js contributing guide][node]_.
 
 ## Keeping track of issues and PRs
 
-The Tokio GitHub repository has a lot of issues and PRs to keep track of. This
-section explains the meaning of various labels, as well as our [GitHub
-project][project]. The section is primarily targeted at maintainers.  Most
-contributors aren't able to set these labels.
+The Tokio GitHub repository has a lot of issues and PRs, which is not easy to
+keep track of. This section explains the meaning of various labels, as well as
+our [GitHub project][project]. The section is primarily targeted at maintainers.
 
-### Area
-
-The area label describes the crates relevant to this issue or PR.
+**Area.** The area label describes the crates relevant to this issue or PR.
 
  - **A-tokio** This issue concerns the main Tokio crate.
  - **A-tokio-util** This issue concerns the `tokio-util` crate.
@@ -455,7 +442,7 @@ The area label describes the crates relevant to this issue or PR.
    be used for the procedural macros, and not `join!` or `select!`.
  - **A-ci** This issue concerns our GitHub Actions setup.
 
-### Category
+**Category.** The category label describes the category.
 
  - **C-bug** This is a bug-report. Bug-fix PRs use `C-enhancement` instead.
  - **C-enhancement** This is a PR that adds a new features.
@@ -473,7 +460,8 @@ The area label describes the crates relevant to this issue or PR.
  - **C-request** A non-feature request, e.g. "please add deprecation notices to
    `-alpha.*` versions of crates"
 
-### Calls for participation
+**Call for participation.** I don't know why it's called `E-`. Many issues are
+missing a difficulty rating, and you should feel free to add one.
 
  - **E-help-wanted** Stuff where we want help. Often seen together with `C-bug`
    or `C-feature-accepted`.
@@ -485,13 +473,7 @@ The area label describes the crates relevant to this issue or PR.
  - **E-needs-mvce** This bug is missing a minimal complete and verifiable
    example.
 
-The "E-" prefix is the same as used in the Rust compiler repository. Some
-issues are missing a difficulty rating, but feel free to ask on our Discord
-server if you want to know how difficult an issue likely is.
-
-### Module
-
-The module label provides a more fine grained categorization than **Area**.
+**Module.** A more fine groaned categorization than area.
 
  - **M-blocking** Things relevant to `spawn_blocking`, `block_in_place`.
  - **M-codec** The `tokio_util::codec` module.
@@ -504,14 +486,13 @@ The module label provides a more fine grained categorization than **Area**.
  - **M-process** The `tokio::process` module.
  - **M-runtime** The `tokio::runtime` module.
  - **M-signal** The `tokio::signal` module.
+ - **M-stream** The `tokio::stream` module.
  - **M-sync** The `tokio::sync` module.
  - **M-task** The `tokio::task` module.
  - **M-time** The `tokio::time` module.
  - **M-tracing** Tracing support in Tokio.
 
-### Topic
-
-Some extra information.
+**Topic.** Some extra information.
 
  - **T-docs** This is about documentation.
  - **T-performance** This is about performance.
@@ -521,34 +502,6 @@ Any label not listed here is not in active use.
 
 [project]: https://github.com/orgs/tokio-rs/projects/1
 
-## LTS guarantees
-
-Tokio ≥1.0.0 comes with LTS guarantees:
-
- * A minimum of 5 years of maintenance.
- * A minimum of 3 years before a hypothetical 2.0 release.
-
-The goal of these guarantees is to provide stability to the ecosystem.
-
-## Mininum Supported Rust Version (MSRV)
-
- * All Tokio ≥1.0.0 releases will support at least a 6-month old Rust
-   compiler release.
- * The MSRV will only be increased on 1.x releases.
-
-## Versioning Policy
-
-With Tokio ≥1.0.0:
-
- * Patch (1.\_.x) releases _should only_ contain bug fixes or documentation
-   changes. Besides this, these releases should not substantially change
-   runtime behavior.
- * Minor (1.x) releases may contain new functionality, MSRV increases (see
-   above), minor dependency updates, deprecations, and larger internal
-   implementation changes.
-
-This is as defined by [Semantic Versioning 2.0](https://semver.org/).
-
 ## Releasing
 
 Since the Tokio project consists of a number of crates, many of which depend on
@@ -581,8 +534,9 @@ When releasing a new version of a crate, follow these steps:
 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 "Documentation" link in the
-   crate's `README.md` to point 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

Cargo.toml

@@ -4,13 +4,11 @@ members = [
   "tokio",
   "tokio-macros",
   "tokio-test",
-  "tokio-stream",
   "tokio-util",
 
   # Internal
   "benches",
   "examples",
-  "stress-test",
   "tests-build",
   "tests-integration",
 ]

LICENSE

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

README.md

@@ -14,21 +14,22 @@ the Rust programming language. It is:
 
 [![Crates.io][crates-badge]][crates-url]
 [![MIT licensed][mit-badge]][mit-url]
-[![Build Status][actions-badge]][actions-url]
+[![Build Status][azure-badge]][azure-url]
 [![Discord chat][discord-badge]][discord-url]
 
 [crates-badge]: https://img.shields.io/crates/v/tokio.svg
 [crates-url]: https://crates.io/crates/tokio
 [mit-badge]: https://img.shields.io/badge/license-MIT-blue.svg
 [mit-url]: https://github.com/tokio-rs/tokio/blob/master/LICENSE
-[actions-badge]: https://github.com/tokio-rs/tokio/workflows/CI/badge.svg
-[actions-url]: https://github.com/tokio-rs/tokio/actions?query=workflow%3ACI+branch%3Amaster
+[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
 [discord-badge]: https://img.shields.io/discord/500028886025895936.svg?logo=discord&style=flat-square
 [discord-url]: https://discord.gg/tokio
 
 [Website](https://tokio.rs) |
 [Guides](https://tokio.rs/tokio/tutorial) |
 [API Docs](https://docs.rs/tokio/latest/tokio) |
+[Roadmap](https://github.com/tokio-rs/tokio/blob/master/ROADMAP.md) |
 [Chat](https://discord.gg/tokio)
 
 ## Overview
@@ -50,19 +51,11 @@ an asynchronous application.
 
 ## Example
 
-A basic TCP echo server with Tokio.
-
-Make sure you activated the full features of the tokio crate on Cargo.toml:
-
-```toml
-[dependencies]
-tokio = { version = "1.5.0", features = ["full"] }
-```
-Then, on your main.rs:
+A basic TCP echo server with Tokio:
 
 ```rust,no_run
 use tokio::net::TcpListener;
-use tokio::io::{AsyncReadExt, AsyncWriteExt};
+use tokio::prelude::*;
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
@@ -164,7 +157,7 @@ several other libraries, including:
 
 ## Supported Rust Versions
 
-Tokio is built against the latest stable release. The minimum supported version is 1.45.
+Tokio is built against the latest stable release. The minimum supported version is 1.39.
 The current Tokio version is not guaranteed to build on Rust versions earlier than the
 minimum supported version.
 

ROADMAP.md

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

benches/Cargo.toml

@@ -5,29 +5,22 @@ publish = false
 edition = "2018"
 
 [dependencies]
-tokio = { version = "1.5.0", path = "../tokio", features = ["full"] }
+tokio = { version = "0.2.0", path = "../tokio", features = ["full"] }
 bencher = "0.1.5"
 
-[dev-dependencies]
-tokio-util = { version = "0.6.6", path = "../tokio-util", features = ["full"] }
-tokio-stream = { path = "../tokio-stream" }
-
-[target.'cfg(unix)'.dependencies]
-libc = "0.2.42"
-
 [[bench]]
 name = "spawn"
 path = "spawn.rs"
 harness = false
 
 [[bench]]
-name = "sync_mpsc"
-path = "sync_mpsc.rs"
+name = "mpsc"
+path = "mpsc.rs"
 harness = false
 
 [[bench]]
-name = "rt_multi_threaded"
-path = "rt_multi_threaded.rs"
+name = "scheduler"
+path = "scheduler.rs"
 harness = false
 
 
@@ -40,13 +33,3 @@ harness = false
 name = "sync_semaphore"
 path = "sync_semaphore.rs"
 harness = false
-
-[[bench]]
-name = "signal"
-path = "signal.rs"
-harness = false
-
-[[bench]]
-name = "fs"
-path = "fs.rs"
-harness = false

benches/fs.rs

@@ -1,103 +0,0 @@
-#![cfg(unix)]
-
-use tokio_stream::StreamExt;
-
-use tokio::fs::File;
-use tokio::io::AsyncReadExt;
-use tokio_util::codec::{BytesCodec, FramedRead /*FramedWrite*/};
-
-use bencher::{benchmark_group, benchmark_main, Bencher};
-
-use std::fs::File as StdFile;
-use std::io::Read as StdRead;
-
-fn rt() -> tokio::runtime::Runtime {
-    tokio::runtime::Builder::new_multi_thread()
-        .worker_threads(2)
-        .build()
-        .unwrap()
-}
-
-const BLOCK_COUNT: usize = 1_000;
-
-const BUFFER_SIZE: usize = 4096;
-const DEV_ZERO: &'static str = "/dev/zero";
-
-fn async_read_codec(b: &mut Bencher) {
-    let rt = rt();
-
-    b.iter(|| {
-        let task = || async {
-            let file = File::open(DEV_ZERO).await.unwrap();
-            let mut input_stream = FramedRead::with_capacity(file, BytesCodec::new(), BUFFER_SIZE);
-
-            for _i in 0..BLOCK_COUNT {
-                let _bytes = input_stream.next().await.unwrap();
-            }
-        };
-
-        rt.block_on(task());
-    });
-}
-
-fn async_read_buf(b: &mut Bencher) {
-    let rt = rt();
-
-    b.iter(|| {
-        let task = || async {
-            let mut file = File::open(DEV_ZERO).await.unwrap();
-            let mut buffer = [0u8; BUFFER_SIZE];
-
-            for _i in 0..BLOCK_COUNT {
-                let count = file.read(&mut buffer).await.unwrap();
-                if count == 0 {
-                    break;
-                }
-            }
-        };
-
-        rt.block_on(task());
-    });
-}
-
-fn async_read_std_file(b: &mut Bencher) {
-    let rt = rt();
-
-    let task = || async {
-        let mut file = tokio::task::block_in_place(|| Box::pin(StdFile::open(DEV_ZERO).unwrap()));
-
-        for _i in 0..BLOCK_COUNT {
-            let mut buffer = [0u8; BUFFER_SIZE];
-            let mut file_ref = file.as_mut();
-
-            tokio::task::block_in_place(move || {
-                file_ref.read_exact(&mut buffer).unwrap();
-            });
-        }
-    };
-
-    b.iter(|| {
-        rt.block_on(task());
-    });
-}
-
-fn sync_read(b: &mut Bencher) {
-    b.iter(|| {
-        let mut file = StdFile::open(DEV_ZERO).unwrap();
-        let mut buffer = [0u8; BUFFER_SIZE];
-
-        for _i in 0..BLOCK_COUNT {
-            file.read_exact(&mut buffer).unwrap();
-        }
-    });
-}
-
-benchmark_group!(
-    file,
-    async_read_std_file,
-    async_read_buf,
-    async_read_codec,
-    sync_read
-);
-
-benchmark_main!(file);

benches/mpsc.rs

@@ -4,13 +4,6 @@ use tokio::sync::mpsc;
 type Medium = [usize; 64];
 type Large = [Medium; 64];
 
-fn rt() -> tokio::runtime::Runtime {
-    tokio::runtime::Builder::new_multi_thread()
-        .worker_threads(6)
-        .build()
-        .unwrap()
-}
-
 fn create_1_medium(b: &mut Bencher) {
     b.iter(|| {
         black_box(&mpsc::channel::<Medium>(1));
@@ -30,38 +23,38 @@ fn create_100_000_medium(b: &mut Bencher) {
 }
 
 fn send_medium(b: &mut Bencher) {
-    let rt = rt();
-
     b.iter(|| {
-        let (tx, mut rx) = mpsc::channel::<Medium>(1000);
+        let (mut tx, mut rx) = mpsc::channel::<Medium>(1000);
 
-        let _ = rt.block_on(tx.send([0; 64]));
+        let _ = tx.try_send([0; 64]);
 
-        rt.block_on(rx.recv()).unwrap();
+        rx.try_recv().unwrap();
     });
 }
 
 fn send_large(b: &mut Bencher) {
-    let rt = rt();
-
     b.iter(|| {
-        let (tx, mut rx) = mpsc::channel::<Large>(1000);
+        let (mut tx, mut rx) = mpsc::channel::<Large>(1000);
 
-        let _ = rt.block_on(tx.send([[0; 64]; 64]));
+        let _ = tx.try_send([[0; 64]; 64]);
 
-        rt.block_on(rx.recv()).unwrap();
+        rx.try_recv().unwrap();
     });
 }
 
 fn contention_bounded(b: &mut Bencher) {
-    let rt = rt();
+    let mut rt = tokio::runtime::Builder::new()
+        .core_threads(6)
+        .threaded_scheduler()
+        .build()
+        .unwrap();
 
     b.iter(|| {
         rt.block_on(async move {
             let (tx, mut rx) = mpsc::channel::<usize>(1_000_000);
 
             for _ in 0..5 {
-                let tx = tx.clone();
+                let mut tx = tx.clone();
                 tokio::spawn(async move {
                     for i in 0..1000 {
                         tx.send(i).await.unwrap();
@@ -77,14 +70,18 @@ fn contention_bounded(b: &mut Bencher) {
 }
 
 fn contention_bounded_full(b: &mut Bencher) {
-    let rt = rt();
+    let mut rt = tokio::runtime::Builder::new()
+        .core_threads(6)
+        .threaded_scheduler()
+        .build()
+        .unwrap();
 
     b.iter(|| {
         rt.block_on(async move {
             let (tx, mut rx) = mpsc::channel::<usize>(100);
 
             for _ in 0..5 {
-                let tx = tx.clone();
+                let mut tx = tx.clone();
                 tokio::spawn(async move {
                     for i in 0..1000 {
                         tx.send(i).await.unwrap();
@@ -100,7 +97,11 @@ fn contention_bounded_full(b: &mut Bencher) {
 }
 
 fn contention_unbounded(b: &mut Bencher) {
-    let rt = rt();
+    let mut rt = tokio::runtime::Builder::new()
+        .core_threads(6)
+        .threaded_scheduler()
+        .build()
+        .unwrap();
 
     b.iter(|| {
         rt.block_on(async move {
@@ -123,11 +124,15 @@ fn contention_unbounded(b: &mut Bencher) {
 }
 
 fn uncontented_bounded(b: &mut Bencher) {
-    let rt = rt();
+    let mut rt = tokio::runtime::Builder::new()
+        .core_threads(6)
+        .threaded_scheduler()
+        .build()
+        .unwrap();
 
     b.iter(|| {
         rt.block_on(async move {
-            let (tx, mut rx) = mpsc::channel::<usize>(1_000_000);
+            let (mut tx, mut rx) = mpsc::channel::<usize>(1_000_000);
 
             for i in 0..5000 {
                 tx.send(i).await.unwrap();
@@ -141,7 +146,11 @@ fn uncontented_bounded(b: &mut Bencher) {
 }
 
 fn uncontented_unbounded(b: &mut Bencher) {
-    let rt = rt();
+    let mut rt = tokio::runtime::Builder::new()
+        .core_threads(6)
+        .threaded_scheduler()
+        .build()
+        .unwrap();
 
     b.iter(|| {
         rt.block_on(async move {

benches/scheduler.rs

@@ -13,7 +13,7 @@ use std::sync::{mpsc, Arc};
 fn spawn_many(b: &mut Bencher) {
     const NUM_SPAWN: usize = 10_000;
 
-    let rt = rt();
+    let mut rt = rt();
 
     let (tx, rx) = mpsc::sync_channel(1000);
     let rem = Arc::new(AtomicUsize::new(0));
@@ -68,7 +68,7 @@ fn yield_many(b: &mut Bencher) {
 fn ping_pong(b: &mut Bencher) {
     const NUM_PINGS: usize = 1_000;
 
-    let rt = rt();
+    let mut rt = rt();
 
     let (done_tx, done_rx) = mpsc::sync_channel(1000);
     let rem = Arc::new(AtomicUsize::new(0));
@@ -111,7 +111,7 @@ fn ping_pong(b: &mut Bencher) {
 fn chained_spawn(b: &mut Bencher) {
     const ITER: usize = 1_000;
 
-    let rt = rt();
+    let mut rt = rt();
 
     fn iter(done_tx: mpsc::SyncSender<()>, n: usize) {
         if n == 0 {
@@ -139,8 +139,9 @@ fn chained_spawn(b: &mut Bencher) {
 }
 
 fn rt() -> Runtime {
-    runtime::Builder::new_multi_thread()
-        .worker_threads(4)
+    runtime::Builder::new()
+        .threaded_scheduler()
+        .core_threads(4)
         .enable_all()
         .build()
         .unwrap()

benches/signal.rs

@@ -1,95 +0,0 @@
-//! Benchmark the delay in propagating OS signals to any listeners.
-#![cfg(unix)]
-
-use bencher::{benchmark_group, benchmark_main, Bencher};
-use std::future::Future;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use tokio::runtime;
-use tokio::signal::unix::{signal, SignalKind};
-use tokio::sync::mpsc;
-
-struct Spinner {
-    count: usize,
-}
-
-impl Future for Spinner {
-    type Output = ();
-
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        if self.count > 3 {
-            Poll::Ready(())
-        } else {
-            self.count += 1;
-            cx.waker().wake_by_ref();
-            Poll::Pending
-        }
-    }
-}
-
-impl Spinner {
-    fn new() -> Self {
-        Self { count: 0 }
-    }
-}
-
-pub fn send_signal(signal: libc::c_int) {
-    use libc::{getpid, kill};
-
-    unsafe {
-        assert_eq!(kill(getpid(), signal), 0);
-    }
-}
-
-fn many_signals(bench: &mut Bencher) {
-    let num_signals = 10;
-    let (tx, mut rx) = mpsc::channel(num_signals);
-
-    // Intentionally single threaded to measure delays in propagating wakes
-    let rt = runtime::Builder::new_current_thread()
-        .enable_all()
-        .build()
-        .unwrap();
-
-    let spawn_signal = |kind| {
-        let tx = tx.clone();
-        rt.spawn(async move {
-            let mut signal = signal(kind).expect("failed to create signal");
-
-            while signal.recv().await.is_some() {
-                if tx.send(()).await.is_err() {
-                    break;
-                }
-            }
-        });
-    };
-
-    for _ in 0..num_signals {
-        // Pick some random signals which don't terminate the test harness
-        spawn_signal(SignalKind::child());
-        spawn_signal(SignalKind::io());
-    }
-    drop(tx);
-
-    // Turn the runtime for a while to ensure that all the spawned
-    // tasks have been polled at least once
-    rt.block_on(Spinner::new());
-
-    bench.iter(|| {
-        rt.block_on(async {
-            send_signal(libc::SIGCHLD);
-            for _ in 0..num_signals {
-                rx.recv().await.expect("channel closed");
-            }
-
-            send_signal(libc::SIGIO);
-            for _ in 0..num_signals {
-                rx.recv().await.expect("channel closed");
-            }
-        });
-    });
-}
-
-benchmark_group!(signal_group, many_signals,);
-
-benchmark_main!(signal_group);

benches/spawn.rs

@@ -10,7 +10,8 @@ async fn work() -> usize {
 }
 
 fn basic_scheduler_local_spawn(bench: &mut Bencher) {
-    let runtime = tokio::runtime::Builder::new_current_thread()
+    let mut runtime = tokio::runtime::Builder::new()
+        .basic_scheduler()
         .build()
         .unwrap();
     runtime.block_on(async {
@@ -22,7 +23,8 @@ fn basic_scheduler_local_spawn(bench: &mut Bencher) {
 }
 
 fn threaded_scheduler_local_spawn(bench: &mut Bencher) {
-    let runtime = tokio::runtime::Builder::new_current_thread()
+    let mut runtime = tokio::runtime::Builder::new()
+        .threaded_scheduler()
         .build()
         .unwrap();
     runtime.block_on(async {
@@ -34,21 +36,25 @@ fn threaded_scheduler_local_spawn(bench: &mut Bencher) {
 }
 
 fn basic_scheduler_remote_spawn(bench: &mut Bencher) {
-    let runtime = tokio::runtime::Builder::new_current_thread()
+    let runtime = tokio::runtime::Builder::new()
+        .basic_scheduler()
         .build()
         .unwrap();
-
+    let handle = runtime.handle();
     bench.iter(|| {
-        let h = runtime.spawn(work());
+        let h = handle.spawn(work());
         black_box(h);
     });
 }
 
 fn threaded_scheduler_remote_spawn(bench: &mut Bencher) {
-    let runtime = tokio::runtime::Builder::new_multi_thread().build().unwrap();
-
+    let runtime = tokio::runtime::Builder::new()
+        .threaded_scheduler()
+        .build()
+        .unwrap();
+    let handle = runtime.handle();
     bench.iter(|| {
-        let h = runtime.spawn(work());
+        let h = handle.spawn(work());
         black_box(h);
     });
 }

benches/sync_rwlock.rs

@@ -3,8 +3,9 @@ use std::sync::Arc;
 use tokio::{sync::RwLock, task};
 
 fn read_uncontended(b: &mut Bencher) {
-    let rt = tokio::runtime::Builder::new_multi_thread()
-        .worker_threads(6)
+    let mut rt = tokio::runtime::Builder::new()
+        .core_threads(6)
+        .threaded_scheduler()
         .build()
         .unwrap();
 
@@ -21,8 +22,9 @@ fn read_uncontended(b: &mut Bencher) {
 }
 
 fn read_concurrent_uncontended_multi(b: &mut Bencher) {
-    let rt = tokio::runtime::Builder::new_multi_thread()
-        .worker_threads(6)
+    let mut rt = tokio::runtime::Builder::new()
+        .core_threads(6)
+        .threaded_scheduler()
         .build()
         .unwrap();
 
@@ -49,7 +51,8 @@ fn read_concurrent_uncontended_multi(b: &mut Bencher) {
 }
 
 fn read_concurrent_uncontended(b: &mut Bencher) {
-    let rt = tokio::runtime::Builder::new_current_thread()
+    let mut rt = tokio::runtime::Builder::new()
+        .basic_scheduler()
         .build()
         .unwrap();
 
@@ -75,8 +78,9 @@ fn read_concurrent_uncontended(b: &mut Bencher) {
 }
 
 fn read_concurrent_contended_multi(b: &mut Bencher) {
-    let rt = tokio::runtime::Builder::new_multi_thread()
-        .worker_threads(6)
+    let mut rt = tokio::runtime::Builder::new()
+        .core_threads(6)
+        .threaded_scheduler()
         .build()
         .unwrap();
 
@@ -104,7 +108,8 @@ fn read_concurrent_contended_multi(b: &mut Bencher) {
 }
 
 fn read_concurrent_contended(b: &mut Bencher) {
-    let rt = tokio::runtime::Builder::new_current_thread()
+    let mut rt = tokio::runtime::Builder::new()
+        .basic_scheduler()
         .build()
         .unwrap();
 

benches/sync_semaphore.rs

@@ -3,8 +3,9 @@ use std::sync::Arc;
 use tokio::{sync::Semaphore, task};
 
 fn uncontended(b: &mut Bencher) {
-    let rt = tokio::runtime::Builder::new_multi_thread()
-        .worker_threads(6)
+    let mut rt = tokio::runtime::Builder::new()
+        .core_threads(6)
+        .threaded_scheduler()
         .build()
         .unwrap();
 
@@ -26,8 +27,9 @@ async fn task(s: Arc<Semaphore>) {
 }
 
 fn uncontended_concurrent_multi(b: &mut Bencher) {
-    let rt = tokio::runtime::Builder::new_multi_thread()
-        .worker_threads(6)
+    let mut rt = tokio::runtime::Builder::new()
+        .core_threads(6)
+        .threaded_scheduler()
         .build()
         .unwrap();
 
@@ -49,7 +51,8 @@ fn uncontended_concurrent_multi(b: &mut Bencher) {
 }
 
 fn uncontended_concurrent_single(b: &mut Bencher) {
-    let rt = tokio::runtime::Builder::new_current_thread()
+    let mut rt = tokio::runtime::Builder::new()
+        .basic_scheduler()
         .build()
         .unwrap();
 
@@ -70,8 +73,9 @@ fn uncontended_concurrent_single(b: &mut Bencher) {
 }
 
 fn contended_concurrent_multi(b: &mut Bencher) {
-    let rt = tokio::runtime::Builder::new_multi_thread()
-        .worker_threads(6)
+    let mut rt = tokio::runtime::Builder::new()
+        .core_threads(6)
+        .threaded_scheduler()
         .build()
         .unwrap();
 
@@ -93,7 +97,8 @@ fn contended_concurrent_multi(b: &mut Bencher) {
 }
 
 fn contended_concurrent_single(b: &mut Bencher) {
-    let rt = tokio::runtime::Builder::new_current_thread()
+    let mut rt = tokio::runtime::Builder::new()
+        .basic_scheduler()
         .build()
         .unwrap();
 

examples/Cargo.toml

@@ -7,22 +7,18 @@ edition = "2018"
 # If you copy one of the examples into a new project, you should be using
 # [dependencies] instead.
 [dev-dependencies]
-tokio = { version = "1.0.0", path = "../tokio",features = ["full", "tracing"] }
-tokio-util = { version = "0.6.3", path = "../tokio-util",features = ["full"] }
-tokio-stream = { version = "0.1", path = "../tokio-stream" }
-
+tokio = { version = "0.2.0", path = "../tokio", features = ["full", "tracing"] }
 tracing = "0.1"
 tracing-subscriber = { version = "0.2.7", default-features = false, features = ["fmt", "ansi", "env-filter", "chrono", "tracing-log"] }
-bytes = "1.0.0"
-futures = { version = "0.3.0", features = ["thread-pool"]}
+tokio-util = { version = "0.3.0", path = "../tokio-util", features = ["full"] }
+bytes = "0.5"
+futures = "0.3.0"
 http = "0.2"
 serde = "1.0"
 serde_derive = "1.0"
 serde_json = "1.0"
 httparse = "1.0"
 time = "0.1"
-once_cell = "1.5.2"
-
 
 [[example]]
 name = "chat"
@@ -67,12 +63,3 @@ path = "udp-codec.rs"
 [[example]]
 name = "tinyhttp"
 path = "tinyhttp.rs"
-
-[[example]]
-name = "custom-executor"
-path = "custom-executor.rs"
-
-
-[[example]]
-name = "custom-executor-tokio-context"
-path = "custom-executor-tokio-context.rs"

examples/chat.rs

@@ -27,9 +27,9 @@
 #![warn(rust_2018_idioms)]
 
 use tokio::net::{TcpListener, TcpStream};
+use tokio::stream::{Stream, StreamExt};
 use tokio::sync::{mpsc, Mutex};
-use tokio_stream::StreamExt;
-use tokio_util::codec::{Framed, LinesCodec};
+use tokio_util::codec::{Framed, LinesCodec, LinesCodecError};
 
 use futures::SinkExt;
 use std::collections::HashMap;
@@ -37,7 +37,9 @@ use std::env;
 use std::error::Error;
 use std::io;
 use std::net::SocketAddr;
+use std::pin::Pin;
 use std::sync::Arc;
+use std::task::{Context, Poll};
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn Error>> {
@@ -75,7 +77,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
     // Bind a TCP listener to the socket address.
     //
     // Note that this is the Tokio TcpListener, which is fully async.
-    let listener = TcpListener::bind(&addr).await?;
+    let mut listener = TcpListener::bind(&addr).await?;
 
     tracing::info!("server running on {}", addr);
 
@@ -166,6 +168,43 @@ impl Peer {
     }
 }
 
+#[derive(Debug)]
+enum Message {
+    /// A message that should be broadcasted to others.
+    Broadcast(String),
+
+    /// A message that should be received by a client
+    Received(String),
+}
+
+// Peer implements `Stream` in a way that polls both the `Rx`, and `Framed` types.
+// A message is produced whenever an event is ready until the `Framed` stream returns `None`.
+impl Stream for Peer {
+    type Item = Result<Message, LinesCodecError>;
+
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        // First poll the `UnboundedReceiver`.
+
+        if let Poll::Ready(Some(v)) = Pin::new(&mut self.rx).poll_next(cx) {
+            return Poll::Ready(Some(Ok(Message::Received(v))));
+        }
+
+        // Secondly poll the `Framed` stream.
+        let result: Option<_> = futures::ready!(Pin::new(&mut self.lines).poll_next(cx));
+
+        Poll::Ready(match result {
+            // We've received a message we should broadcast to others.
+            Some(Ok(message)) => Some(Ok(Message::Broadcast(message))),
+
+            // An error occurred.
+            Some(Err(e)) => Some(Err(e)),
+
+            // The stream has been exhausted.
+            None => None,
+        })
+    }
+}
+
 /// Process an individual chat client
 async fn process(
     state: Arc<Mutex<Shared>>,
@@ -199,32 +238,28 @@ async fn process(
     }
 
     // Process incoming messages until our stream is exhausted by a disconnect.
-    loop {
-        tokio::select! {
-            // A message was received from a peer. Send it to the current user.
-            Some(msg) = peer.rx.recv() => {
+    while let Some(result) = peer.next().await {
+        match result {
+            // A message was received from the current user, we should
+            // broadcast this message to the other users.
+            Ok(Message::Broadcast(msg)) => {
+                let mut state = state.lock().await;
+                let msg = format!("{}: {}", username, msg);
+
+                state.broadcast(addr, &msg).await;
+            }
+            // A message was received from a peer. Send it to the
+            // current user.
+            Ok(Message::Received(msg)) => {
                 peer.lines.send(&msg).await?;
             }
-            result = peer.lines.next() => match result {
-                // A message was received from the current user, we should
-                // broadcast this message to the other users.
-                Some(Ok(msg)) => {
-                    let mut state = state.lock().await;
-                    let msg = format!("{}: {}", username, msg);
-
-                    state.broadcast(addr, &msg).await;
-                }
-                // An error occurred.
-                Some(Err(e)) => {
-                    tracing::error!(
-                        "an error occurred while processing messages for {}; error = {:?}",
-                        username,
-                        e
-                    );
-                }
-                // The stream has been exhausted.
-                None => break,
-            },
+            Err(e) => {
+                tracing::error!(
+                    "an error occurred while processing messages for {}; error = {:?}",
+                    username,
+                    e
+                );
+            }
         }
     }
 

examples/connect.rs

@@ -92,10 +92,11 @@ mod tcp {
 
 mod udp {
     use bytes::Bytes;
-    use futures::{Sink, SinkExt, Stream, StreamExt};
+    use futures::{future, Sink, SinkExt, Stream, StreamExt};
     use std::error::Error;
     use std::io;
     use std::net::SocketAddr;
+    use tokio::net::udp::{RecvHalf, SendHalf};
     use tokio::net::UdpSocket;
 
     pub async fn connect(
@@ -113,15 +114,16 @@ mod udp {
 
         let socket = UdpSocket::bind(&bind_addr).await?;
         socket.connect(addr).await?;
+        let (mut r, mut w) = socket.split();
 
-        tokio::try_join!(send(stdin, &socket), recv(stdout, &socket))?;
+        future::try_join(send(stdin, &mut w), recv(stdout, &mut r)).await?;
 
         Ok(())
     }
 
     async fn send(
         mut stdin: impl Stream<Item = Result<Bytes, io::Error>> + Unpin,
-        writer: &UdpSocket,
+        writer: &mut SendHalf,
     ) -> Result<(), io::Error> {
         while let Some(item) = stdin.next().await {
             let buf = item?;
@@ -133,7 +135,7 @@ mod udp {
 
     async fn recv(
         mut stdout: impl Sink<Bytes, Error = io::Error> + Unpin,
-        reader: &UdpSocket,
+        reader: &mut RecvHalf,
     ) -> Result<(), io::Error> {
         loop {
             let mut buf = vec![0; 1024];

examples/custom-executor-tokio-context.rs

@@ -1,32 +0,0 @@
-// This example shows how to use the tokio runtime with any other executor
-//
-//It takes advantage from RuntimeExt which provides the extension to customize your
-//runtime.
-
-use tokio::net::TcpListener;
-use tokio::runtime::Builder;
-use tokio::sync::oneshot;
-use tokio_util::context::RuntimeExt;
-
-fn main() {
-    let (tx, rx) = oneshot::channel();
-    let rt1 = Builder::new_multi_thread()
-        .worker_threads(1)
-        // no timer!
-        .build()
-        .unwrap();
-    let rt2 = Builder::new_multi_thread()
-        .worker_threads(1)
-        .enable_all()
-        .build()
-        .unwrap();
-
-    // Without the `HandleExt.wrap()` there would be a panic because there is
-    // no timer running, since it would be referencing runtime r1.
-    let _ = rt1.block_on(rt2.wrap(async move {
-        let listener = TcpListener::bind("0.0.0.0:0").await.unwrap();
-        println!("addr: {:?}", listener.local_addr());
-        tx.send(()).unwrap();
-    }));
-    futures::executor::block_on(rx).unwrap();
-}

examples/custom-executor.rs

@@ -1,56 +0,0 @@
-// This example shows how to use the tokio runtime with any other executor
-//
-// The main components are a spawn fn that will wrap futures in a special future
-// that will always enter the tokio context on poll. This only spawns one extra thread
-// to manage and run the tokio drivers in the background.
-
-use tokio::net::TcpListener;
-use tokio::sync::oneshot;
-
-fn main() {
-    let (tx, rx) = oneshot::channel();
-
-    my_custom_runtime::spawn(async move {
-        let listener = TcpListener::bind("0.0.0.0:0").await.unwrap();
-
-        println!("addr: {:?}", listener.local_addr());
-
-        tx.send(()).unwrap();
-    });
-
-    futures::executor::block_on(rx).unwrap();
-}
-
-mod my_custom_runtime {
-    use once_cell::sync::Lazy;
-    use std::future::Future;
-    use tokio_util::context::TokioContext;
-
-    pub fn spawn(f: impl Future<Output = ()> + Send + 'static) {
-        EXECUTOR.spawn(f);
-    }
-
-    struct ThreadPool {
-        inner: futures::executor::ThreadPool,
-        rt: tokio::runtime::Runtime,
-    }
-
-    static EXECUTOR: Lazy<ThreadPool> = Lazy::new(|| {
-        // Spawn tokio runtime on a single background thread
-        // enabling IO and timers.
-        let rt = tokio::runtime::Builder::new_multi_thread()
-            .enable_all()
-            .build()
-            .unwrap();
-        let inner = futures::executor::ThreadPool::builder().create().unwrap();
-
-        ThreadPool { inner, rt }
-    });
-
-    impl ThreadPool {
-        fn spawn(&self, f: impl Future<Output = ()> + Send + 'static) {
-            let handle = self.rt.handle().clone();
-            self.inner.spawn_ok(TokioContext::new(f, handle));
-        }
-    }
-}

examples/echo-udp.rs

@@ -26,7 +26,7 @@ struct Server {
 impl Server {
     async fn run(self) -> Result<(), io::Error> {
         let Server {
-            socket,
+            mut socket,
             mut buf,
             mut to_send,
         } = self;

examples/echo.rs

@@ -39,7 +39,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
     // 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.
-    let listener = TcpListener::bind(&addr).await?;
+    let mut listener = TcpListener::bind(&addr).await?;
     println!("Listening on: {}", addr);
 
     loop {
@@ -55,7 +55,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
         // which will allow all of our clients to be processed concurrently.
 
         tokio::spawn(async move {
-            let mut buf = vec![0; 1024];
+            let mut buf = [0; 1024];
 
             // In a loop, read data from the socket and write the data back.
             loop {

examples/print_each_packet.rs

@@ -55,7 +55,7 @@
 #![warn(rust_2018_idioms)]
 
 use tokio::net::TcpListener;
-use tokio_stream::StreamExt;
+use tokio::stream::StreamExt;
 use tokio_util::codec::{BytesCodec, Decoder};
 
 use std::env;
@@ -74,7 +74,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // 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 listener = TcpListener::bind(&addr).await?;
+    let mut listener = TcpListener::bind(&addr).await?;
     println!("Listening on: {}", addr);
 
     loop {

examples/proxy.rs

@@ -26,6 +26,7 @@ use tokio::io;
 use tokio::io::AsyncWriteExt;
 use tokio::net::{TcpListener, TcpStream};
 
+use futures::future::try_join;
 use futures::FutureExt;
 use std::env;
 use std::error::Error;
@@ -42,7 +43,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
     println!("Listening on: {}", listen_addr);
     println!("Proxying to: {}", server_addr);
 
-    let listener = TcpListener::bind(listen_addr).await?;
+    let mut listener = TcpListener::bind(listen_addr).await?;
 
     while let Ok((inbound, _)) = listener.accept().await {
         let transfer = transfer(inbound, server_addr.clone()).map(|r| {
@@ -73,7 +74,7 @@ async fn transfer(mut inbound: TcpStream, proxy_addr: String) -> Result<(), Box<
         wi.shutdown().await
     };
 
-    tokio::try_join!(client_to_server, server_to_client)?;
+    try_join(client_to_server, server_to_client).await?;
 
     Ok(())
 }

examples/tinydb.rs

@@ -42,7 +42,7 @@
 #![warn(rust_2018_idioms)]
 
 use tokio::net::TcpListener;
-use tokio_stream::StreamExt;
+use tokio::stream::StreamExt;
 use tokio_util::codec::{Framed, LinesCodec};
 
 use futures::SinkExt;
@@ -89,7 +89,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
         .nth(1)
         .unwrap_or_else(|| "127.0.0.1:8080".to_string());
 
-    let listener = TcpListener::bind(&addr).await?;
+    let mut listener = TcpListener::bind(&addr).await?;
     println!("Listening on: {}", addr);
 
     // Create the shared state of this server that will be shared amongst all

examples/tinyhttp.rs

@@ -20,7 +20,7 @@ use http::{header::HeaderValue, Request, Response, StatusCode};
 extern crate serde_derive;
 use std::{env, error::Error, fmt, io};
 use tokio::net::{TcpListener, TcpStream};
-use tokio_stream::StreamExt;
+use tokio::stream::StreamExt;
 use tokio_util::codec::{Decoder, Encoder, Framed};
 
 #[tokio::main]
@@ -30,17 +30,19 @@ async fn main() -> Result<(), Box<dyn Error>> {
     let addr = env::args()
         .nth(1)
         .unwrap_or_else(|| "127.0.0.1:8080".to_string());
-    let server = TcpListener::bind(&addr).await?;
+    let mut server = TcpListener::bind(&addr).await?;
+    let mut incoming = server.incoming();
     println!("Listening on: {}", addr);
 
-    loop {
-        let (stream, _) = server.accept().await?;
+    while let Some(Ok(stream)) = incoming.next().await {
         tokio::spawn(async move {
             if let Err(e) = process(stream).await {
                 println!("failed to process connection; error = {}", e);
             }
         });
     }
+
+    Ok(())
 }
 
 async fn process(stream: TcpStream) -> Result<(), Box<dyn Error>> {

examples/udp-client.rs

@@ -55,7 +55,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
     }
     .parse()?;
 
-    let socket = UdpSocket::bind(local_addr).await?;
+    let mut socket = UdpSocket::bind(local_addr).await?;
     const MAX_DATAGRAM_SIZE: usize = 65_507;
     socket.connect(&remote_addr).await?;
     let data = get_stdin_data()?;

examples/udp-codec.rs

@@ -9,8 +9,8 @@
 #![warn(rust_2018_idioms)]
 
 use tokio::net::UdpSocket;
+use tokio::stream::StreamExt;
 use tokio::{io, time};
-use tokio_stream::StreamExt;
 use tokio_util::codec::BytesCodec;
 use tokio_util::udp::UdpFramed;
 
@@ -45,7 +45,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
     let b = pong(&mut b);
 
     // Run both futures simultaneously of `a` and `b` sending messages back and forth.
-    match tokio::try_join!(a, b) {
+    match futures::future::try_join(a, b).await {
         Err(e) => println!("an error occurred; error = {:?}", e),
         _ => println!("done!"),
     }

stress-test/Cargo.toml

@@ -1,14 +0,0 @@
-[package]
-name = "stress-test"
-version = "0.1.0"
-authors = ["Tokio Contributors <[email protected]>"]
-edition = "2018"
-publish = false
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-tokio = { path = "../tokio/", features = ["full"] }
-
-[dev-dependencies]
-rand = "0.8"

stress-test/examples/simple_echo_tcp.rs

@@ -1,58 +0,0 @@
-//! Simple TCP echo server to check memory leaks using Valgrind.
-use std::{thread::sleep, time::Duration};
-
-use tokio::{
-    io::{AsyncReadExt, AsyncWriteExt},
-    net::{TcpListener, TcpSocket},
-    runtime::Builder,
-    sync::oneshot,
-};
-
-const TCP_ENDPOINT: &str = "127.0.0.1:8080";
-const NUM_MSGS: usize = 100;
-const MSG_SIZE: usize = 1024;
-
-fn main() {
-    let rt = Builder::new_multi_thread().enable_io().build().unwrap();
-    let rt2 = Builder::new_multi_thread().enable_io().build().unwrap();
-
-    rt.spawn(async {
-        let listener = TcpListener::bind(TCP_ENDPOINT).await.unwrap();
-        let (mut socket, _) = listener.accept().await.unwrap();
-        let (mut rd, mut wr) = socket.split();
-        while tokio::io::copy(&mut rd, &mut wr).await.is_ok() {}
-    });
-
-    // wait a bit so that the listener binds.
-    sleep(Duration::from_millis(100));
-
-    // create a channel to let the main thread know that all the messages were sent and received.
-    let (tx, mut rx) = oneshot::channel();
-
-    rt2.spawn(async {
-        let addr = TCP_ENDPOINT.parse().unwrap();
-        let socket = TcpSocket::new_v4().unwrap();
-        let mut stream = socket.connect(addr).await.unwrap();
-
-        let mut buff = [0; MSG_SIZE];
-        for _ in 0..NUM_MSGS {
-            let one_mega_random_bytes: Vec<u8> =
-                (0..MSG_SIZE).map(|_| rand::random::<u8>()).collect();
-            stream
-                .write_all(one_mega_random_bytes.as_slice())
-                .await
-                .unwrap();
-            stream.read(&mut buff).await.unwrap();
-        }
-        tx.send(()).unwrap();
-    });
-
-    loop {
-        // check that we're done.
-        match rx.try_recv() {
-            Err(oneshot::error::TryRecvError::Empty) => (),
-            Err(oneshot::error::TryRecvError::Closed) => panic!("channel got closed..."),
-            Ok(()) => break,
-        }
-    }
-}

tests-build/Cargo.toml

@@ -7,7 +7,6 @@ publish = false
 
 [features]
 full = ["tokio/full"]
-rt = ["tokio/rt", "tokio/macros"]
 
 [dependencies]
 tokio = { path = "../tokio", optional = true }

tests-build/tests/fail/macros_core_no_default.rs

@@ -1,6 +0,0 @@
-use tests_build::tokio;
-
-#[tokio::main]
-async fn my_fn() {}
-
-fn main() {}

tests-build/tests/fail/macros_core_no_default.stderr

@@ -1,7 +0,0 @@
-error: The default runtime flavor is `multi_thread`, but the `rt-multi-thread` feature is disabled.
- --> $DIR/macros_core_no_default.rs:3:1
-  |
-3 | #[tokio::main]
-  | ^^^^^^^^^^^^^^
-  |
-  = note: this error originates in an attribute macro (in Nightly builds, run with -Z macro-backtrace for more info)

tests-build/tests/fail/macros_dead_code.rs

@@ -1,8 +0,0 @@
-#![deny(dead_code)]
-
-use tests_build::tokio;
-
-#[tokio::main]
-async fn f() {}
-
-fn main() {}

tests-build/tests/fail/macros_dead_code.stderr

@@ -1,11 +0,0 @@
-error: function is never used: `f`
- --> $DIR/macros_dead_code.rs:6:10
-  |
-6 | async fn f() {}
-  |          ^
-  |
-note: the lint level is defined here
- --> $DIR/macros_dead_code.rs:1:9
-  |
-1 | #![deny(dead_code)]
-  |         ^^^^^^^^^

tests-build/tests/fail/macros_invalid_input.rs

@@ -12,27 +12,12 @@ async fn main_attr_has_path_args() {}
 #[tokio::test]
 fn test_is_not_async() {}
 
+#[tokio::test]
+async fn test_fn_has_args(_x: u8) {}
+
 #[tokio::test(foo)]
 async fn test_attr_has_args() {}
 
-#[tokio::test(foo = 123)]
-async fn test_unexpected_attr() {}
-
-#[tokio::test(flavor = 123)]
-async fn test_flavor_not_string() {}
-
-#[tokio::test(flavor = "foo")]
-async fn test_unknown_flavor() {}
-
-#[tokio::test(flavor = "multi_thread", start_paused = false)]
-async fn test_multi_thread_with_start_paused() {}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = "foo")]
-async fn test_worker_threads_not_int() {}
-
-#[tokio::test(flavor = "current_thread", worker_threads = 4)]
-async fn test_worker_threads_and_current_thread() {}
-
 #[tokio::test]
 #[test]
 async fn test_has_second_test_attr() {}

tests-build/tests/fail/macros_invalid_input.stderr

@@ -1,10 +1,10 @@
-error: the `async` keyword is missing from the function declaration
+error: the async keyword is missing from the function declaration
  --> $DIR/macros_invalid_input.rs:4:1
   |
 4 | fn main_is_not_async() {}
   | ^^
 
-error: Unknown attribute foo is specified; expected one of: `flavor`, `worker_threads`, `start_paused`
+error: Unknown attribute foo is specified; expected `basic_scheduler` or `threaded_scheduler`
  --> $DIR/macros_invalid_input.rs:6:15
   |
 6 | #[tokio::main(foo)]
@@ -16,56 +16,26 @@ error: Must have specified ident
 9 | #[tokio::main(threadpool::bar)]
   |               ^^^^^^^^^^^^^^^
 
-error: the `async` keyword is missing from the function declaration
+error: the async keyword is missing from the function declaration
   --> $DIR/macros_invalid_input.rs:13:1
    |
 13 | fn test_is_not_async() {}
    | ^^
 
-error: Unknown attribute foo is specified; expected one of: `flavor`, `worker_threads`, `start_paused`
-  --> $DIR/macros_invalid_input.rs:15:15
+error: the test function cannot accept arguments
+  --> $DIR/macros_invalid_input.rs:16:27
    |
-15 | #[tokio::test(foo)]
-   |               ^^^
+16 | async fn test_fn_has_args(_x: u8) {}
+   |                           ^^^^^^
 
-error: Unknown attribute foo is specified; expected one of: `flavor`, `worker_threads`, `start_paused`
+error: Unknown attribute foo is specified; expected `basic_scheduler` or `threaded_scheduler`
   --> $DIR/macros_invalid_input.rs:18:15
    |
-18 | #[tokio::test(foo = 123)]
-   |               ^^^^^^^^^
-
-error: Failed to parse value of `flavor` as string.
-  --> $DIR/macros_invalid_input.rs:21:24
-   |
-21 | #[tokio::test(flavor = 123)]
-   |                        ^^^
-
-error: No such runtime flavor `foo`. The runtime flavors are `current_thread` and `multi_thread`.
-  --> $DIR/macros_invalid_input.rs:24:24
-   |
-24 | #[tokio::test(flavor = "foo")]
-   |                        ^^^^^
-
-error: The `start_paused` option requires the `current_thread` runtime flavor. Use `#[tokio::test(flavor = "current_thread")]`
-  --> $DIR/macros_invalid_input.rs:27:55
-   |
-27 | #[tokio::test(flavor = "multi_thread", start_paused = false)]
-   |                                                       ^^^^^
-
-error: Failed to parse value of `worker_threads` as integer.
-  --> $DIR/macros_invalid_input.rs:30:57
-   |
-30 | #[tokio::test(flavor = "multi_thread", worker_threads = "foo")]
-   |                                                         ^^^^^
-
-error: The `worker_threads` option requires the `multi_thread` runtime flavor. Use `#[tokio::test(flavor = "multi_thread")]`
-  --> $DIR/macros_invalid_input.rs:33:59
-   |
-33 | #[tokio::test(flavor = "current_thread", worker_threads = 4)]
-   |                                                           ^
+18 | #[tokio::test(foo)]
+   |               ^^^
 
 error: second test attribute is supplied
-  --> $DIR/macros_invalid_input.rs:37:1
+  --> $DIR/macros_invalid_input.rs:22:1
    |
-37 | #[test]
+22 | #[test]
    | ^^^^^^^

tests-build/tests/fail/macros_type_mismatch.rs

@@ -1,32 +0,0 @@
-use tests_build::tokio;
-
-#[tokio::main]
-async fn missing_semicolon_or_return_type() {
-    Ok(())
-}
-
-#[tokio::main]
-async fn missing_return_type() {
-    /* TODO(taiki-e): one of help messages still wrong
-    help: consider using a semicolon here
-       |
-    16 |     return Ok(());;
-       |
-    */
-    return Ok(());
-}
-
-#[tokio::main]
-async fn extra_semicolon() -> Result<(), ()> {
-    /* TODO(taiki-e): help message still wrong
-    help: try using a variant of the expected enum
-       |
-    29 |     Ok(Ok(());)
-       |
-    29 |     Err(Ok(());)
-       |
-    */
-    Ok(());
-}
-
-fn main() {}

tests-build/tests/fail/macros_type_mismatch.stderr

@@ -1,51 +0,0 @@
-error[E0308]: mismatched types
- --> $DIR/macros_type_mismatch.rs:5:5
-  |
-5 |     Ok(())
-  |     ^^^^^^ expected `()`, found enum `Result`
-  |
-  = note: expected unit type `()`
-                  found enum `Result<(), _>`
-help: consider using a semicolon here
-  |
-5 |     Ok(());
-  |           ^
-help: try adding a return type
-  |
-4 | async fn missing_semicolon_or_return_type() -> Result<(), _> {
-  |                                             ^^^^^^^^^^^^^^^^
-
-error[E0308]: mismatched types
-  --> $DIR/macros_type_mismatch.rs:16:5
-   |
-16 |     return Ok(());
-   |     ^^^^^^^^^^^^^^ expected `()`, found enum `Result`
-   |
-   = note: expected unit type `()`
-                   found enum `Result<(), _>`
-help: consider using a semicolon here
-   |
-16 |     return Ok(());;
-   |                   ^
-help: try adding a return type
-   |
-9  | async fn missing_return_type() -> Result<(), _> {
-   |                                ^^^^^^^^^^^^^^^^
-
-error[E0308]: mismatched types
-  --> $DIR/macros_type_mismatch.rs:29:5
-   |
-20 | async fn extra_semicolon() -> Result<(), ()> {
-   |                               -------------- expected `Result<(), ()>` because of return type
-...
-29 |     Ok(());
-   |     ^^^^^^^ expected enum `Result`, found `()`
-   |
-   = note:   expected enum `Result<(), ()>`
-           found unit type `()`
-help: try using a variant of the expected enum
-   |
-29 |     Ok(Ok(());)
-   |
-29 |     Err(Ok(());)
-   |

tests-build/tests/macros.rs

@@ -1,21 +1,9 @@
 #[test]
-fn compile_fail_full() {
+fn compile_fail() {
     let t = trybuild::TestCases::new();
 
-    #[cfg(feature = "full")]
-    t.pass("tests/pass/forward_args_and_output.rs");
-
     #[cfg(feature = "full")]
     t.compile_fail("tests/fail/macros_invalid_input.rs");
 
-    #[cfg(feature = "full")]
-    t.compile_fail("tests/fail/macros_dead_code.rs");
-
-    #[cfg(feature = "full")]
-    t.compile_fail("tests/fail/macros_type_mismatch.rs");
-
-    #[cfg(all(feature = "rt", not(feature = "full")))]
-    t.compile_fail("tests/fail/macros_core_no_default.rs");
-
     drop(t);
 }

tests-build/tests/pass/forward_args_and_output.rs

@@ -1,13 +0,0 @@
-use tests_build::tokio;
-
-fn main() {}
-
-// arguments and output type is forwarded so other macros can access them
-
-#[tokio::test]
-async fn test_fn_has_args(_x: u8) {}
-
-#[tokio::test]
-async fn test_has_output() -> Result<(), Box<dyn std::error::Error>> {
-    Ok(())
-}

tests-integration/Cargo.toml

@@ -5,38 +5,24 @@ authors = ["Tokio Contributors <[email protected]>"]
 edition = "2018"
 publish = false
 
-[[bin]]
-name = "test-cat"
-
-[[bin]]
-name = "test-mem"
-required-features = ["rt-net"]
-
-[[bin]]
-name = "test-process-signal"
-required-features = ["rt-process-signal"]
-
 [features]
-# For mem check
-rt-net = ["tokio/rt", "tokio/rt-multi-thread", "tokio/net"]
-# For test-process-signal
-rt-process-signal = ["rt", "tokio/process", "tokio/signal"]
-
 full = [
     "macros",
-    "rt",
-    "rt-multi-thread",
+    "rt-core",
+    "rt-threaded",
 
     "tokio/full",
     "tokio-test"
 ]
 macros = ["tokio/macros"]
 sync = ["tokio/sync"]
-rt = ["tokio/rt"]
-rt-multi-thread = ["rt", "tokio/rt-multi-thread"]
+rt-core = ["tokio/rt-core"]
+rt-threaded = ["rt-core", "tokio/rt-threaded"]
 
 [dependencies]
 tokio = { path = "../tokio" }
 tokio-test = { path = "../tokio-test", optional = true }
 doc-comment = "0.3.1"
+
+[dev-dependencies]
 futures = { version = "0.3.0", features = ["async-await"] }

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

@@ -1,21 +0,0 @@
-use futures::future::poll_fn;
-
-fn main() {
-    let rt = tokio::runtime::Builder::new_multi_thread()
-        .worker_threads(1)
-        .enable_io()
-        .build()
-        .unwrap();
-
-    rt.block_on(async {
-        let listener = tokio::net::TcpListener::bind("0.0.0.0:0").await.unwrap();
-        tokio::spawn(async move {
-            loop {
-                poll_fn(|cx| listener.poll_accept(cx)).await.unwrap();
-            }
-        });
-    });
-
-    std::thread::sleep(std::time::Duration::from_millis(50));
-    drop(rt);
-}

tests-integration/src/bin/test-process-signal.rs

@@ -1,11 +0,0 @@
-// https://github.com/tokio-rs/tokio/issues/3550
-fn main() {
-    for _ in 0..1000 {
-        let rt = tokio::runtime::Builder::new_current_thread()
-            .enable_all()
-            .build()
-            .unwrap();
-
-        drop(rt);
-    }
-}

tests-integration/tests/macros_main.rs

@@ -1,4 +1,4 @@
-#![cfg(all(feature = "macros", feature = "rt"))]
+#![cfg(feature = "macros")]
 
 #[tokio::main]
 async fn basic_main() -> usize {
@@ -10,15 +10,18 @@ async fn generic_fun<T: Default>() -> T {
     T::default()
 }
 
-#[tokio::main]
-async fn spawning() -> usize {
-    let join = tokio::spawn(async { 1 });
-    join.await.unwrap()
-}
+#[cfg(feature = "rt-core")]
+mod spawn {
+    #[tokio::main]
+    async fn spawning() -> usize {
+        let join = tokio::spawn(async { 1 });
+        join.await.unwrap()
+    }
 
-#[test]
-fn main_with_spawn() {
-    assert_eq!(1, spawning());
+    #[test]
+    fn main_with_spawn() {
+        assert_eq!(1, spawning());
+    }
 }
 
 #[test]

tests-integration/tests/process_stdio.rs

@@ -1,19 +1,26 @@
 #![warn(rust_2018_idioms)]
 #![cfg(feature = "full")]
 
-use tokio::io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader};
-use tokio::join;
+use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
 use tokio::process::{Child, Command};
 use tokio_test::assert_ok;
 
 use futures::future::{self, FutureExt};
-use std::convert::TryInto;
 use std::env;
 use std::io;
 use std::process::{ExitStatus, Stdio};
 
 fn cat() -> Command {
-    let mut cmd = Command::new(env!("CARGO_BIN_EXE_test-cat"));
+    let mut me = env::current_exe().unwrap();
+    me.pop();
+
+    if me.ends_with("deps") {
+        me.pop();
+    }
+
+    me.push("test-cat");
+
+    let mut cmd = Command::new(me);
     cmd.stdin(Stdio::piped()).stdout(Stdio::piped());
     cmd
 }
@@ -65,7 +72,7 @@ async fn feed_cat(mut cat: Child, n: usize) -> io::Result<ExitStatus> {
     };
 
     // Compose reading and writing concurrently.
-    future::join3(write, read, cat.wait())
+    future::join3(write, read, cat)
         .map(|(_, _, status)| status)
         .await
 }
@@ -118,75 +125,3 @@ async fn status_closes_any_pipes() {
 
     assert_ok!(child.await);
 }
-
-#[tokio::test]
-async fn try_wait() {
-    let mut child = cat().spawn().unwrap();
-
-    let id = child.id().expect("missing id");
-    assert!(id > 0);
-
-    assert_eq!(None, assert_ok!(child.try_wait()));
-
-    // Drop the child's stdio handles so it can terminate
-    drop(child.stdin.take());
-    drop(child.stderr.take());
-    drop(child.stdout.take());
-
-    assert_ok!(child.wait().await);
-
-    // test that the `.try_wait()` method is fused just like the stdlib
-    assert!(assert_ok!(child.try_wait()).unwrap().success());
-
-    // Can't get id after process has exited
-    assert_eq!(child.id(), None);
-}
-
-#[tokio::test]
-async fn pipe_from_one_command_to_another() {
-    let mut first = cat().spawn().expect("first cmd");
-    let mut third = cat().spawn().expect("third cmd");
-
-    // Convert ChildStdout to Stdio
-    let second_stdin: Stdio = first
-        .stdout
-        .take()
-        .expect("first.stdout")
-        .try_into()
-        .expect("first.stdout into Stdio");
-
-    // Convert ChildStdin to Stdio
-    let second_stdout: Stdio = third
-        .stdin
-        .take()
-        .expect("third.stdin")
-        .try_into()
-        .expect("third.stdin into Stdio");
-
-    let mut second = cat()
-        .stdin(second_stdin)
-        .stdout(second_stdout)
-        .spawn()
-        .expect("first cmd");
-
-    let msg = "hello world! please pipe this message through";
-
-    let mut stdin = first.stdin.take().expect("first.stdin");
-    let write = async move { stdin.write_all(msg.as_bytes()).await };
-
-    let mut stdout = third.stdout.take().expect("third.stdout");
-    let read = async move {
-        let mut data = String::new();
-        stdout.read_to_string(&mut data).await.map(|_| data)
-    };
-
-    let (read, write, first_status, second_status, third_status) =
-        join!(read, write, first.wait(), second.wait(), third.wait());
-
-    assert_eq!(msg, read.expect("read result"));
-    write.expect("write result");
-
-    assert!(first_status.expect("first status").success());
-    assert!(second_status.expect("second status").success());
-    assert!(third_status.expect("third status").success());
-}

tests-integration/tests/rt_shell.rs

@@ -0,0 +1,32 @@
+#![warn(rust_2018_idioms)]
+#![cfg(feature = "sync")]
+
+use tokio::runtime;
+use tokio::sync::oneshot;
+
+use std::sync::mpsc;
+use std::thread;
+
+#[test]
+fn basic_shell_rt() {
+    let (feed_tx, feed_rx) = mpsc::channel::<oneshot::Sender<()>>();
+
+    let th = thread::spawn(move || {
+        for tx in feed_rx.iter() {
+            tx.send(()).unwrap();
+        }
+    });
+
+    for _ in 0..1_000 {
+        let mut rt = runtime::Builder::new().build().unwrap();
+
+        let (tx, rx) = oneshot::channel();
+
+        feed_tx.send(tx).unwrap();
+
+        rt.block_on(rx).unwrap();
+    }
+
+    drop(feed_tx);
+    th.join().unwrap();
+}

tokio-macros/CHANGELOG.md

@@ -1,25 +1,3 @@
-# 1.1.0 (February 5, 2021)
-
-- add `start_paused` option to macros ([#3492])
-
-# 1.0.0 (December 23, 2020)
-
-- track `tokio` 1.0 release.
-
-# 0.3.1 (October 25, 2020)
-
-### Fixed
-
-- fix incorrect docs regarding `max_threads` option ([#3038])
-
-# 0.3.0 (October 15, 2020)
-
-- Track `tokio` 0.3 release.
-
-### Changed
-- options are renamed to track `tokio` runtime builder fn names.
-- `#[tokio::main]` macro requires `rt-multi-thread` when no `flavor` is specified.
-
 # 0.2.5 (February 27, 2019)
 
 ### Fixed
@@ -52,11 +30,9 @@
 
 - Initial release
 
-[#1954]: https://github.com/tokio-rs/tokio/pull/1954
-[#2022]: https://github.com/tokio-rs/tokio/pull/2022
-[#2038]: https://github.com/tokio-rs/tokio/pull/2038
-[#2152]: https://github.com/tokio-rs/tokio/pull/2152
-[#2177]: https://github.com/tokio-rs/tokio/pull/2177
 [#2225]: https://github.com/tokio-rs/tokio/pull/2225
-[#3038]: https://github.com/tokio-rs/tokio/pull/3038
-[#3492]: https://github.com/tokio-rs/tokio/pull/3492
+[#2177]: https://github.com/tokio-rs/tokio/pull/2177
+[#2152]: https://github.com/tokio-rs/tokio/pull/2152
+[#2038]: https://github.com/tokio-rs/tokio/pull/2038
+[#2022]: https://github.com/tokio-rs/tokio/pull/2022
+[#1954]: https://github.com/tokio-rs/tokio/pull/1954

tokio-macros/Cargo.toml

@@ -2,17 +2,18 @@
 name = "tokio-macros"
 # When releasing to crates.io:
 # - Remove path dependencies
+# - Update html_root_url.
 # - Update doc url
 #   - Cargo.toml
 # - Update CHANGELOG.md.
-# - Create "tokio-macros-1.0.x" git tag.
-version = "1.1.0"
+# - Create "v0.1.x" git tag.
+version = "0.2.5"
 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-macros/1.1.0/tokio_macros"
+documentation = "https://docs.rs/tokio-macros/0.2.5/tokio_macros"
 description = """
 Tokio's proc macros.
 """
@@ -26,10 +27,10 @@ proc-macro = true
 [dependencies]
 proc-macro2 = "1.0.7"
 quote = "1"
-syn = { version = "1.0.56", features = ["full"] }
+syn = { version = "1.0.3", features = ["full"] }
 
 [dev-dependencies]
-tokio = { version = "1.0.0", path = "../tokio", features = ["full"] }
+tokio = { version = "0.2.0", path = "../tokio", features = ["full"] }
 
 [package.metadata.docs.rs]
 all-features = true

tokio-macros/LICENSE

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

tokio-macros/src/entry.rs

@@ -1,202 +1,34 @@
 use proc_macro::TokenStream;
-use proc_macro2::Span;
-use quote::{quote, quote_spanned, ToTokens};
+use quote::quote;
+use std::num::NonZeroUsize;
 
 #[derive(Clone, Copy, PartialEq)]
-enum RuntimeFlavor {
-    CurrentThread,
+enum Runtime {
+    Basic,
     Threaded,
 }
 
-impl RuntimeFlavor {
-    fn from_str(s: &str) -> Result<RuntimeFlavor, String> {
-        match s {
-            "current_thread" => Ok(RuntimeFlavor::CurrentThread),
-            "multi_thread" => Ok(RuntimeFlavor::Threaded),
-            "single_thread" => Err("The single threaded runtime flavor is called `current_thread`.".to_string()),
-            "basic_scheduler" => Err("The `basic_scheduler` runtime flavor has been renamed to `current_thread`.".to_string()),
-            "threaded_scheduler" => Err("The `threaded_scheduler` runtime flavor has been renamed to `multi_thread`.".to_string()),
-            _ => Err(format!("No such runtime flavor `{}`. The runtime flavors are `current_thread` and `multi_thread`.", s)),
-        }
-    }
-}
-
-struct FinalConfig {
-    flavor: RuntimeFlavor,
-    worker_threads: Option<usize>,
-    start_paused: Option<bool>,
-}
-
-struct Configuration {
-    rt_multi_thread_available: bool,
-    default_flavor: RuntimeFlavor,
-    flavor: Option<RuntimeFlavor>,
-    worker_threads: Option<(usize, Span)>,
-    start_paused: Option<(bool, Span)>,
-    is_test: bool,
-}
-
-impl Configuration {
-    fn new(is_test: bool, rt_multi_thread: bool) -> Self {
-        Configuration {
-            rt_multi_thread_available: rt_multi_thread,
-            default_flavor: match is_test {
-                true => RuntimeFlavor::CurrentThread,
-                false => RuntimeFlavor::Threaded,
-            },
-            flavor: None,
-            worker_threads: None,
-            start_paused: None,
-            is_test,
-        }
-    }
-
-    fn set_flavor(&mut self, runtime: syn::Lit, span: Span) -> Result<(), syn::Error> {
-        if self.flavor.is_some() {
-            return Err(syn::Error::new(span, "`flavor` set multiple times."));
-        }
-
-        let runtime_str = parse_string(runtime, span, "flavor")?;
-        let runtime =
-            RuntimeFlavor::from_str(&runtime_str).map_err(|err| syn::Error::new(span, err))?;
-        self.flavor = Some(runtime);
-        Ok(())
-    }
-
-    fn set_worker_threads(
-        &mut self,
-        worker_threads: syn::Lit,
-        span: Span,
-    ) -> Result<(), syn::Error> {
-        if self.worker_threads.is_some() {
-            return Err(syn::Error::new(
-                span,
-                "`worker_threads` set multiple times.",
-            ));
-        }
-
-        let worker_threads = parse_int(worker_threads, span, "worker_threads")?;
-        if worker_threads == 0 {
-            return Err(syn::Error::new(span, "`worker_threads` may not be 0."));
-        }
-        self.worker_threads = Some((worker_threads, span));
-        Ok(())
-    }
-
-    fn set_start_paused(&mut self, start_paused: syn::Lit, span: Span) -> Result<(), syn::Error> {
-        if self.start_paused.is_some() {
-            return Err(syn::Error::new(span, "`start_paused` set multiple times."));
-        }
-
-        let start_paused = parse_bool(start_paused, span, "start_paused")?;
-        self.start_paused = Some((start_paused, span));
-        Ok(())
-    }
-
-    fn macro_name(&self) -> &'static str {
-        if self.is_test {
-            "tokio::test"
-        } else {
-            "tokio::main"
-        }
-    }
-
-    fn build(&self) -> Result<FinalConfig, syn::Error> {
-        let flavor = self.flavor.unwrap_or(self.default_flavor);
-        use RuntimeFlavor::*;
-
-        let worker_threads = match (flavor, self.worker_threads) {
-            (CurrentThread, Some((_, worker_threads_span))) => {
-                let msg = format!(
-                    "The `worker_threads` option requires the `multi_thread` runtime flavor. Use `#[{}(flavor = \"multi_thread\")]`",
-                    self.macro_name(),
-                );
-                return Err(syn::Error::new(worker_threads_span, msg));
-            }
-            (CurrentThread, None) => None,
-            (Threaded, worker_threads) if self.rt_multi_thread_available => {
-                worker_threads.map(|(val, _span)| val)
-            }
-            (Threaded, _) => {
-                let msg = if self.flavor.is_none() {
-                    "The default runtime flavor is `multi_thread`, but the `rt-multi-thread` feature is disabled."
-                } else {
-                    "The runtime flavor `multi_thread` requires the `rt-multi-thread` feature."
-                };
-                return Err(syn::Error::new(Span::call_site(), msg));
-            }
-        };
-
-        let start_paused = match (flavor, self.start_paused) {
-            (Threaded, Some((_, start_paused_span))) => {
-                let msg = format!(
-                    "The `start_paused` option requires the `current_thread` runtime flavor. Use `#[{}(flavor = \"current_thread\")]`",
-                    self.macro_name(),
-                );
-                return Err(syn::Error::new(start_paused_span, msg));
-            }
-            (CurrentThread, Some((start_paused, _))) => Some(start_paused),
-            (_, None) => None,
-        };
-
-        Ok(FinalConfig {
-            flavor,
-            worker_threads,
-            start_paused,
-        })
-    }
-}
-
-fn parse_int(int: syn::Lit, span: Span, field: &str) -> Result<usize, syn::Error> {
-    match int {
-        syn::Lit::Int(lit) => match lit.base10_parse::<usize>() {
-            Ok(value) => Ok(value),
-            Err(e) => Err(syn::Error::new(
-                span,
-                format!("Failed to parse value of `{}` as integer: {}", field, e),
-            )),
-        },
-        _ => Err(syn::Error::new(
-            span,
-            format!("Failed to parse value of `{}` as integer.", field),
-        )),
-    }
-}
-
-fn parse_string(int: syn::Lit, span: Span, field: &str) -> Result<String, syn::Error> {
-    match int {
-        syn::Lit::Str(s) => Ok(s.value()),
-        syn::Lit::Verbatim(s) => Ok(s.to_string()),
-        _ => Err(syn::Error::new(
-            span,
-            format!("Failed to parse value of `{}` as string.", field),
-        )),
-    }
-}
-
-fn parse_bool(bool: syn::Lit, span: Span, field: &str) -> Result<bool, syn::Error> {
-    match bool {
-        syn::Lit::Bool(b) => Ok(b.value),
-        _ => Err(syn::Error::new(
-            span,
-            format!("Failed to parse value of `{}` as bool.", field),
-        )),
-    }
-}
-
 fn parse_knobs(
     mut input: syn::ItemFn,
     args: syn::AttributeArgs,
     is_test: bool,
-    rt_multi_thread: bool,
+    rt_threaded: bool,
 ) -> Result<TokenStream, syn::Error> {
-    if input.sig.asyncness.take().is_none() {
-        let msg = "the `async` keyword is missing from the function declaration";
-        return Err(syn::Error::new_spanned(input.sig.fn_token, msg));
+    let sig = &mut input.sig;
+    let body = &input.block;
+    let attrs = &input.attrs;
+    let vis = input.vis;
+
+    if sig.asyncness.is_none() {
+        let msg = "the async keyword is missing from the function declaration";
+        return Err(syn::Error::new_spanned(sig.fn_token, msg));
     }
 
-    let mut config = Configuration::new(is_test, rt_multi_thread);
-    let macro_name = config.macro_name();
+    sig.asyncness = None;
+
+    let mut runtime = None;
+    let mut core_threads = None;
+    let mut max_threads = None;
 
     for arg in args {
         match arg {
@@ -207,33 +39,65 @@ fn parse_knobs(
                     return Err(syn::Error::new_spanned(namevalue, msg));
                 }
                 match ident.unwrap().to_string().to_lowercase().as_str() {
-                    "worker_threads" => {
-                        config.set_worker_threads(
-                            namevalue.lit.clone(),
-                            syn::spanned::Spanned::span(&namevalue.lit),
-                        )?;
-                    }
-                    "flavor" => {
-                        config.set_flavor(
-                            namevalue.lit.clone(),
-                            syn::spanned::Spanned::span(&namevalue.lit),
-                        )?;
-                    }
-                    "start_paused" => {
-                        config.set_start_paused(
-                            namevalue.lit.clone(),
-                            syn::spanned::Spanned::span(&namevalue.lit),
-                        )?;
-                    }
                     "core_threads" => {
-                        let msg = "Attribute `core_threads` is renamed to `worker_threads`";
-                        return Err(syn::Error::new_spanned(namevalue, msg));
+                        if rt_threaded {
+                            match &namevalue.lit {
+                                syn::Lit::Int(expr) => {
+                                    let num = expr.base10_parse::<NonZeroUsize>().unwrap();
+                                    if num.get() > 1 {
+                                        runtime = Some(Runtime::Threaded);
+                                    } else {
+                                        runtime = Some(Runtime::Basic);
+                                    }
+
+                                    if let Some(v) = max_threads {
+                                        if v < num {
+                                            return Err(syn::Error::new_spanned(
+                                                namevalue,
+                                                "max_threads cannot be less than core_threads",
+                                            ));
+                                        }
+                                    }
+
+                                    core_threads = Some(num);
+                                }
+                                _ => {
+                                    return Err(syn::Error::new_spanned(
+                                        namevalue,
+                                        "core_threads argument must be an int",
+                                    ))
+                                }
+                            }
+                        } else {
+                            return Err(syn::Error::new_spanned(
+                                namevalue,
+                                "core_threads can only be set with rt-threaded feature flag enabled",
+                            ));
+                        }
                     }
+                    "max_threads" => match &namevalue.lit {
+                        syn::Lit::Int(expr) => {
+                            let num = expr.base10_parse::<NonZeroUsize>().unwrap();
+
+                            if let Some(v) = core_threads {
+                                if num < v {
+                                    return Err(syn::Error::new_spanned(
+                                        namevalue,
+                                        "max_threads cannot be less than core_threads",
+                                    ));
+                                }
+                            }
+                            max_threads = Some(num);
+                        }
+                        _ => {
+                            return Err(syn::Error::new_spanned(
+                                namevalue,
+                                "max_threads argument must be an int",
+                            ))
+                        }
+                    },
                     name => {
-                        let msg = format!(
-                            "Unknown attribute {} is specified; expected one of: `flavor`, `worker_threads`, `start_paused`",
-                            name,
-                        );
+                        let msg = format!("Unknown attribute pair {} is specified; expected one of: `core_threads`, `max_threads`", name);
                         return Err(syn::Error::new_spanned(namevalue, msg));
                     }
                 }
@@ -244,28 +108,16 @@ fn parse_knobs(
                     let msg = "Must have specified ident";
                     return Err(syn::Error::new_spanned(path, msg));
                 }
-                let name = ident.unwrap().to_string().to_lowercase();
-                let msg = match name.as_str() {
-                    "threaded_scheduler" | "multi_thread" => {
-                        format!(
-                            "Set the runtime flavor with #[{}(flavor = \"multi_thread\")].",
-                            macro_name
-                        )
-                    }
-                    "basic_scheduler" | "current_thread" | "single_threaded" => {
-                        format!(
-                            "Set the runtime flavor with #[{}(flavor = \"current_thread\")].",
-                            macro_name
-                        )
-                    }
-                    "flavor" | "worker_threads" | "start_paused" => {
-                        format!("The `{}` attribute requires an argument.", name)
+                match ident.unwrap().to_string().to_lowercase().as_str() {
+                    "threaded_scheduler" => {
+                        runtime = Some(runtime.unwrap_or_else(|| Runtime::Threaded))
                     }
+                    "basic_scheduler" => runtime = Some(runtime.unwrap_or_else(|| Runtime::Basic)),
                     name => {
-                        format!("Unknown attribute {} is specified; expected one of: `flavor`, `worker_threads`, `start_paused`", name)
+                        let msg = format!("Unknown attribute {} is specified; expected `basic_scheduler` or `threaded_scheduler`", name);
+                        return Err(syn::Error::new_spanned(path, msg));
                     }
-                };
-                return Err(syn::Error::new_spanned(path, msg));
+                }
             }
             other => {
                 return Err(syn::Error::new_spanned(
@@ -276,87 +128,58 @@ fn parse_knobs(
         }
     }
 
-    let config = config.build()?;
-
-    // If type mismatch occurs, the current rustc points to the last statement.
-    let (last_stmt_start_span, last_stmt_end_span) = {
-        let mut last_stmt = input
-            .block
-            .stmts
-            .last()
-            .map(ToTokens::into_token_stream)
-            .unwrap_or_default()
-            .into_iter();
-        // `Span` on stable Rust has a limitation that only points to the first
-        // token, not the whole tokens. We can work around this limitation by
-        // using the first/last span of the tokens like
-        // `syn::Error::new_spanned` does.
-        let start = last_stmt.next().map_or_else(Span::call_site, |t| t.span());
-        let end = last_stmt.last().map_or(start, |t| t.span());
-        (start, end)
-    };
-
-    let mut rt = match config.flavor {
-        RuntimeFlavor::CurrentThread => quote_spanned! {last_stmt_start_span=>
-            tokio::runtime::Builder::new_current_thread()
-        },
-        RuntimeFlavor::Threaded => quote_spanned! {last_stmt_start_span=>
-            tokio::runtime::Builder::new_multi_thread()
-        },
-    };
-    if let Some(v) = config.worker_threads {
-        rt = quote! { #rt.worker_threads(#v) };
+    let mut rt = quote! { tokio::runtime::Builder::new().basic_scheduler() };
+    if rt_threaded && (runtime == Some(Runtime::Threaded) || (runtime.is_none() && !is_test)) {
+        rt = quote! { #rt.threaded_scheduler() };
     }
-    if let Some(v) = config.start_paused {
-        rt = quote! { #rt.start_paused(#v) };
+    if let Some(v) = core_threads.map(|v| v.get()) {
+        rt = quote! { #rt.core_threads(#v) };
+    }
+    if let Some(v) = max_threads.map(|v| v.get()) {
+        rt = quote! { #rt.max_threads(#v) };
     }
 
-    let header = if is_test {
-        quote! {
-            #[::core::prelude::v1::test]
+    let header = {
+        if is_test {
+            quote! {
+                #[::core::prelude::v1::test]
+            }
+        } else {
+            quote! {}
         }
-    } else {
-        quote! {}
     };
 
-    let body = &input.block;
-    let brace_token = input.block.brace_token;
-    input.block = syn::parse2(quote_spanned! {last_stmt_end_span=>
-        {
+    let result = quote! {
+        #header
+        #(#attrs)*
+        #vis #sig {
             #rt
                 .enable_all()
                 .build()
                 .unwrap()
-                .block_on(async #body)
+                .block_on(async { #body })
         }
-    })
-    .unwrap();
-    input.block.brace_token = brace_token;
-
-    let result = quote! {
-        #header
-        #input
     };
 
     Ok(result.into())
 }
 
 #[cfg(not(test))] // Work around for rust-lang/rust#62127
-pub(crate) fn main(args: TokenStream, item: TokenStream, rt_multi_thread: bool) -> TokenStream {
+pub(crate) fn main(args: TokenStream, item: TokenStream, rt_threaded: bool) -> TokenStream {
     let input = syn::parse_macro_input!(item as syn::ItemFn);
     let args = syn::parse_macro_input!(args as syn::AttributeArgs);
 
     if input.sig.ident == "main" && !input.sig.inputs.is_empty() {
         let msg = "the main function cannot accept arguments";
-        return syn::Error::new_spanned(&input.sig.ident, msg)
+        return syn::Error::new_spanned(&input.sig.inputs, msg)
             .to_compile_error()
             .into();
     }
 
-    parse_knobs(input, args, false, rt_multi_thread).unwrap_or_else(|e| e.to_compile_error().into())
+    parse_knobs(input, args, false, rt_threaded).unwrap_or_else(|e| e.to_compile_error().into())
 }
 
-pub(crate) fn test(args: TokenStream, item: TokenStream, rt_multi_thread: bool) -> TokenStream {
+pub(crate) fn test(args: TokenStream, item: TokenStream, rt_threaded: bool) -> TokenStream {
     let input = syn::parse_macro_input!(item as syn::ItemFn);
     let args = syn::parse_macro_input!(args as syn::AttributeArgs);
 
@@ -369,5 +192,168 @@ pub(crate) fn test(args: TokenStream, item: TokenStream, rt_multi_thread: bool)
         }
     }
 
-    parse_knobs(input, args, true, rt_multi_thread).unwrap_or_else(|e| e.to_compile_error().into())
+    if !input.sig.inputs.is_empty() {
+        let msg = "the test function cannot accept arguments";
+        return syn::Error::new_spanned(&input.sig.inputs, msg)
+            .to_compile_error()
+            .into();
+    }
+
+    parse_knobs(input, args, true, rt_threaded).unwrap_or_else(|e| e.to_compile_error().into())
+}
+
+pub(crate) mod old {
+    use proc_macro::TokenStream;
+    use quote::quote;
+
+    enum Runtime {
+        Basic,
+        Threaded,
+        Auto,
+    }
+
+    #[cfg(not(test))] // Work around for rust-lang/rust#62127
+    pub(crate) fn main(args: TokenStream, item: TokenStream) -> TokenStream {
+        let mut input = syn::parse_macro_input!(item as syn::ItemFn);
+        let args = syn::parse_macro_input!(args as syn::AttributeArgs);
+
+        let sig = &mut input.sig;
+        let name = &sig.ident;
+        let inputs = &sig.inputs;
+        let body = &input.block;
+        let attrs = &input.attrs;
+        let vis = input.vis;
+
+        if sig.asyncness.is_none() {
+            let msg = "the async keyword is missing from the function declaration";
+            return syn::Error::new_spanned(sig.fn_token, msg)
+                .to_compile_error()
+                .into();
+        } else if name == "main" && !inputs.is_empty() {
+            let msg = "the main function cannot accept arguments";
+            return syn::Error::new_spanned(&sig.inputs, msg)
+                .to_compile_error()
+                .into();
+        }
+
+        sig.asyncness = None;
+
+        let mut runtime = Runtime::Auto;
+
+        for arg in args {
+            if let syn::NestedMeta::Meta(syn::Meta::Path(path)) = arg {
+                let ident = path.get_ident();
+                if ident.is_none() {
+                    let msg = "Must have specified ident";
+                    return syn::Error::new_spanned(path, msg).to_compile_error().into();
+                }
+                match ident.unwrap().to_string().to_lowercase().as_str() {
+                    "threaded_scheduler" => runtime = Runtime::Threaded,
+                    "basic_scheduler" => runtime = Runtime::Basic,
+                    name => {
+                        let msg = format!("Unknown attribute {} is specified; expected `basic_scheduler` or `threaded_scheduler`", name);
+                        return syn::Error::new_spanned(path, msg).to_compile_error().into();
+                    }
+                }
+            }
+        }
+
+        let result = match runtime {
+            Runtime::Threaded | Runtime::Auto => quote! {
+                #(#attrs)*
+                #vis #sig {
+                    tokio::runtime::Runtime::new().unwrap().block_on(async { #body })
+                }
+            },
+            Runtime::Basic => quote! {
+                #(#attrs)*
+                #vis #sig {
+                    tokio::runtime::Builder::new()
+                        .basic_scheduler()
+                        .enable_all()
+                        .build()
+                        .unwrap()
+                        .block_on(async { #body })
+                }
+            },
+        };
+
+        result.into()
+    }
+
+    pub(crate) fn test(args: TokenStream, item: TokenStream) -> TokenStream {
+        let input = syn::parse_macro_input!(item as syn::ItemFn);
+        let args = syn::parse_macro_input!(args as syn::AttributeArgs);
+
+        let ret = &input.sig.output;
+        let name = &input.sig.ident;
+        let body = &input.block;
+        let attrs = &input.attrs;
+        let vis = input.vis;
+
+        for attr in attrs {
+            if attr.path.is_ident("test") {
+                let msg = "second test attribute is supplied";
+                return syn::Error::new_spanned(&attr, msg)
+                    .to_compile_error()
+                    .into();
+            }
+        }
+
+        if input.sig.asyncness.is_none() {
+            let msg = "the async keyword is missing from the function declaration";
+            return syn::Error::new_spanned(&input.sig.fn_token, msg)
+                .to_compile_error()
+                .into();
+        } else if !input.sig.inputs.is_empty() {
+            let msg = "the test function cannot accept arguments";
+            return syn::Error::new_spanned(&input.sig.inputs, msg)
+                .to_compile_error()
+                .into();
+        }
+
+        let mut runtime = Runtime::Auto;
+
+        for arg in args {
+            if let syn::NestedMeta::Meta(syn::Meta::Path(path)) = arg {
+                let ident = path.get_ident();
+                if ident.is_none() {
+                    let msg = "Must have specified ident";
+                    return syn::Error::new_spanned(path, msg).to_compile_error().into();
+                }
+                match ident.unwrap().to_string().to_lowercase().as_str() {
+                    "threaded_scheduler" => runtime = Runtime::Threaded,
+                    "basic_scheduler" => runtime = Runtime::Basic,
+                    name => {
+                        let msg = format!("Unknown attribute {} is specified; expected `basic_scheduler` or `threaded_scheduler`", name);
+                        return syn::Error::new_spanned(path, msg).to_compile_error().into();
+                    }
+                }
+            }
+        }
+
+        let result = match runtime {
+            Runtime::Threaded => quote! {
+                #[::core::prelude::v1::test]
+                #(#attrs)*
+                #vis fn #name() #ret {
+                    tokio::runtime::Runtime::new().unwrap().block_on(async { #body })
+                }
+            },
+            Runtime::Basic | Runtime::Auto => quote! {
+                #[::core::prelude::v1::test]
+                #(#attrs)*
+                #vis fn #name() #ret {
+                    tokio::runtime::Builder::new()
+                        .basic_scheduler()
+                        .enable_all()
+                        .build()
+                        .unwrap()
+                        .block_on(async { #body })
+                }
+            },
+        };
+
+        result.into()
+    }
 }

tokio-macros/src/lib.rs

@@ -1,3 +1,4 @@
+#![doc(html_root_url = "https://docs.rs/tokio-macros/0.2.5")]
 #![allow(clippy::needless_doctest_main)]
 #![warn(
     missing_debug_implementations,
@@ -23,47 +24,18 @@ mod select;
 
 use proc_macro::TokenStream;
 
-/// Marks async function to be executed by the selected runtime. This macro
-/// helps set up a `Runtime` without requiring the user to use
-/// [Runtime](../tokio/runtime/struct.Runtime.html) or
-/// [Builder](../tokio/runtime/struct.Builder.html) directly.
+/// Marks async function to be executed by selected runtime. This macro helps set up a `Runtime`
+/// without requiring the user to use [Runtime](../tokio/runtime/struct.Runtime.html) or
+/// [Builder](../tokio/runtime/struct.builder.html) directly.
 ///
-/// Note: This macro is designed to be simplistic and targets applications that
-/// do not require a complex setup. If the provided functionality is not
-/// sufficient, you may be interested in using
-/// [Builder](../tokio/runtime/struct.Builder.html), which provides a more
-/// powerful interface.
+/// ## Options:
 ///
-/// Note: This macro can be used on any function and not just the `main`
-/// function. Using it on a non-main function makes the function behave as if it
-/// was synchronous by starting a new runtime each time it is called. If the
-/// function is called often, it is preferable to create the runtime using the
-/// runtime builder so the runtime can be reused across calls.
+/// If you want to set the number of worker threads used for asynchronous code, use the
+/// `core_threads` option.
 ///
-/// # Multi-threaded runtime
-///
-/// To use the multi-threaded runtime, the macro can be configured using
-///
-/// ```
-/// #[tokio::main(flavor = "multi_thread", worker_threads = 10)]
-/// # async fn main() {}
-/// ```
-///
-/// The `worker_threads` option configures the number of worker threads, and
-/// defaults to the number of cpus on the system. This is the default flavor.
-///
-/// Note: The multi-threaded runtime requires the `rt-multi-thread` feature
-/// flag.
-///
-/// # Current thread runtime
-///
-/// To use the single-threaded runtime known as the `current_thread` runtime,
-/// the macro can be configured using
-///
-/// ```
-/// #[tokio::main(flavor = "current_thread")]
-/// # async fn main() {}
-/// ```
+/// - `core_threads=n` - Sets core threads to `n` (requires `rt-threaded` feature).
+/// - `max_threads=n` - Sets max threads to `n` (requires `rt-core` or `rt-threaded` feature).
+/// - `basic_scheduler` - Use the basic schduler (requires `rt-core`).
 ///
 /// ## Function arguments:
 ///
@@ -71,7 +43,7 @@ use proc_macro::TokenStream;
 ///
 /// ## Usage
 ///
-/// ### Using the multi-thread runtime
+/// ### Using default
 ///
 /// ```rust
 /// #[tokio::main]
@@ -84,7 +56,8 @@ use proc_macro::TokenStream;
 ///
 /// ```rust
 /// fn main() {
-///     tokio::runtime::Builder::new_multi_thread()
+///     tokio::runtime::Builder::new()
+///         .threaded_scheduler()
 ///         .enable_all()
 ///         .build()
 ///         .unwrap()
@@ -94,12 +67,12 @@ use proc_macro::TokenStream;
 /// }
 /// ```
 ///
-/// ### Using current thread runtime
+/// ### Using basic scheduler
 ///
 /// The basic scheduler is single-threaded.
 ///
 /// ```rust
-/// #[tokio::main(flavor = "current_thread")]
+/// #[tokio::main(basic_scheduler)]
 /// async fn main() {
 ///     println!("Hello world");
 /// }
@@ -109,7 +82,8 @@ use proc_macro::TokenStream;
 ///
 /// ```rust
 /// fn main() {
-///     tokio::runtime::Builder::new_current_thread()
+///     tokio::runtime::Builder::new()
+///         .basic_scheduler()
 ///         .enable_all()
 ///         .build()
 ///         .unwrap()
@@ -119,10 +93,10 @@ use proc_macro::TokenStream;
 /// }
 /// ```
 ///
-/// ### Set number of worker threads
+/// ### Set number of core threads
 ///
 /// ```rust
-/// #[tokio::main(worker_threads = 2)]
+/// #[tokio::main(core_threads = 2)]
 /// async fn main() {
 ///     println!("Hello world");
 /// }
@@ -132,8 +106,9 @@ use proc_macro::TokenStream;
 ///
 /// ```rust
 /// fn main() {
-///     tokio::runtime::Builder::new_multi_thread()
-///         .worker_threads(2)
+///     tokio::runtime::Builder::new()
+///         .threaded_scheduler()
+///         .core_threads(2)
 ///         .enable_all()
 ///         .build()
 ///         .unwrap()
@@ -143,41 +118,16 @@ use proc_macro::TokenStream;
 /// }
 /// ```
 ///
-/// ### Configure the runtime to start with time paused
-///
-/// ```rust
-/// #[tokio::main(flavor = "current_thread", start_paused = true)]
-/// async fn main() {
-///     println!("Hello world");
-/// }
-/// ```
-///
-/// Equivalent code not using `#[tokio::main]`
-///
-/// ```rust
-/// fn main() {
-///     tokio::runtime::Builder::new_current_thread()
-///         .enable_all()
-///         .start_paused(true)
-///         .build()
-///         .unwrap()
-///         .block_on(async {
-///             println!("Hello world");
-///         })
-/// }
-/// ```
-///
-/// Note that `start_paused` requires the `test-util` feature to be enabled.
-///
 /// ### NOTE:
 ///
-/// If you rename the Tokio crate in your dependencies this macro will not work.
-/// If you must rename the current version of Tokio because you're also using an
-/// older version of Tokio, you _must_ make the current version of Tokio
-/// available as `tokio` in the module where this macro is expanded.
+/// If you rename the tokio crate in your dependencies this macro
+/// will not work. If you must rename the 0.2 version of tokio because
+/// you're also using the 0.1 version of tokio, you _must_ make the
+/// tokio 0.2 crate available as `tokio` in the module where this
+/// macro is expanded.
 #[proc_macro_attribute]
 #[cfg(not(test))] // Work around for rust-lang/rust#62127
-pub fn main(args: TokenStream, item: TokenStream) -> TokenStream {
+pub fn main_threaded(args: TokenStream, item: TokenStream) -> TokenStream {
     entry::main(args, item, true)
 }
 
@@ -185,6 +135,11 @@ pub fn main(args: TokenStream, item: TokenStream) -> TokenStream {
 /// without requiring the user to use [Runtime](../tokio/runtime/struct.Runtime.html) or
 /// [Builder](../tokio/runtime/struct.builder.html) directly.
 ///
+/// ## Options:
+///
+/// - `basic_scheduler` - All tasks are executed on the current thread.
+/// - `threaded_scheduler` - Uses the multi-threaded scheduler. Used by default (requires `rt-threaded` feature).
+///
 /// ## Function arguments:
 ///
 /// Arguments are allowed for any functions aside from `main` which is special
@@ -194,7 +149,7 @@ pub fn main(args: TokenStream, item: TokenStream) -> TokenStream {
 /// ### Using default
 ///
 /// ```rust
-/// #[tokio::main(flavor = "current_thread")]
+/// #[tokio::main]
 /// async fn main() {
 ///     println!("Hello world");
 /// }
@@ -204,7 +159,29 @@ pub fn main(args: TokenStream, item: TokenStream) -> TokenStream {
 ///
 /// ```rust
 /// fn main() {
-///     tokio::runtime::Builder::new_current_thread()
+///     tokio::runtime::Runtime::new()
+///         .unwrap()
+///         .block_on(async {
+///             println!("Hello world");
+///         })
+/// }
+/// ```
+///
+/// ### Select runtime
+///
+/// ```rust
+/// #[tokio::main(basic_scheduler)]
+/// async fn main() {
+///     println!("Hello world");
+/// }
+/// ```
+///
+/// Equivalent code not using `#[tokio::main]`
+///
+/// ```rust
+/// fn main() {
+///     tokio::runtime::Builder::new()
+///         .basic_scheduler()
 ///         .enable_all()
 ///         .build()
 ///         .unwrap()
@@ -216,24 +193,81 @@ pub fn main(args: TokenStream, item: TokenStream) -> TokenStream {
 ///
 /// ### NOTE:
 ///
-/// If you rename the Tokio crate in your dependencies this macro will not work.
-/// If you must rename the current version of Tokio because you're also using an
-/// older version of Tokio, you _must_ make the current version of Tokio
-/// available as `tokio` in the module where this macro is expanded.
+/// If you rename the tokio crate in your dependencies this macro
+/// will not work. If you must rename the 0.2 version of tokio because
+/// you're also using the 0.1 version of tokio, you _must_ make the
+/// tokio 0.2 crate available as `tokio` in the module where this
+/// macro is expanded.
 #[proc_macro_attribute]
 #[cfg(not(test))] // Work around for rust-lang/rust#62127
-pub fn main_rt(args: TokenStream, item: TokenStream) -> TokenStream {
+pub fn main(args: TokenStream, item: TokenStream) -> TokenStream {
+    entry::old::main(args, item)
+}
+
+/// Marks async function to be executed by selected runtime. This macro helps set up a `Runtime`
+/// without requiring the user to use [Runtime](../tokio/runtime/struct.Runtime.html) or
+/// [Builder](../tokio/runtime/struct.builder.html) directly.
+///
+/// ## Options:
+///
+/// - `max_threads=n` - Sets max threads to `n`.
+///
+/// ## Function arguments:
+///
+/// Arguments are allowed for any functions aside from `main` which is special
+///
+/// ## Usage
+///
+/// ### Using default
+///
+/// ```rust
+/// #[tokio::main]
+/// async fn main() {
+///     println!("Hello world");
+/// }
+/// ```
+///
+/// Equivalent code not using `#[tokio::main]`
+///
+/// ```rust
+/// fn main() {
+///     tokio::runtime::Builder::new()
+///         .basic_scheduler()
+///         .enable_all()
+///         .build()
+///         .unwrap()
+///         .block_on(async {
+///             println!("Hello world");
+///         })
+/// }
+/// ```
+///
+/// ### NOTE:
+///
+/// If you rename the tokio crate in your dependencies this macro
+/// will not work. If you must rename the 0.2 version of tokio because
+/// you're also using the 0.1 version of tokio, you _must_ make the
+/// tokio 0.2 crate available as `tokio` in the module where this
+/// macro is expanded.
+#[proc_macro_attribute]
+#[cfg(not(test))] // Work around for rust-lang/rust#62127
+pub fn main_basic(args: TokenStream, item: TokenStream) -> TokenStream {
     entry::main(args, item, false)
 }
 
 /// Marks async function to be executed by runtime, suitable to test environment
 ///
+/// ## Options:
+///
+/// - `core_threads=n` - Sets core threads to `n` (requires `rt-threaded` feature).
+/// - `max_threads=n` - Sets max threads to `n` (requires `rt-core` or `rt-threaded` feature).
+///
 /// ## Usage
 ///
-/// ### Multi-thread runtime
+/// ### Select runtime
 ///
 /// ```no_run
-/// #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
+/// #[tokio::test(core_threads = 1)]
 /// async fn my_test() {
 ///     assert!(true);
 /// }
@@ -241,7 +275,44 @@ pub fn main_rt(args: TokenStream, item: TokenStream) -> TokenStream {
 ///
 /// ### Using default
 ///
-/// The default test runtime is single-threaded.
+/// ```no_run
+/// #[tokio::test]
+/// async fn my_test() {
+///     assert!(true);
+/// }
+/// ```
+///
+/// ### NOTE:
+///
+/// If you rename the tokio crate in your dependencies this macro
+/// will not work. If you must rename the 0.2 version of tokio because
+/// you're also using the 0.1 version of tokio, you _must_ make the
+/// tokio 0.2 crate available as `tokio` in the module where this
+/// macro is expanded.
+#[proc_macro_attribute]
+pub fn test_threaded(args: TokenStream, item: TokenStream) -> TokenStream {
+    entry::test(args, item, true)
+}
+
+/// Marks async function to be executed by runtime, suitable to test environment
+///
+/// ## Options:
+///
+/// - `basic_scheduler` - All tasks are executed on the current thread. Used by default.
+/// - `threaded_scheduler` - Use multi-threaded scheduler (requires `rt-threaded` feature).
+///
+/// ## Usage
+///
+/// ### Select runtime
+///
+/// ```no_run
+/// #[tokio::test(threaded_scheduler)]
+/// async fn my_test() {
+///     assert!(true);
+/// }
+/// ```
+///
+/// ### Using default
 ///
 /// ```no_run
 /// #[tokio::test]
@@ -250,30 +321,24 @@ pub fn main_rt(args: TokenStream, item: TokenStream) -> TokenStream {
 /// }
 /// ```
 ///
-/// ### Configure the runtime to start with time paused
-///
-/// ```no_run
-/// #[tokio::test(start_paused = true)]
-/// async fn my_test() {
-///     assert!(true);
-/// }
-/// ```
-///
-/// Note that `start_paused` requires the `test-util` feature to be enabled.
-///
 /// ### NOTE:
 ///
-/// If you rename the Tokio crate in your dependencies this macro will not work.
-/// If you must rename the current version of Tokio because you're also using an
-/// older version of Tokio, you _must_ make the current version of Tokio
-/// available as `tokio` in the module where this macro is expanded.
+/// If you rename the tokio crate in your dependencies this macro
+/// will not work. If you must rename the 0.2 version of tokio because
+/// you're also using the 0.1 version of tokio, you _must_ make the
+/// tokio 0.2 crate available as `tokio` in the module where this
+/// macro is expanded.
 #[proc_macro_attribute]
 pub fn test(args: TokenStream, item: TokenStream) -> TokenStream {
-    entry::test(args, item, true)
+    entry::old::test(args, item)
 }
 
 /// Marks async function to be executed by runtime, suitable to test environment
 ///
+/// ## Options:
+///
+/// - `max_threads=n` - Sets max threads to `n`.
+///
 /// ## Usage
 ///
 /// ```no_run
@@ -285,43 +350,16 @@ pub fn test(args: TokenStream, item: TokenStream) -> TokenStream {
 ///
 /// ### NOTE:
 ///
-/// If you rename the Tokio crate in your dependencies this macro will not work.
-/// If you must rename the current version of Tokio because you're also using an
-/// older version of Tokio, you _must_ make the current version of Tokio
-/// available as `tokio` in the module where this macro is expanded.
+/// If you rename the tokio crate in your dependencies this macro
+/// will not work. If you must rename the 0.2 version of tokio because
+/// you're also using the 0.1 version of tokio, you _must_ make the
+/// tokio 0.2 crate available as `tokio` in the module where this
+/// macro is expanded.
 #[proc_macro_attribute]
-pub fn test_rt(args: TokenStream, item: TokenStream) -> TokenStream {
+pub fn test_basic(args: TokenStream, item: TokenStream) -> TokenStream {
     entry::test(args, item, false)
 }
 
-/// Always fails with the error message below.
-/// ```text
-/// The #[tokio::main] macro requires rt or rt-multi-thread.
-/// ```
-#[proc_macro_attribute]
-pub fn main_fail(_args: TokenStream, _item: TokenStream) -> TokenStream {
-    syn::Error::new(
-        proc_macro2::Span::call_site(),
-        "The #[tokio::main] macro requires rt or rt-multi-thread.",
-    )
-    .to_compile_error()
-    .into()
-}
-
-/// Always fails with the error message below.
-/// ```text
-/// The #[tokio::test] macro requires rt or rt-multi-thread.
-/// ```
-#[proc_macro_attribute]
-pub fn test_fail(_args: TokenStream, _item: TokenStream) -> TokenStream {
-    syn::Error::new(
-        proc_macro2::Span::call_site(),
-        "The #[tokio::test] macro requires rt or rt-multi-thread.",
-    )
-    .to_compile_error()
-    .into()
-}
-
 /// Implementation detail of the `select!` macro. This macro is **not** intended
 /// to be used as part of the public API and is permitted to change.
 #[proc_macro]

tokio-stream/CHANGELOG.md

@@ -1,56 +0,0 @@
-# 0.1.5 (March 20, 2021)
-
-### Fixed
-
-- stream: documentation note for throttle `Unpin` ([#3600])
-
-[#3600]: https://github.com/tokio-rs/tokio/pull/3600
-
-# 0.1.4 (March 9, 2021)
-
-Added
-
-- signal: add `Signal` wrapper ([#3510])
-
-Fixed
-
-- stream: remove duplicate `doc_cfg` declaration ([#3561])
-- sync: yield initial value in `WatchStream` ([#3576])
-
-[#3510]: https://github.com/tokio-rs/tokio/pull/3510
-[#3561]: https://github.com/tokio-rs/tokio/pull/3561
-[#3576]: https://github.com/tokio-rs/tokio/pull/3576
-
-# 0.1.3 (February 5, 2021)
-
-Added
-
- - sync: add wrapper for broadcast and watch ([#3384], [#3504])
-
-[#3384]: https://github.com/tokio-rs/tokio/pull/3384
-[#3504]: https://github.com/tokio-rs/tokio/pull/3504
-
-# 0.1.2 (January 12, 2021)
-
-Fixed
-
- - docs: fix some wrappers missing in documentation ([#3378])
-
-[#3378]: https://github.com/tokio-rs/tokio/pull/3378
-
-# 0.1.1 (January 4, 2021)
-
-Added
-
- - add `Stream` wrappers ([#3343])
-
-Fixed
-
- - move `async-stream` to `dev-dependencies` ([#3366])
-
-[#3366]: https://github.com/tokio-rs/tokio/pull/3366
-[#3343]: https://github.com/tokio-rs/tokio/pull/3343
-
-# 0.1.0 (December 23, 2020)
-
- - Initial release

tokio-stream/Cargo.toml

@@ -1,46 +0,0 @@
-[package]
-name = "tokio-stream"
-# When releasing to crates.io:
-# - Remove path dependencies
-# - Update doc url
-#   - Cargo.toml
-# - Update CHANGELOG.md.
-# - Create "tokio-stream-0.1.x" git tag.
-version = "0.1.5"
-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-stream/0.1.5/tokio_stream"
-description = """
-Utilities to work with `Stream` and `tokio`.
-"""
-categories = ["asynchronous"]
-
-[features]
-default = ["time"]
-time = ["tokio/time"]
-net = ["tokio/net"]
-io-util = ["tokio/io-util"]
-fs = ["tokio/fs"]
-sync = ["tokio/sync", "tokio-util"]
-signal = ["tokio/signal"]
-
-[dependencies]
-futures-core = { version = "0.3.0" }
-pin-project-lite = "0.2.0"
-tokio = { version = "1.2.0", path = "../tokio", features = ["sync"] }
-tokio-util = { version = "0.6.3", path = "../tokio-util", optional = true }
-
-[dev-dependencies]
-tokio = { version = "1.2.0", path = "../tokio", features = ["full", "test-util"] }
-async-stream = "0.3"
-tokio-test = { path = "../tokio-test" }
-futures = { version = "0.3", default-features = false }
-
-proptest = "1"
-
-[package.metadata.docs.rs]
-all-features = true
-rustdoc-args = ["--cfg", "docsrs"]

tokio-stream/LICENSE

@@ -1,25 +0,0 @@
-Copyright (c) 2021 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-stream/src/lib.rs

@@ -1,98 +0,0 @@
-#![allow(
-    clippy::cognitive_complexity,
-    clippy::large_enum_variant,
-    clippy::needless_doctest_main
-)]
-#![warn(
-    missing_debug_implementations,
-    missing_docs,
-    rust_2018_idioms,
-    unreachable_pub
-)]
-#![cfg_attr(docsrs, feature(doc_cfg))]
-#![cfg_attr(docsrs, deny(broken_intra_doc_links))]
-#![doc(test(
-    no_crate_inject,
-    attr(deny(warnings, rust_2018_idioms), allow(dead_code, unused_variables))
-))]
-
-//! Stream utilities for Tokio.
-//!
-//! A `Stream` is an asynchronous sequence of values. It can be thought of as
-//! an asynchronous version of the standard library's `Iterator` trait.
-//!
-//! This crate provides helpers to work with them. For examples of usage and a more in-depth
-//! description of streams you can also refer to the [streams
-//! tutorial](https://tokio.rs/tokio/tutorial/streams) on the tokio website.
-//!
-//! # Iterating over a Stream
-//!
-//! Due to similarities with the standard library's `Iterator` trait, some new
-//! users may assume that they can use `for in` syntax to iterate over a
-//! `Stream`, but this is unfortunately not possible. Instead, you can use a
-//! `while let` loop as follows:
-//!
-//! ```rust
-//! use tokio_stream::{self as stream, StreamExt};
-//!
-//! #[tokio::main]
-//! async fn main() {
-//!     let mut stream = stream::iter(vec![0, 1, 2]);
-//!
-//!     while let Some(value) = stream.next().await {
-//!         println!("Got {}", value);
-//!     }
-//! }
-//! ```
-//!
-//! # Returning a Stream from a function
-//!
-//! A common way to stream values from a function is to pass in the sender
-//! half of a channel and use the receiver as the stream. This requires awaiting
-//! both futures to ensure progress is made. Another alternative is the
-//! [async-stream] crate, which contains macros that provide a `yield` keyword
-//! and allow you to return an `impl Stream`.
-//!
-//! [async-stream]: https://docs.rs/async-stream
-//!
-//! # Conversion to and from AsyncRead/AsyncWrite
-//!
-//! It is often desirable to convert a `Stream` into an [`AsyncRead`],
-//! especially when dealing with plaintext formats streamed over the network.
-//! The opposite conversion from an [`AsyncRead`] into a `Stream` is also
-//! another commonly required feature. To enable these conversions,
-//! [`tokio-util`] provides the [`StreamReader`] and [`ReaderStream`]
-//! types when the io feature is enabled.
-//!
-//! [`tokio-util`]: https://docs.rs/tokio-util/0.4/tokio_util/codec/index.html
-//! [`tokio::io`]: https://docs.rs/tokio/1.0/tokio/io/index.html
-//! [`AsyncRead`]: https://docs.rs/tokio/1.0/tokio/io/trait.AsyncRead.html
-//! [`AsyncWrite`]: https://docs.rs/tokio/1.0/tokio/io/trait.AsyncWrite.html
-//! [`ReaderStream`]: https://docs.rs/tokio-util/0.4/tokio_util/io/struct.ReaderStream.html
-//! [`StreamReader`]: https://docs.rs/tokio-util/0.4/tokio_util/io/struct.StreamReader.html
-
-#[macro_use]
-mod macros;
-
-pub mod wrappers;
-
-mod stream_ext;
-pub use stream_ext::{collect::FromStream, StreamExt};
-
-mod empty;
-pub use empty::{empty, Empty};
-
-mod iter;
-pub use iter::{iter, Iter};
-
-mod once;
-pub use once::{once, Once};
-
-mod pending;
-pub use pending::{pending, Pending};
-
-mod stream_map;
-pub use stream_map::StreamMap;
-
-#[doc(no_inline)]
-pub use futures_core::Stream;

tokio-stream/src/macros.rs

@@ -1,68 +0,0 @@
-macro_rules! cfg_fs {
-    ($($item:item)*) => {
-        $(
-            #[cfg(feature = "fs")]
-            #[cfg_attr(docsrs, doc(cfg(feature = "fs")))]
-            $item
-        )*
-    }
-}
-
-macro_rules! cfg_io_util {
-    ($($item:item)*) => {
-        $(
-            #[cfg(feature = "io-util")]
-            #[cfg_attr(docsrs, doc(cfg(feature = "io-util")))]
-            $item
-        )*
-    }
-}
-
-macro_rules! cfg_net {
-    ($($item:item)*) => {
-        $(
-            #[cfg(feature = "net")]
-            #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
-            $item
-        )*
-    }
-}
-
-macro_rules! cfg_time {
-    ($($item:item)*) => {
-        $(
-            #[cfg(feature = "time")]
-            #[cfg_attr(docsrs, doc(cfg(feature = "time")))]
-            $item
-        )*
-    }
-}
-
-macro_rules! cfg_sync {
-    ($($item:item)*) => {
-        $(
-            #[cfg(feature = "sync")]
-            #[cfg_attr(docsrs, doc(cfg(feature = "sync")))]
-            $item
-        )*
-    }
-}
-
-macro_rules! cfg_signal {
-    ($($item:item)*) => {
-        $(
-            #[cfg(feature = "signal")]
-            #[cfg_attr(docsrs, doc(cfg(feature = "signal")))]
-            $item
-        )*
-    }
-}
-
-macro_rules! ready {
-    ($e:expr $(,)?) => {
-        match $e {
-            std::task::Poll::Ready(t) => t,
-            std::task::Poll::Pending => return std::task::Poll::Pending,
-        }
-    };
-}

tokio-stream/src/stream_ext/all.rs

@@ -1,58 +0,0 @@
-use crate::Stream;
-
-use core::future::Future;
-use core::marker::PhantomPinned;
-use core::pin::Pin;
-use core::task::{Context, Poll};
-use pin_project_lite::pin_project;
-
-pin_project! {
-    /// Future for the [`all`](super::StreamExt::all) method.
-    #[derive(Debug)]
-    #[must_use = "futures do nothing unless you `.await` or poll them"]
-    pub struct AllFuture<'a, St: ?Sized, F> {
-        stream: &'a mut St,
-        f: F,
-        // Make this future `!Unpin` for compatibility with async trait methods.
-        #[pin]
-        _pin: PhantomPinned,
-    }
-}
-
-impl<'a, St: ?Sized, F> AllFuture<'a, St, F> {
-    pub(super) fn new(stream: &'a mut St, f: F) -> Self {
-        Self {
-            stream,
-            f,
-            _pin: PhantomPinned,
-        }
-    }
-}
-
-impl<St, F> Future for AllFuture<'_, St, F>
-where
-    St: ?Sized + Stream + Unpin,
-    F: FnMut(St::Item) -> bool,
-{
-    type Output = bool;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let me = self.project();
-        let mut stream = Pin::new(me.stream);
-
-        // Take a maximum of 32 items from the stream before yielding.
-        for _ in 0..32 {
-            match futures_core::ready!(stream.as_mut().poll_next(cx)) {
-                Some(v) => {
-                    if !(me.f)(v) {
-                        return Poll::Ready(false);
-                    }
-                }
-                None => return Poll::Ready(true),
-            }
-        }
-
-        cx.waker().wake_by_ref();
-        Poll::Pending
-    }
-}

tokio-stream/src/stream_ext/any.rs

@@ -1,58 +0,0 @@
-use crate::Stream;
-
-use core::future::Future;
-use core::marker::PhantomPinned;
-use core::pin::Pin;
-use core::task::{Context, Poll};
-use pin_project_lite::pin_project;
-
-pin_project! {
-    /// Future for the [`any`](super::StreamExt::any) method.
-    #[derive(Debug)]
-    #[must_use = "futures do nothing unless you `.await` or poll them"]
-    pub struct AnyFuture<'a, St: ?Sized, F> {
-        stream: &'a mut St,
-        f: F,
-        // Make this future `!Unpin` for compatibility with async trait methods.
-        #[pin]
-        _pin: PhantomPinned,
-    }
-}
-
-impl<'a, St: ?Sized, F> AnyFuture<'a, St, F> {
-    pub(super) fn new(stream: &'a mut St, f: F) -> Self {
-        Self {
-            stream,
-            f,
-            _pin: PhantomPinned,
-        }
-    }
-}
-
-impl<St, F> Future for AnyFuture<'_, St, F>
-where
-    St: ?Sized + Stream + Unpin,
-    F: FnMut(St::Item) -> bool,
-{
-    type Output = bool;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let me = self.project();
-        let mut stream = Pin::new(me.stream);
-
-        // Take a maximum of 32 items from the stream before yielding.
-        for _ in 0..32 {
-            match futures_core::ready!(stream.as_mut().poll_next(cx)) {
-                Some(v) => {
-                    if (me.f)(v) {
-                        return Poll::Ready(true);
-                    }
-                }
-                None => return Poll::Ready(false),
-            }
-        }
-
-        cx.waker().wake_by_ref();
-        Poll::Pending
-    }
-}

tokio-stream/src/stream_ext/next.rs

@@ -1,37 +0,0 @@
-use crate::Stream;
-
-use core::future::Future;
-use core::marker::PhantomPinned;
-use core::pin::Pin;
-use core::task::{Context, Poll};
-use pin_project_lite::pin_project;
-
-pin_project! {
-    /// Future for the [`next`](super::StreamExt::next) method.
-    #[derive(Debug)]
-    #[must_use = "futures do nothing unless you `.await` or poll them"]
-    pub struct Next<'a, St: ?Sized> {
-        stream: &'a mut St,
-        // Make this future `!Unpin` for compatibility with async trait methods.
-        #[pin]
-        _pin: PhantomPinned,
-    }
-}
-
-impl<'a, St: ?Sized> Next<'a, St> {
-    pub(super) fn new(stream: &'a mut St) -> Self {
-        Next {
-            stream,
-            _pin: PhantomPinned,
-        }
-    }
-}
-
-impl<St: ?Sized + Stream + Unpin> Future for Next<'_, St> {
-    type Output = Option<St::Item>;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let me = self.project();
-        Pin::new(me.stream).poll_next(cx)
-    }
-}

tokio-stream/src/stream_ext/try_next.rs

@@ -1,39 +0,0 @@
-use crate::stream_ext::Next;
-use crate::Stream;
-
-use core::future::Future;
-use core::marker::PhantomPinned;
-use core::pin::Pin;
-use core::task::{Context, Poll};
-use pin_project_lite::pin_project;
-
-pin_project! {
-    /// Future for the [`try_next`](super::StreamExt::try_next) method.
-    #[derive(Debug)]
-    #[must_use = "futures do nothing unless you `.await` or poll them"]
-    pub struct TryNext<'a, St: ?Sized> {
-        #[pin]
-        inner: Next<'a, St>,
-        // Make this future `!Unpin` for compatibility with async trait methods.
-        #[pin]
-        _pin: PhantomPinned,
-    }
-}
-
-impl<'a, St: ?Sized> TryNext<'a, St> {
-    pub(super) fn new(stream: &'a mut St) -> Self {
-        Self {
-            inner: Next::new(stream),
-            _pin: PhantomPinned,
-        }
-    }
-}
-
-impl<T, E, St: ?Sized + Stream<Item = Result<T, E>> + Unpin> Future for TryNext<'_, St> {
-    type Output = Result<Option<T>, E>;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let me = self.project();
-        me.inner.poll(cx).map(Option::transpose)
-    }
-}

tokio-stream/src/wrappers.rs

@@ -1,71 +0,0 @@
-//! Wrappers for Tokio types that implement `Stream`.
-//!
-#![cfg_attr(
-    unix,
-    doc = "You are viewing documentation built under unix. To view windows-specific wrappers, change to the `x86_64-pc-windows-msvc` platform."
-)]
-#![cfg_attr(
-    windows,
-    doc = "You are viewing documentation built under windows. To view unix-specific wrappers, change to the `x86_64-unknown-linux-gnu` platform."
-)]
-
-/// Error types for the wrappers.
-pub mod errors {
-    cfg_sync! {
-        pub use crate::wrappers::broadcast::BroadcastStreamRecvError;
-    }
-}
-
-mod mpsc_bounded;
-pub use mpsc_bounded::ReceiverStream;
-
-mod mpsc_unbounded;
-pub use mpsc_unbounded::UnboundedReceiverStream;
-
-cfg_sync! {
-    mod broadcast;
-    pub use broadcast::BroadcastStream;
-
-    mod watch;
-    pub use watch::WatchStream;
-}
-
-cfg_signal! {
-    #[cfg(unix)]
-    mod signal_unix;
-    #[cfg(unix)]
-    pub use signal_unix::SignalStream;
-
-    #[cfg(windows)]
-    mod signal_windows;
-    #[cfg(windows)]
-    pub use signal_windows::{CtrlCStream, CtrlBreakStream};
-}
-
-cfg_time! {
-    mod interval;
-    pub use interval::IntervalStream;
-}
-
-cfg_net! {
-    mod tcp_listener;
-    pub use tcp_listener::TcpListenerStream;
-
-    #[cfg(unix)]
-    mod unix_listener;
-    #[cfg(unix)]
-    pub use unix_listener::UnixListenerStream;
-}
-
-cfg_io_util! {
-    mod split;
-    pub use split::SplitStream;
-
-    mod lines;
-    pub use lines::LinesStream;
-}
-
-cfg_fs! {
-    mod read_dir;
-    pub use read_dir::ReadDirStream;
-}

tokio-stream/src/wrappers/broadcast.rs

@@ -1,73 +0,0 @@
-use std::pin::Pin;
-use tokio::sync::broadcast::error::RecvError;
-use tokio::sync::broadcast::Receiver;
-
-use futures_core::Stream;
-use tokio_util::sync::ReusableBoxFuture;
-
-use std::fmt;
-use std::task::{Context, Poll};
-
-/// A wrapper around [`tokio::sync::broadcast::Receiver`] that implements [`Stream`].
-///
-/// [`tokio::sync::broadcast::Receiver`]: struct@tokio::sync::broadcast::Receiver
-/// [`Stream`]: trait@crate::Stream
-#[cfg_attr(docsrs, doc(cfg(feature = "sync")))]
-pub struct BroadcastStream<T> {
-    inner: ReusableBoxFuture<(Result<T, RecvError>, Receiver<T>)>,
-}
-
-/// An error returned from the inner stream of a [`BroadcastStream`].
-#[derive(Debug, PartialEq)]
-pub enum BroadcastStreamRecvError {
-    /// The receiver lagged too far behind. Attempting to receive again will
-    /// return the oldest message still retained by the channel.
-    ///
-    /// Includes the number of skipped messages.
-    Lagged(u64),
-}
-
-impl fmt::Display for BroadcastStreamRecvError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            BroadcastStreamRecvError::Lagged(amt) => write!(f, "channel lagged by {}", amt),
-        }
-    }
-}
-
-impl std::error::Error for BroadcastStreamRecvError {}
-
-async fn make_future<T: Clone>(mut rx: Receiver<T>) -> (Result<T, RecvError>, Receiver<T>) {
-    let result = rx.recv().await;
-    (result, rx)
-}
-
-impl<T: 'static + Clone + Send> BroadcastStream<T> {
-    /// Create a new `BroadcastStream`.
-    pub fn new(rx: Receiver<T>) -> Self {
-        Self {
-            inner: ReusableBoxFuture::new(make_future(rx)),
-        }
-    }
-}
-
-impl<T: 'static + Clone + Send> Stream for BroadcastStream<T> {
-    type Item = Result<T, BroadcastStreamRecvError>;
-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        let (result, rx) = ready!(self.inner.poll(cx));
-        self.inner.set(make_future(rx));
-        match result {
-            Ok(item) => Poll::Ready(Some(Ok(item))),
-            Err(RecvError::Closed) => Poll::Ready(None),
-            Err(RecvError::Lagged(n)) => {
-                Poll::Ready(Some(Err(BroadcastStreamRecvError::Lagged(n))))
-            }
-        }
-    }
-}
-
-impl<T> fmt::Debug for BroadcastStream<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("BroadcastStream").finish()
-    }
-}

tokio-stream/src/wrappers/interval.rs

@@ -1,50 +0,0 @@
-use crate::Stream;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use tokio::time::{Instant, Interval};
-
-/// A wrapper around [`Interval`] that implements [`Stream`].
-///
-/// [`Interval`]: struct@tokio::time::Interval
-/// [`Stream`]: trait@crate::Stream
-#[derive(Debug)]
-#[cfg_attr(docsrs, doc(cfg(feature = "time")))]
-pub struct IntervalStream {
-    inner: Interval,
-}
-
-impl IntervalStream {
-    /// Create a new `IntervalStream`.
-    pub fn new(interval: Interval) -> Self {
-        Self { inner: interval }
-    }
-
-    /// Get back the inner `Interval`.
-    pub fn into_inner(self) -> Interval {
-        self.inner
-    }
-}
-
-impl Stream for IntervalStream {
-    type Item = Instant;
-
-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Instant>> {
-        self.inner.poll_tick(cx).map(Some)
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (std::usize::MAX, None)
-    }
-}
-
-impl AsRef<Interval> for IntervalStream {
-    fn as_ref(&self) -> &Interval {
-        &self.inner
-    }
-}
-
-impl AsMut<Interval> for IntervalStream {
-    fn as_mut(&mut self) -> &mut Interval {
-        &mut self.inner
-    }
-}

tokio-stream/src/wrappers/lines.rs

@@ -1,60 +0,0 @@
-use crate::Stream;
-use pin_project_lite::pin_project;
-use std::io;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use tokio::io::{AsyncBufRead, Lines};
-
-pin_project! {
-    /// A wrapper around [`tokio::io::Lines`] that implements [`Stream`].
-    ///
-    /// [`tokio::io::Lines`]: struct@tokio::io::Lines
-    /// [`Stream`]: trait@crate::Stream
-    #[derive(Debug)]
-    #[cfg_attr(docsrs, doc(cfg(feature = "io-util")))]
-    pub struct LinesStream<R> {
-        #[pin]
-        inner: Lines<R>,
-    }
-}
-
-impl<R> LinesStream<R> {
-    /// Create a new `LinesStream`.
-    pub fn new(lines: Lines<R>) -> Self {
-        Self { inner: lines }
-    }
-
-    /// Get back the inner `Lines`.
-    pub fn into_inner(self) -> Lines<R> {
-        self.inner
-    }
-
-    /// Obtain a pinned reference to the inner `Lines<R>`.
-    #[allow(clippy::wrong_self_convention)] // https://github.com/rust-lang/rust-clippy/issues/4546
-    pub fn as_pin_mut(self: Pin<&mut Self>) -> Pin<&mut Lines<R>> {
-        self.project().inner
-    }
-}
-
-impl<R: AsyncBufRead> Stream for LinesStream<R> {
-    type Item = io::Result<String>;
-
-    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        self.project()
-            .inner
-            .poll_next_line(cx)
-            .map(Result::transpose)
-    }
-}
-
-impl<R> AsRef<Lines<R>> for LinesStream<R> {
-    fn as_ref(&self) -> &Lines<R> {
-        &self.inner
-    }
-}
-
-impl<R> AsMut<Lines<R>> for LinesStream<R> {
-    fn as_mut(&mut self) -> &mut Lines<R> {
-        &mut self.inner
-    }
-}

tokio-stream/src/wrappers/mpsc_bounded.rs

@@ -1,59 +0,0 @@
-use crate::Stream;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use tokio::sync::mpsc::Receiver;
-
-/// A wrapper around [`tokio::sync::mpsc::Receiver`] that implements [`Stream`].
-///
-/// [`tokio::sync::mpsc::Receiver`]: struct@tokio::sync::mpsc::Receiver
-/// [`Stream`]: trait@crate::Stream
-#[derive(Debug)]
-pub struct ReceiverStream<T> {
-    inner: Receiver<T>,
-}
-
-impl<T> ReceiverStream<T> {
-    /// Create a new `ReceiverStream`.
-    pub fn new(recv: Receiver<T>) -> Self {
-        Self { inner: recv }
-    }
-
-    /// Get back the inner `Receiver`.
-    pub fn into_inner(self) -> Receiver<T> {
-        self.inner
-    }
-
-    /// Closes the receiving half of a channel without dropping it.
-    ///
-    /// This prevents any further messages from being sent on the channel while
-    /// still enabling the receiver to drain messages that are buffered. Any
-    /// outstanding [`Permit`] values will still be able to send messages.
-    ///
-    /// To guarantee no messages are dropped, after calling `close()`, you must
-    /// receive all items from the stream until `None` is returned.
-    ///
-    /// [`Permit`]: struct@tokio::sync::mpsc::Permit
-    pub fn close(&mut self) {
-        self.inner.close()
-    }
-}
-
-impl<T> Stream for ReceiverStream<T> {
-    type Item = T;
-
-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        self.inner.poll_recv(cx)
-    }
-}
-
-impl<T> AsRef<Receiver<T>> for ReceiverStream<T> {
-    fn as_ref(&self) -> &Receiver<T> {
-        &self.inner
-    }
-}
-
-impl<T> AsMut<Receiver<T>> for ReceiverStream<T> {
-    fn as_mut(&mut self) -> &mut Receiver<T> {
-        &mut self.inner
-    }
-}

tokio-stream/src/wrappers/mpsc_unbounded.rs

@@ -1,53 +0,0 @@
-use crate::Stream;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use tokio::sync::mpsc::UnboundedReceiver;
-
-/// A wrapper around [`tokio::sync::mpsc::UnboundedReceiver`] that implements [`Stream`].
-///
-/// [`tokio::sync::mpsc::UnboundedReceiver`]: struct@tokio::sync::mpsc::UnboundedReceiver
-/// [`Stream`]: trait@crate::Stream
-#[derive(Debug)]
-pub struct UnboundedReceiverStream<T> {
-    inner: UnboundedReceiver<T>,
-}
-
-impl<T> UnboundedReceiverStream<T> {
-    /// Create a new `UnboundedReceiverStream`.
-    pub fn new(recv: UnboundedReceiver<T>) -> Self {
-        Self { inner: recv }
-    }
-
-    /// Get back the inner `UnboundedReceiver`.
-    pub fn into_inner(self) -> UnboundedReceiver<T> {
-        self.inner
-    }
-
-    /// Closes the receiving half of a channel without dropping it.
-    ///
-    /// This prevents any further messages from being sent on the channel while
-    /// still enabling the receiver to drain messages that are buffered.
-    pub fn close(&mut self) {
-        self.inner.close()
-    }
-}
-
-impl<T> Stream for UnboundedReceiverStream<T> {
-    type Item = T;
-
-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        self.inner.poll_recv(cx)
-    }
-}
-
-impl<T> AsRef<UnboundedReceiver<T>> for UnboundedReceiverStream<T> {
-    fn as_ref(&self) -> &UnboundedReceiver<T> {
-        &self.inner
-    }
-}
-
-impl<T> AsMut<UnboundedReceiver<T>> for UnboundedReceiverStream<T> {
-    fn as_mut(&mut self) -> &mut UnboundedReceiver<T> {
-        &mut self.inner
-    }
-}

tokio-stream/src/wrappers/read_dir.rs

@@ -1,47 +0,0 @@
-use crate::Stream;
-use std::io;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use tokio::fs::{DirEntry, ReadDir};
-
-/// A wrapper around [`tokio::fs::ReadDir`] that implements [`Stream`].
-///
-/// [`tokio::fs::ReadDir`]: struct@tokio::fs::ReadDir
-/// [`Stream`]: trait@crate::Stream
-#[derive(Debug)]
-#[cfg_attr(docsrs, doc(cfg(feature = "fs")))]
-pub struct ReadDirStream {
-    inner: ReadDir,
-}
-
-impl ReadDirStream {
-    /// Create a new `ReadDirStream`.
-    pub fn new(read_dir: ReadDir) -> Self {
-        Self { inner: read_dir }
-    }
-
-    /// Get back the inner `ReadDir`.
-    pub fn into_inner(self) -> ReadDir {
-        self.inner
-    }
-}
-
-impl Stream for ReadDirStream {
-    type Item = io::Result<DirEntry>;
-
-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        self.inner.poll_next_entry(cx).map(Result::transpose)
-    }
-}
-
-impl AsRef<ReadDir> for ReadDirStream {
-    fn as_ref(&self) -> &ReadDir {
-        &self.inner
-    }
-}
-
-impl AsMut<ReadDir> for ReadDirStream {
-    fn as_mut(&mut self) -> &mut ReadDir {
-        &mut self.inner
-    }
-}

tokio-stream/src/wrappers/signal_unix.rs

@@ -1,46 +0,0 @@
-use crate::Stream;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use tokio::signal::unix::Signal;
-
-/// A wrapper around [`Signal`] that implements [`Stream`].
-///
-/// [`Signal`]: struct@tokio::signal::unix::Signal
-/// [`Stream`]: trait@crate::Stream
-#[derive(Debug)]
-#[cfg_attr(docsrs, doc(cfg(all(unix, feature = "signal"))))]
-pub struct SignalStream {
-    inner: Signal,
-}
-
-impl SignalStream {
-    /// Create a new `SignalStream`.
-    pub fn new(interval: Signal) -> Self {
-        Self { inner: interval }
-    }
-
-    /// Get back the inner `Signal`.
-    pub fn into_inner(self) -> Signal {
-        self.inner
-    }
-}
-
-impl Stream for SignalStream {
-    type Item = ();
-
-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<()>> {
-        self.inner.poll_recv(cx)
-    }
-}
-
-impl AsRef<Signal> for SignalStream {
-    fn as_ref(&self) -> &Signal {
-        &self.inner
-    }
-}
-
-impl AsMut<Signal> for SignalStream {
-    fn as_mut(&mut self) -> &mut Signal {
-        &mut self.inner
-    }
-}

tokio-stream/src/wrappers/signal_windows.rs

@@ -1,88 +0,0 @@
-use crate::Stream;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use tokio::signal::windows::{CtrlBreak, CtrlC};
-
-/// A wrapper around [`CtrlC`] that implements [`Stream`].
-///
-/// [`CtrlC`]: struct@tokio::signal::windows::CtrlC
-/// [`Stream`]: trait@crate::Stream
-#[derive(Debug)]
-#[cfg_attr(docsrs, doc(cfg(all(windows, feature = "signal"))))]
-pub struct CtrlCStream {
-    inner: CtrlC,
-}
-
-impl CtrlCStream {
-    /// Create a new `CtrlCStream`.
-    pub fn new(interval: CtrlC) -> Self {
-        Self { inner: interval }
-    }
-
-    /// Get back the inner `CtrlC`.
-    pub fn into_inner(self) -> CtrlC {
-        self.inner
-    }
-}
-
-impl Stream for CtrlCStream {
-    type Item = ();
-
-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<()>> {
-        self.inner.poll_recv(cx)
-    }
-}
-
-impl AsRef<CtrlC> for CtrlCStream {
-    fn as_ref(&self) -> &CtrlC {
-        &self.inner
-    }
-}
-
-impl AsMut<CtrlC> for CtrlCStream {
-    fn as_mut(&mut self) -> &mut CtrlC {
-        &mut self.inner
-    }
-}
-
-/// A wrapper around [`CtrlBreak`] that implements [`Stream`].
-///
-/// [`CtrlBreak`]: struct@tokio::signal::windows::CtrlBreak
-/// [`Stream`]: trait@crate::Stream
-#[derive(Debug)]
-#[cfg_attr(docsrs, doc(cfg(all(windows, feature = "signal"))))]
-pub struct CtrlBreakStream {
-    inner: CtrlBreak,
-}
-
-impl CtrlBreakStream {
-    /// Create a new `CtrlBreakStream`.
-    pub fn new(interval: CtrlBreak) -> Self {
-        Self { inner: interval }
-    }
-
-    /// Get back the inner `CtrlBreak`.
-    pub fn into_inner(self) -> CtrlBreak {
-        self.inner
-    }
-}
-
-impl Stream for CtrlBreakStream {
-    type Item = ();
-
-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<()>> {
-        self.inner.poll_recv(cx)
-    }
-}
-
-impl AsRef<CtrlBreak> for CtrlBreakStream {
-    fn as_ref(&self) -> &CtrlBreak {
-        &self.inner
-    }
-}
-
-impl AsMut<CtrlBreak> for CtrlBreakStream {
-    fn as_mut(&mut self) -> &mut CtrlBreak {
-        &mut self.inner
-    }
-}

tokio-stream/src/wrappers/split.rs

@@ -1,60 +0,0 @@
-use crate::Stream;
-use pin_project_lite::pin_project;
-use std::io;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use tokio::io::{AsyncBufRead, Split};
-
-pin_project! {
-    /// A wrapper around [`tokio::io::Split`] that implements [`Stream`].
-    ///
-    /// [`tokio::io::Split`]: struct@tokio::io::Split
-    /// [`Stream`]: trait@crate::Stream
-    #[derive(Debug)]
-    #[cfg_attr(docsrs, doc(cfg(feature = "io-util")))]
-    pub struct SplitStream<R> {
-        #[pin]
-        inner: Split<R>,
-    }
-}
-
-impl<R> SplitStream<R> {
-    /// Create a new `SplitStream`.
-    pub fn new(split: Split<R>) -> Self {
-        Self { inner: split }
-    }
-
-    /// Get back the inner `Split`.
-    pub fn into_inner(self) -> Split<R> {
-        self.inner
-    }
-
-    /// Obtain a pinned reference to the inner `Split<R>`.
-    #[allow(clippy::wrong_self_convention)] // https://github.com/rust-lang/rust-clippy/issues/4546
-    pub fn as_pin_mut(self: Pin<&mut Self>) -> Pin<&mut Split<R>> {
-        self.project().inner
-    }
-}
-
-impl<R: AsyncBufRead> Stream for SplitStream<R> {
-    type Item = io::Result<Vec<u8>>;
-
-    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        self.project()
-            .inner
-            .poll_next_segment(cx)
-            .map(Result::transpose)
-    }
-}
-
-impl<R> AsRef<Split<R>> for SplitStream<R> {
-    fn as_ref(&self) -> &Split<R> {
-        &self.inner
-    }
-}
-
-impl<R> AsMut<Split<R>> for SplitStream<R> {
-    fn as_mut(&mut self) -> &mut Split<R> {
-        &mut self.inner
-    }
-}

tokio-stream/src/wrappers/tcp_listener.rs

@@ -1,54 +0,0 @@
-use crate::Stream;
-use std::io;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use tokio::net::{TcpListener, TcpStream};
-
-/// A wrapper around [`TcpListener`] that implements [`Stream`].
-///
-/// [`TcpListener`]: struct@tokio::net::TcpListener
-/// [`Stream`]: trait@crate::Stream
-#[derive(Debug)]
-#[cfg_attr(docsrs, doc(cfg(feature = "net")))]
-pub struct TcpListenerStream {
-    inner: TcpListener,
-}
-
-impl TcpListenerStream {
-    /// Create a new `TcpListenerStream`.
-    pub fn new(listener: TcpListener) -> Self {
-        Self { inner: listener }
-    }
-
-    /// Get back the inner `TcpListener`.
-    pub fn into_inner(self) -> TcpListener {
-        self.inner
-    }
-}
-
-impl Stream for TcpListenerStream {
-    type Item = io::Result<TcpStream>;
-
-    fn poll_next(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<io::Result<TcpStream>>> {
-        match self.inner.poll_accept(cx) {
-            Poll::Ready(Ok((stream, _))) => Poll::Ready(Some(Ok(stream))),
-            Poll::Ready(Err(err)) => Poll::Ready(Some(Err(err))),
-            Poll::Pending => Poll::Pending,
-        }
-    }
-}
-
-impl AsRef<TcpListener> for TcpListenerStream {
-    fn as_ref(&self) -> &TcpListener {
-        &self.inner
-    }
-}
-
-impl AsMut<TcpListener> for TcpListenerStream {
-    fn as_mut(&mut self) -> &mut TcpListener {
-        &mut self.inner
-    }
-}

tokio-stream/src/wrappers/unix_listener.rs

@@ -1,54 +0,0 @@
-use crate::Stream;
-use std::io;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use tokio::net::{UnixListener, UnixStream};
-
-/// A wrapper around [`UnixListener`] that implements [`Stream`].
-///
-/// [`UnixListener`]: struct@tokio::net::UnixListener
-/// [`Stream`]: trait@crate::Stream
-#[derive(Debug)]
-#[cfg_attr(docsrs, doc(cfg(all(unix, feature = "net"))))]
-pub struct UnixListenerStream {
-    inner: UnixListener,
-}
-
-impl UnixListenerStream {
-    /// Create a new `UnixListenerStream`.
-    pub fn new(listener: UnixListener) -> Self {
-        Self { inner: listener }
-    }
-
-    /// Get back the inner `UnixListener`.
-    pub fn into_inner(self) -> UnixListener {
-        self.inner
-    }
-}
-
-impl Stream for UnixListenerStream {
-    type Item = io::Result<UnixStream>;
-
-    fn poll_next(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<io::Result<UnixStream>>> {
-        match self.inner.poll_accept(cx) {
-            Poll::Ready(Ok((stream, _))) => Poll::Ready(Some(Ok(stream))),
-            Poll::Ready(Err(err)) => Poll::Ready(Some(Err(err))),
-            Poll::Pending => Poll::Pending,
-        }
-    }
-}
-
-impl AsRef<UnixListener> for UnixListenerStream {
-    fn as_ref(&self) -> &UnixListener {
-        &self.inner
-    }
-}
-
-impl AsMut<UnixListener> for UnixListenerStream {
-    fn as_mut(&mut self) -> &mut UnixListener {
-        &mut self.inner
-    }
-}

tokio-stream/src/wrappers/watch.rs

@@ -1,96 +0,0 @@
-use std::pin::Pin;
-use tokio::sync::watch::Receiver;
-
-use futures_core::Stream;
-use tokio_util::sync::ReusableBoxFuture;
-
-use std::fmt;
-use std::task::{Context, Poll};
-use tokio::sync::watch::error::RecvError;
-
-/// A wrapper around [`tokio::sync::watch::Receiver`] that implements [`Stream`].
-///
-/// This stream will always start by yielding the current value when the WatchStream is polled,
-/// regardles of whether it was the initial value or sent afterwards.
-///
-/// # Examples
-///
-/// ```
-/// # #[tokio::main]
-/// # async fn main() {
-/// use tokio_stream::{StreamExt, wrappers::WatchStream};
-/// use tokio::sync::watch;
-///
-/// let (tx, rx) = watch::channel("hello");
-/// let mut rx = WatchStream::new(rx);
-///
-/// assert_eq!(rx.next().await, Some("hello"));
-///
-/// tx.send("goodbye").unwrap();
-/// assert_eq!(rx.next().await, Some("goodbye"));
-/// # }
-/// ```
-///
-/// ```
-/// # #[tokio::main]
-/// # async fn main() {
-/// use tokio_stream::{StreamExt, wrappers::WatchStream};
-/// use tokio::sync::watch;
-///
-/// let (tx, rx) = watch::channel("hello");
-/// let mut rx = WatchStream::new(rx);
-///
-/// tx.send("goodbye").unwrap();
-/// assert_eq!(rx.next().await, Some("goodbye"));
-/// # }
-/// ```
-///
-/// [`tokio::sync::watch::Receiver`]: struct@tokio::sync::watch::Receiver
-/// [`Stream`]: trait@crate::Stream
-#[cfg_attr(docsrs, doc(cfg(feature = "sync")))]
-pub struct WatchStream<T> {
-    inner: ReusableBoxFuture<(Result<(), RecvError>, Receiver<T>)>,
-}
-
-async fn make_future<T: Clone + Send + Sync>(
-    mut rx: Receiver<T>,
-) -> (Result<(), RecvError>, Receiver<T>) {
-    let result = rx.changed().await;
-    (result, rx)
-}
-
-impl<T: 'static + Clone + Unpin + Send + Sync> WatchStream<T> {
-    /// Create a new `WatchStream`.
-    pub fn new(rx: Receiver<T>) -> Self {
-        Self {
-            inner: ReusableBoxFuture::new(async move { (Ok(()), rx) }),
-        }
-    }
-}
-
-impl<T: Clone + 'static + Send + Sync> Stream for WatchStream<T> {
-    type Item = T;
-
-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        let (result, rx) = ready!(self.inner.poll(cx));
-        match result {
-            Ok(_) => {
-                let received = (*rx.borrow()).clone();
-                self.inner.set(make_future(rx));
-                Poll::Ready(Some(received))
-            }
-            Err(_) => {
-                self.inner.set(make_future(rx));
-                Poll::Ready(None)
-            }
-        }
-    }
-}
-
-impl<T> Unpin for WatchStream<T> {}
-
-impl<T> fmt::Debug for WatchStream<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("WatchStream").finish()
-    }
-}

tokio-stream/tests/async_send_sync.rs

@@ -1,105 +0,0 @@
-use std::rc::Rc;
-
-#[allow(dead_code)]
-type BoxStream<T> = std::pin::Pin<Box<dyn tokio_stream::Stream<Item = T>>>;
-
-#[allow(dead_code)]
-fn require_send<T: Send>(_t: &T) {}
-#[allow(dead_code)]
-fn require_sync<T: Sync>(_t: &T) {}
-#[allow(dead_code)]
-fn require_unpin<T: Unpin>(_t: &T) {}
-
-#[allow(dead_code)]
-struct Invalid;
-
-trait AmbiguousIfSend<A> {
-    fn some_item(&self) {}
-}
-impl<T: ?Sized> AmbiguousIfSend<()> for T {}
-impl<T: ?Sized + Send> AmbiguousIfSend<Invalid> for T {}
-
-trait AmbiguousIfSync<A> {
-    fn some_item(&self) {}
-}
-impl<T: ?Sized> AmbiguousIfSync<()> for T {}
-impl<T: ?Sized + Sync> AmbiguousIfSync<Invalid> for T {}
-
-trait AmbiguousIfUnpin<A> {
-    fn some_item(&self) {}
-}
-impl<T: ?Sized> AmbiguousIfUnpin<()> for T {}
-impl<T: ?Sized + Unpin> AmbiguousIfUnpin<Invalid> for T {}
-
-macro_rules! into_todo {
-    ($typ:ty) => {{
-        let x: $typ = todo!();
-        x
-    }};
-}
-
-macro_rules! async_assert_fn {
-    ($($f:ident $(< $($generic:ty),* > )? )::+($($arg:ty),*): Send & Sync) => {
-        #[allow(unreachable_code)]
-        #[allow(unused_variables)]
-        const _: fn() = || {
-            let f = $($f $(::<$($generic),*>)? )::+( $( into_todo!($arg) ),* );
-            require_send(&f);
-            require_sync(&f);
-        };
-    };
-    ($($f:ident $(< $($generic:ty),* > )? )::+($($arg:ty),*): Send & !Sync) => {
-        #[allow(unreachable_code)]
-        #[allow(unused_variables)]
-        const _: fn() = || {
-            let f = $($f $(::<$($generic),*>)? )::+( $( into_todo!($arg) ),* );
-            require_send(&f);
-            AmbiguousIfSync::some_item(&f);
-        };
-    };
-    ($($f:ident $(< $($generic:ty),* > )? )::+($($arg:ty),*): !Send & Sync) => {
-        #[allow(unreachable_code)]
-        #[allow(unused_variables)]
-        const _: fn() = || {
-            let f = $($f $(::<$($generic),*>)? )::+( $( into_todo!($arg) ),* );
-            AmbiguousIfSend::some_item(&f);
-            require_sync(&f);
-        };
-    };
-    ($($f:ident $(< $($generic:ty),* > )? )::+($($arg:ty),*): !Send & !Sync) => {
-        #[allow(unreachable_code)]
-        #[allow(unused_variables)]
-        const _: fn() = || {
-            let f = $($f $(::<$($generic),*>)? )::+( $( into_todo!($arg) ),* );
-            AmbiguousIfSend::some_item(&f);
-            AmbiguousIfSync::some_item(&f);
-        };
-    };
-    ($($f:ident $(< $($generic:ty),* > )? )::+($($arg:ty),*): !Unpin) => {
-        #[allow(unreachable_code)]
-        #[allow(unused_variables)]
-        const _: fn() = || {
-            let f = $($f $(::<$($generic),*>)? )::+( $( into_todo!($arg) ),* );
-            AmbiguousIfUnpin::some_item(&f);
-        };
-    };
-    ($($f:ident $(< $($generic:ty),* > )? )::+($($arg:ty),*): Unpin) => {
-        #[allow(unreachable_code)]
-        #[allow(unused_variables)]
-        const _: fn() = || {
-            let f = $($f $(::<$($generic),*>)? )::+( $( into_todo!($arg) ),* );
-            require_unpin(&f);
-        };
-    };
-}
-
-async_assert_fn!(tokio_stream::empty<Rc<u8>>(): Send & Sync);
-async_assert_fn!(tokio_stream::pending<Rc<u8>>(): Send & Sync);
-async_assert_fn!(tokio_stream::iter(std::vec::IntoIter<u8>): Send & Sync);
-
-async_assert_fn!(tokio_stream::StreamExt::next(&mut BoxStream<()>): !Unpin);
-async_assert_fn!(tokio_stream::StreamExt::try_next(&mut BoxStream<Result<(), ()>>): !Unpin);
-async_assert_fn!(tokio_stream::StreamExt::all(&mut BoxStream<()>, fn(())->bool): !Unpin);
-async_assert_fn!(tokio_stream::StreamExt::any(&mut BoxStream<()>, fn(())->bool): !Unpin);
-async_assert_fn!(tokio_stream::StreamExt::fold(&mut BoxStream<()>, (), fn((), ())->()): !Unpin);
-async_assert_fn!(tokio_stream::StreamExt::collect<Vec<()>>(&mut BoxStream<()>): !Unpin);

tokio-stream/tests/support/mpsc.rs

@@ -1,15 +0,0 @@
-use async_stream::stream;
-use tokio::sync::mpsc::{self, UnboundedSender};
-use tokio_stream::Stream;
-
-pub fn unbounded_channel_stream<T: Unpin>() -> (UnboundedSender<T>, impl Stream<Item = T>) {
-    let (tx, mut rx) = mpsc::unbounded_channel();
-
-    let stream = stream! {
-        while let Some(item) = rx.recv().await {
-            yield item;
-        }
-    };
-
-    (tx, stream)
-}

tokio-test/CHANGELOG.md

@@ -1,17 +1,3 @@
-# 0.4.1 (March 10, 2021)
-
-- Fix `io::Mock` to be `Send` and `Sync` ([#3594])
-
-[#3594]: https://github.com/tokio-rs/tokio/pull/3594
-
-# 0.4.0 (December 23, 2020)
-
-- Track `tokio` 1.0 release.
-
-# 0.3.0 (October 15, 2020)
-
-- Track `tokio` 0.3 release.
-
 # 0.2.1 (April 17, 2020)
 
 - Add `Future` and `Stream` implementations for `task::Spawn<T>`.

tokio-test/Cargo.toml

@@ -2,32 +2,31 @@
 name = "tokio-test"
 # When releasing to crates.io:
 # - Remove path dependencies
+# - Update html_root_url.
 # - Update doc url
 #   - Cargo.toml
 # - Update CHANGELOG.md.
-# - Create "tokio-test-0.4.x" git tag.
-version = "0.4.1"
+# - Create "v0.2.x" git tag.
+version = "0.2.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-test/0.4.1/tokio_test"
+documentation = "https://docs.rs/tokio-test/0.2.1/tokio_test"
 description = """
 Testing utilities for Tokio- and futures-based code
 """
 categories = ["asynchronous", "testing"]
 
 [dependencies]
-tokio = { version = "1.2.0", path = "../tokio", features = ["rt", "sync", "time", "test-util"] }
-tokio-stream = { version = "0.1", path = "../tokio-stream" }
-async-stream = "0.3"
+tokio = { version = "0.2.0", path = "../tokio", features = ["rt-core", "stream", "sync", "time", "test-util"] }
 
-bytes = "1.0.0"
+bytes = "0.5.0"
 futures-core = "0.3.0"
 
 [dev-dependencies]
-tokio = { version = "1.2.0", path = "../tokio", features = ["full"] }
+tokio = { version = "0.2.0", path = "../tokio", features = ["full"] }
 futures-util = "0.3.0"
 
 [package.metadata.docs.rs]

tokio-test/LICENSE

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

tokio-test/src/io.rs

@@ -18,14 +18,13 @@
 //! [`AsyncRead`]: tokio::io::AsyncRead
 //! [`AsyncWrite`]: tokio::io::AsyncWrite
 
-use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
+use tokio::io::{AsyncRead, AsyncWrite};
 use tokio::sync::mpsc;
-use tokio::time::{self, Duration, Instant, Sleep};
-use tokio_stream::wrappers::UnboundedReceiverStream;
+use tokio::time::{self, Delay, Duration, Instant};
 
-use futures_core::{ready, Stream};
+use bytes::Buf;
+use futures_core::ready;
 use std::collections::VecDeque;
-use std::fmt;
 use std::future::Future;
 use std::pin::Pin;
 use std::sync::Arc;
@@ -65,12 +64,13 @@ enum Action {
     WriteError(Option<Arc<io::Error>>),
 }
 
+#[derive(Debug)]
 struct Inner {
     actions: VecDeque<Action>,
     waiting: Option<Instant>,
-    sleep: Option<Pin<Box<Sleep>>>,
+    sleep: Option<Delay>,
     read_wait: Option<Waker>,
-    rx: UnboundedReceiverStream<Action>,
+    rx: mpsc::UnboundedReceiver<Action>,
 }
 
 impl Builder {
@@ -187,8 +187,6 @@ impl Inner {
     fn new(actions: VecDeque<Action>) -> (Inner, Handle) {
         let (tx, rx) = mpsc::unbounded_channel();
 
-        let rx = UnboundedReceiverStream::new(rx);
-
         let inner = Inner {
             actions,
             sleep: None,
@@ -203,22 +201,23 @@ impl Inner {
     }
 
     fn poll_action(&mut self, cx: &mut task::Context<'_>) -> Poll<Option<Action>> {
-        Pin::new(&mut self.rx).poll_next(cx)
+        self.rx.poll_recv(cx)
     }
 
-    fn read(&mut self, dst: &mut ReadBuf<'_>) -> io::Result<()> {
+    fn read(&mut self, dst: &mut [u8]) -> io::Result<usize> {
         match self.action() {
             Some(&mut Action::Read(ref mut data)) => {
                 // Figure out how much to copy
-                let n = cmp::min(dst.remaining(), data.len());
+                let n = cmp::min(dst.len(), data.len());
 
                 // Copy the data into the `dst` slice
-                dst.put_slice(&data[..n]);
+                (&mut dst[..n]).copy_from_slice(&data[..n]);
 
                 // Drain the data from the source
                 data.drain(..n);
 
-                Ok(())
+                // Return the number of bytes read
+                Ok(n)
             }
             Some(&mut Action::ReadError(ref mut err)) => {
                 // As the
@@ -230,7 +229,7 @@ impl Inner {
                 // Either waiting or expecting a write
                 Err(io::ErrorKind::WouldBlock.into())
             }
-            None => Ok(()),
+            None => Ok(0),
         }
     }
 
@@ -349,8 +348,8 @@ impl AsyncRead for Mock {
     fn poll_read(
         mut self: Pin<&mut Self>,
         cx: &mut task::Context<'_>,
-        buf: &mut ReadBuf<'_>,
-    ) -> Poll<io::Result<()>> {
+        buf: &mut [u8],
+    ) -> Poll<io::Result<usize>> {
         loop {
             if let Some(ref mut sleep) = self.inner.sleep {
                 ready!(Pin::new(sleep).poll(cx));
@@ -359,35 +358,29 @@ impl AsyncRead for Mock {
             // If a sleep is set, it has already fired
             self.inner.sleep = None;
 
-            // Capture 'filled' to monitor if it changed
-            let filled = buf.filled().len();
-
             match self.inner.read(buf) {
                 Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
                     if let Some(rem) = self.inner.remaining_wait() {
                         let until = Instant::now() + rem;
-                        self.inner.sleep = Some(Box::pin(time::sleep_until(until)));
+                        self.inner.sleep = Some(time::delay_until(until));
                     } else {
                         self.inner.read_wait = Some(cx.waker().clone());
                         return Poll::Pending;
                     }
                 }
-                Ok(()) => {
-                    if buf.filled().len() == filled {
-                        match ready!(self.inner.poll_action(cx)) {
-                            Some(action) => {
-                                self.inner.actions.push_back(action);
-                                continue;
-                            }
-                            None => {
-                                return Poll::Ready(Ok(()));
-                            }
+                Ok(0) => {
+                    // TODO: Extract
+                    match ready!(self.inner.poll_action(cx)) {
+                        Some(action) => {
+                            self.inner.actions.push_back(action);
+                            continue;
+                        }
+                        None => {
+                            return Poll::Ready(Ok(0));
                         }
-                    } else {
-                        return Poll::Ready(Ok(()));
                     }
                 }
-                Err(e) => return Poll::Ready(Err(e)),
+                ret => return Poll::Ready(ret),
             }
         }
     }
@@ -411,7 +404,7 @@ impl AsyncWrite for Mock {
                 Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
                     if let Some(rem) = self.inner.remaining_wait() {
                         let until = Instant::now() + rem;
-                        self.inner.sleep = Some(Box::pin(time::sleep_until(until)));
+                        self.inner.sleep = Some(time::delay_until(until));
                     } else {
                         panic!("unexpected WouldBlock");
                     }
@@ -441,6 +434,16 @@ impl AsyncWrite for Mock {
         }
     }
 
+    fn poll_write_buf<B: Buf>(
+        self: Pin<&mut Self>,
+        cx: &mut task::Context<'_>,
+        buf: &mut B,
+    ) -> Poll<io::Result<usize>> {
+        let n = ready!(self.poll_write(cx, buf.bytes()))?;
+        buf.advance(n);
+        Poll::Ready(Ok(n))
+    }
+
     fn poll_flush(self: Pin<&mut Self>, _cx: &mut task::Context<'_>) -> Poll<io::Result<()>> {
         Poll::Ready(Ok(()))
     }
@@ -450,21 +453,6 @@ impl AsyncWrite for Mock {
     }
 }
 
-/// Ensures that Mock isn't dropped with data "inside".
-impl Drop for Mock {
-    fn drop(&mut self) {
-        // Avoid double panicking, since makes debugging much harder.
-        if std::thread::panicking() {
-            return;
-        }
-
-        self.inner.actions.iter().for_each(|a| match a {
-            Action::Read(data) => assert!(data.is_empty(), "There is still data left to read."),
-            Action::Write(data) => assert!(data.is_empty(), "There is still data left to write."),
-            _ => (),
-        })
-    }
-}
 /*
 /// Returns `true` if called from the context of a futures-rs Task
 fn is_task_ctx() -> bool {
@@ -486,9 +474,3 @@ fn is_task_ctx() -> bool {
     r
 }
 */
-
-impl fmt::Debug for Inner {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "Inner {{...}}")
-    }
-}

tokio-test/src/lib.rs

@@ -1,3 +1,4 @@
+#![doc(html_root_url = "https://docs.rs/tokio-test/0.2.1")]
 #![warn(
     missing_debug_implementations,
     missing_docs,
@@ -21,13 +22,14 @@ pub mod task;
 /// future completes.
 ///
 /// For more information, see the documentation for
-/// [`tokio::runtime::Runtime::block_on`][runtime-block-on].
+/// [`tokio::runtime::current_thread::Runtime::block_on`][runtime-block-on].
 ///
-/// [runtime-block-on]: https://docs.rs/tokio/1.3.0/tokio/runtime/struct.Runtime.html#method.block_on
+/// [runtime-block-on]: https://docs.rs/tokio/0.2.0-alpha.2/tokio/runtime/current_thread/struct.Runtime.html#method.block_on
 pub fn block_on<F: std::future::Future>(future: F) -> F::Output {
     use tokio::runtime;
 
-    let rt = runtime::Builder::new_current_thread()
+    let mut rt = runtime::Builder::new()
+        .basic_scheduler()
         .enable_all()
         .build()
         .unwrap();

tokio-test/src/macros.rs

@@ -259,37 +259,3 @@ macro_rules! assert_err {
         }
     }};
 }
-
-/// Asserts that an exact duration has elapsed since since the start instant ±1ms.
-///
-/// ```rust
-/// use tokio::time::{self, Instant};
-/// use std::time::Duration;
-/// use tokio_test::assert_elapsed;
-/// # async fn test_time_passed() {
-///
-/// let start = Instant::now();
-/// let dur = Duration::from_millis(50);
-/// time::sleep(dur).await;
-/// assert_elapsed!(start, dur);
-/// # }
-/// ```
-///
-/// This 1ms buffer is required because Tokio's hashed-wheel timer has finite time resolution and
-/// will not always sleep for the exact interval.
-#[macro_export]
-macro_rules! assert_elapsed {
-    ($start:expr, $dur:expr) => {{
-        let elapsed = $start.elapsed();
-        // type ascription improves compiler error when wrong type is passed
-        let lower: std::time::Duration = $dur;
-
-        // Handles ms rounding
-        assert!(
-            elapsed >= lower && elapsed <= lower + std::time::Duration::from_millis(1),
-            "actual = {:?}, expected = {:?}",
-            elapsed,
-            lower
-        );
-    }};
-}

tokio-test/src/task.rs

@@ -9,9 +9,9 @@ use std::pin::Pin;
 use std::sync::{Arc, Condvar, Mutex};
 use std::task::{Context, Poll, RawWaker, RawWakerVTable, Waker};
 
-use tokio_stream::Stream;
+use tokio::stream::Stream;
 
-/// TODO: dox
+/// TOOD: dox
 pub fn spawn<T>(task: T) -> Spawn<T> {
     Spawn {
         task: MockTask::new(),

tokio-test/tests/block_on.rs

@@ -1,6 +1,6 @@
 #![warn(rust_2018_idioms)]
 
-use tokio::time::{sleep_until, Duration, Instant};
+use tokio::time::{delay_until, Duration, Instant};
 use tokio_test::block_on;
 
 #[test]
@@ -18,10 +18,10 @@ fn async_fn() {
 }
 
 #[test]
-fn test_sleep() {
+fn test_delay() {
     let deadline = Instant::now() + Duration::from_millis(100);
 
     block_on(async {
-        sleep_until(deadline).await;
+        delay_until(deadline).await;
     });
 }

tokio-test/tests/io.rs

@@ -70,17 +70,3 @@ async fn write_error() {
 
     mock.write_all(b"world!").await.expect("write 2");
 }
-
-#[tokio::test]
-#[should_panic]
-async fn mock_panics_read_data_left() {
-    use tokio_test::io::Builder;
-    Builder::new().read(b"read").build();
-}
-
-#[tokio::test]
-#[should_panic]
-async fn mock_panics_write_data_left() {
-    use tokio_test::io::Builder;
-    Builder::new().write(b"write").build();
-}

tokio-util/CHANGELOG.md

@@ -1,102 +1,3 @@
-# 0.6.6 (April 12, 2021)
-
-### Added
-
-- util: makes `Framed` and `FramedStream` resumable after eof ([#3272])
-- util: add `PollSemaphore::{add_permits, available_permits}` ([#3683])
-
-### Fixed
-
-- chore: avoid allocation if `PollSemaphore` is unused ([#3634])
-
-[#3272]: https://github.com/tokio-rs/tokio/pull/3272
-[#3634]: https://github.com/tokio-rs/tokio/pull/3634
-[#3683]: https://github.com/tokio-rs/tokio/pull/3683
-
-# 0.6.5 (March 20, 2021)
-
-### Fixed
-
-- util: annotate time module as requiring `time` feature ([#3606])
-
-[#3606]: https://github.com/tokio-rs/tokio/pull/3606
-
-# 0.6.4 (March 9, 2021)
-
-### Added
-
-- codec: `AnyDelimiter` codec ([#3406])
-- sync: add pollable `mpsc::Sender` ([#3490])
-
-### Fixed
-
-- codec: `LinesCodec` should only return `MaxLineLengthExceeded` once per line ([#3556])
-- sync: fuse PollSemaphore ([#3578])
-
-[#3406]: https://github.com/tokio-rs/tokio/pull/3406
-[#3490]: https://github.com/tokio-rs/tokio/pull/3490
-[#3556]: https://github.com/tokio-rs/tokio/pull/3556
-[#3578]: https://github.com/tokio-rs/tokio/pull/3578
-
-# 0.6.3 (January 31, 2021)
-
-### Added
-
-- sync: add `ReusableBoxFuture` utility ([#3464])
-
-### Changed
-
-- sync: use `ReusableBoxFuture` for `PollSemaphore` ([#3463])
-- deps: remove `async-stream` dependency ([#3463])
-- deps: remove `tokio-stream` dependency ([#3487])
-
-# 0.6.2 (January 21, 2021)
-
-### Added
-
-- sync: add pollable `Semaphore` ([#3444])
-
-### Fixed
-
-- time: fix panics on updating `DelayQueue` entries ([#3270])
-
-# 0.6.1 (January 12, 2021)
-
-### Added
-
-- codec: `get_ref()`, `get_mut()`, `get_pin_mut()` and `into_inner()` for
-  `Framed`, `FramedRead`, `FramedWrite` and `StreamReader` ([#3364]).
-- codec: `write_buffer()` and `write_buffer_mut()` for `Framed` and
-  `FramedWrite` ([#3387]).
-
-# 0.6.0 (December 23, 2020)
-
-### Changed
-- depend on `tokio` 1.0.
-
-### Added
-- rt: add constructors to `TokioContext` (#3221).
-
-# 0.5.1 (December 3, 2020)
-
-### Added
-- io: `poll_read_buf` util fn (#2972).
-- io: `poll_write_buf` util fn with vectored write support (#3156).
-
-# 0.5.0 (October 30, 2020)
-
-### Changed
-- io: update `bytes` to 0.6 (#3071).
-
-# 0.4.0 (October 15, 2020)
-
-### Added
-- sync: `CancellationToken` for coordinating task cancellation (#2747).
-- rt: `TokioContext` sets the Tokio runtime for the duration of a future (#2791)
-- io: `StreamReader`/`ReaderStream` map between `AsyncRead` values and `Stream`
-  of bytes (#2788).
-- time: `DelayQueue` to manage many delays (#2897).
-
 # 0.3.1 (March 18, 2020)
 
 ### Fixed
@@ -124,13 +25,6 @@
 
 - Initial release
 
-[#3487]: https://github.com/tokio-rs/tokio/pull/3487
-[#3464]: https://github.com/tokio-rs/tokio/pull/3464
-[#3463]: https://github.com/tokio-rs/tokio/pull/3463
-[#3444]: https://github.com/tokio-rs/tokio/pull/3444
-[#3387]: https://github.com/tokio-rs/tokio/pull/3387
-[#3364]: https://github.com/tokio-rs/tokio/pull/3364
-[#3270]: https://github.com/tokio-rs/tokio/pull/3270
 [#2326]: https://github.com/tokio-rs/tokio/pull/2326
 [#2215]: https://github.com/tokio-rs/tokio/pull/2215
 [#2198]: https://github.com/tokio-rs/tokio/pull/2198

tokio-util/Cargo.toml

@@ -2,17 +2,18 @@
 name = "tokio-util"
 # When releasing to crates.io:
 # - Remove path dependencies
+# - Update html_root_url.
 # - Update doc url
 #   - Cargo.toml
 # - Update CHANGELOG.md.
-# - Create "tokio-util-0.6.x" git tag.
-version = "0.6.6"
+# - Create "v0.2.x" git tag.
+version = "0.3.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-util/0.6.6/tokio_util"
+documentation = "https://docs.rs/tokio-util/0.3.1/tokio_util"
 description = """
 Additional utilities for working with Tokio.
 """
@@ -23,37 +24,27 @@ categories = ["asynchronous"]
 default = []
 
 # Shorthand for enabling everything
-full = ["codec", "compat", "io", "time", "net", "rt"]
+full = ["codec", "udp", "compat"]
 
-net = ["tokio/net"]
 compat = ["futures-io",]
-codec = []
-time = ["tokio/time","slab"]
-io = []
-rt = ["tokio/rt"]
-
-__docs_rs = ["futures-util"]
+codec = ["tokio/stream"]
+udp = ["tokio/udp"]
 
 [dependencies]
-tokio = { version = "1.0.0", path = "../tokio", features = ["sync"] }
+tokio = { version = "0.2.5", path = "../tokio" }
 
-bytes = "1.0.0"
+bytes = "0.5.0"
 futures-core = "0.3.0"
 futures-sink = "0.3.0"
 futures-io = { version = "0.3.0", optional = true }
-futures-util = { version = "0.3.0", optional = true }
 log = "0.4"
-pin-project-lite = "0.2.0"
-slab = { version = "0.4.1", optional = true } # Backs `DelayQueue`
+pin-project-lite = "0.1.4"
 
 [dev-dependencies]
-tokio = { version = "1.0.0", path = "../tokio", features = ["full"] }
-tokio-test = { version = "0.4.0", path = "../tokio-test" }
-tokio-stream = { version = "0.1", path = "../tokio-stream" }
+tokio = { version = "0.2.0", path = "../tokio", features = ["full"] }
+tokio-test = { version = "0.2.0", path = "../tokio-test" }
 
-async-stream = "0.3.0"
 futures = "0.3.0"
-futures-test = "0.3.5"
 
 [package.metadata.docs.rs]
 all-features = true

tokio-util/LICENSE

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

tokio-util/src/cfg.rs

@@ -18,41 +18,11 @@ macro_rules! cfg_compat {
     }
 }
 
-macro_rules! cfg_net {
+macro_rules! cfg_udp {
     ($($item:item)*) => {
         $(
-            #[cfg(all(feature = "net", feature = "codec"))]
-            #[cfg_attr(docsrs, doc(cfg(all(feature = "net", feature = "codec"))))]
-            $item
-        )*
-    }
-}
-
-macro_rules! cfg_io {
-    ($($item:item)*) => {
-        $(
-            #[cfg(feature = "io")]
-            #[cfg_attr(docsrs, doc(cfg(feature = "io")))]
-            $item
-        )*
-    }
-}
-
-macro_rules! cfg_rt {
-    ($($item:item)*) => {
-        $(
-            #[cfg(feature = "rt")]
-            #[cfg_attr(docsrs, doc(cfg(feature = "rt")))]
-            $item
-        )*
-    }
-}
-
-macro_rules! cfg_time {
-    ($($item:item)*) => {
-        $(
-            #[cfg(feature = "time")]
-            #[cfg_attr(docsrs, doc(cfg(feature = "time")))]
+            #[cfg(all(feature = "udp", feature = "codec"))]
+            #[cfg_attr(docsrs, doc(cfg(all(feature = "udp", feature = "codec"))))]
             $item
         )*
     }

tokio-util/src/codec/any_delimiter_codec.rs

@@ -1,263 +0,0 @@
-use crate::codec::decoder::Decoder;
-use crate::codec::encoder::Encoder;
-
-use bytes::{Buf, BufMut, Bytes, BytesMut};
-use std::{cmp, fmt, io, str, usize};
-
-const DEFAULT_SEEK_DELIMITERS: &[u8] = b",;\n\r";
-const DEFAULT_SEQUENCE_WRITER: &[u8] = b",";
-/// A simple [`Decoder`] and [`Encoder`] implementation that splits up data into chunks based on any character in the given delimiter string.
-///
-/// [`Decoder`]: crate::codec::Decoder
-/// [`Encoder`]: crate::codec::Encoder
-///
-/// # Example
-/// Decode string of bytes containing various different delimiters.
-///
-/// [`BytesMut`]: bytes::BytesMut
-/// [`Error`]: std::io::Error
-///
-/// ```
-/// use tokio_util::codec::{AnyDelimiterCodec, Decoder};
-/// use bytes::{BufMut, BytesMut};
-///
-/// #
-/// # #[tokio::main(flavor = "current_thread")]
-/// # async fn main() -> Result<(), std::io::Error> {
-/// let mut codec = AnyDelimiterCodec::new(b",;\r\n".to_vec(),b";".to_vec());
-/// let buf = &mut BytesMut::new();
-/// buf.reserve(200);
-/// buf.put_slice(b"chunk 1,chunk 2;chunk 3\n\r");
-/// assert_eq!("chunk 1", codec.decode(buf).unwrap().unwrap());
-/// assert_eq!("chunk 2", codec.decode(buf).unwrap().unwrap());
-/// assert_eq!("chunk 3", codec.decode(buf).unwrap().unwrap());
-/// assert_eq!("", codec.decode(buf).unwrap().unwrap());
-/// assert_eq!(None, codec.decode(buf).unwrap());
-/// # Ok(())
-/// # }
-/// ```
-///
-#[derive(Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
-pub struct AnyDelimiterCodec {
-    // Stored index of the next index to examine for the delimiter character.
-    // This is used to optimize searching.
-    // For example, if `decode` was called with `abc` and the delimiter is '{}', it would hold `3`,
-    // because that is the next index to examine.
-    // The next time `decode` is called with `abcde}`, the method will
-    // only look at `de}` before returning.
-    next_index: usize,
-
-    /// The maximum length for a given chunk. If `usize::MAX`, chunks will be
-    /// read until a delimiter character is reached.
-    max_length: usize,
-
-    /// Are we currently discarding the remainder of a chunk which was over
-    /// the length limit?
-    is_discarding: bool,
-
-    /// The bytes that are using for search during decode
-    seek_delimiters: Vec<u8>,
-
-    /// The bytes that are using for encoding
-    sequence_writer: Vec<u8>,
-}
-
-impl AnyDelimiterCodec {
-    /// Returns a `AnyDelimiterCodec` for splitting up data into chunks.
-    ///
-    /// # Note
-    ///
-    /// The returned `AnyDelimiterCodec` will not have an upper bound on the length
-    /// of a buffered chunk. See the documentation for [`new_with_max_length`]
-    /// for information on why this could be a potential security risk.
-    ///
-    /// [`new_with_max_length`]: crate::codec::AnyDelimiterCodec::new_with_max_length()
-    pub fn new(seek_delimiters: Vec<u8>, sequence_writer: Vec<u8>) -> AnyDelimiterCodec {
-        AnyDelimiterCodec {
-            next_index: 0,
-            max_length: usize::MAX,
-            is_discarding: false,
-            seek_delimiters,
-            sequence_writer,
-        }
-    }
-
-    /// Returns a `AnyDelimiterCodec` with a maximum chunk length limit.
-    ///
-    /// If this is set, calls to `AnyDelimiterCodec::decode` will return a
-    /// [`AnyDelimiterCodecError`] when a chunk exceeds the length limit. Subsequent calls
-    /// will discard up to `limit` bytes from that chunk until a delimiter
-    /// character is reached, returning `None` until the delimiter over the limit
-    /// has been fully discarded. After that point, calls to `decode` will
-    /// function as normal.
-    ///
-    /// # Note
-    ///
-    /// Setting a length limit is highly recommended for any `AnyDelimiterCodec` which
-    /// will be exposed to untrusted input. Otherwise, the size of the buffer
-    /// that holds the chunk currently being read is unbounded. An attacker could
-    /// exploit this unbounded buffer by sending an unbounded amount of input
-    /// without any delimiter characters, causing unbounded memory consumption.
-    ///
-    /// [`AnyDelimiterCodecError`]: crate::codec::AnyDelimiterCodecError
-    pub fn new_with_max_length(
-        seek_delimiters: Vec<u8>,
-        sequence_writer: Vec<u8>,
-        max_length: usize,
-    ) -> Self {
-        AnyDelimiterCodec {
-            max_length,
-            ..AnyDelimiterCodec::new(seek_delimiters, sequence_writer)
-        }
-    }
-
-    /// Returns the maximum chunk length when decoding.
-    ///
-    /// ```
-    /// use std::usize;
-    /// use tokio_util::codec::AnyDelimiterCodec;
-    ///
-    /// let codec = AnyDelimiterCodec::new(b",;\n".to_vec(), b";".to_vec());
-    /// assert_eq!(codec.max_length(), usize::MAX);
-    /// ```
-    /// ```
-    /// use tokio_util::codec::AnyDelimiterCodec;
-    ///
-    /// let codec = AnyDelimiterCodec::new_with_max_length(b",;\n".to_vec(), b";".to_vec(), 256);
-    /// assert_eq!(codec.max_length(), 256);
-    /// ```
-    pub fn max_length(&self) -> usize {
-        self.max_length
-    }
-}
-
-impl Decoder for AnyDelimiterCodec {
-    type Item = Bytes;
-    type Error = AnyDelimiterCodecError;
-
-    fn decode(&mut self, buf: &mut BytesMut) -> Result<Option<Bytes>, AnyDelimiterCodecError> {
-        loop {
-            // Determine how far into the buffer we'll search for a delimiter. If
-            // there's no max_length set, we'll read to the end of the buffer.
-            let read_to = cmp::min(self.max_length.saturating_add(1), buf.len());
-
-            let new_chunk_offset = buf[self.next_index..read_to].iter().position(|b| {
-                self.seek_delimiters
-                    .iter()
-                    .any(|delimiter| *b == *delimiter)
-            });
-
-            match (self.is_discarding, new_chunk_offset) {
-                (true, Some(offset)) => {
-                    // If we found a new chunk, discard up to that offset and
-                    // then stop discarding. On the next iteration, we'll try
-                    // to read a chunk normally.
-                    buf.advance(offset + self.next_index + 1);
-                    self.is_discarding = false;
-                    self.next_index = 0;
-                }
-                (true, None) => {
-                    // Otherwise, we didn't find a new chunk, so we'll discard
-                    // everything we read. On the next iteration, we'll continue
-                    // discarding up to max_len bytes unless we find a new chunk.
-                    buf.advance(read_to);
-                    self.next_index = 0;
-                    if buf.is_empty() {
-                        return Ok(None);
-                    }
-                }
-                (false, Some(offset)) => {
-                    // Found a chunk!
-                    let new_chunk_index = offset + self.next_index;
-                    self.next_index = 0;
-                    let mut chunk = buf.split_to(new_chunk_index + 1);
-                    chunk.truncate(chunk.len() - 1);
-                    let chunk = chunk.freeze();
-                    return Ok(Some(chunk));
-                }
-                (false, None) if buf.len() > self.max_length => {
-                    // Reached the maximum length without finding a
-                    // new chunk, return an error and start discarding on the
-                    // next call.
-                    self.is_discarding = true;
-                    return Err(AnyDelimiterCodecError::MaxChunkLengthExceeded);
-                }
-                (false, None) => {
-                    // We didn't find a chunk or reach the length limit, so the next
-                    // call will resume searching at the current offset.
-                    self.next_index = read_to;
-                    return Ok(None);
-                }
-            }
-        }
-    }
-
-    fn decode_eof(&mut self, buf: &mut BytesMut) -> Result<Option<Bytes>, AnyDelimiterCodecError> {
-        Ok(match self.decode(buf)? {
-            Some(frame) => Some(frame),
-            None => {
-                // return remaining data, if any
-                if buf.is_empty() {
-                    None
-                } else {
-                    let chunk = buf.split_to(buf.len());
-                    self.next_index = 0;
-                    Some(chunk.freeze())
-                }
-            }
-        })
-    }
-}
-
-impl<T> Encoder<T> for AnyDelimiterCodec
-where
-    T: AsRef<str>,
-{
-    type Error = AnyDelimiterCodecError;
-
-    fn encode(&mut self, chunk: T, buf: &mut BytesMut) -> Result<(), AnyDelimiterCodecError> {
-        let chunk = chunk.as_ref();
-        buf.reserve(chunk.len() + 1);
-        buf.put(chunk.as_bytes());
-        buf.put(self.sequence_writer.as_ref());
-
-        Ok(())
-    }
-}
-
-impl Default for AnyDelimiterCodec {
-    fn default() -> Self {
-        Self::new(
-            DEFAULT_SEEK_DELIMITERS.to_vec(),
-            DEFAULT_SEQUENCE_WRITER.to_vec(),
-        )
-    }
-}
-
-/// An error occured while encoding or decoding a chunk.
-#[derive(Debug)]
-pub enum AnyDelimiterCodecError {
-    /// The maximum chunk length was exceeded.
-    MaxChunkLengthExceeded,
-    /// An IO error occurred.
-    Io(io::Error),
-}
-
-impl fmt::Display for AnyDelimiterCodecError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            AnyDelimiterCodecError::MaxChunkLengthExceeded => {
-                write!(f, "max chunk length exceeded")
-            }
-            AnyDelimiterCodecError::Io(e) => write!(f, "{}", e),
-        }
-    }
-}
-
-impl From<io::Error> for AnyDelimiterCodecError {
-    fn from(e: io::Error) -> AnyDelimiterCodecError {
-        AnyDelimiterCodecError::Io(e)
-    }
-}
-
-impl std::error::Error for AnyDelimiterCodecError {}

tokio-util/src/codec/bytes_codec.rs

@@ -33,7 +33,7 @@ use std::io;
 /// #     }
 /// # }
 /// #
-/// # #[tokio::main(flavor = "current_thread")]
+/// # #[tokio::main(core_threads = 1)]
 /// # async fn main() -> Result<(), std::io::Error> {
 /// let my_async_read = File::open("filename.txt").await?;
 /// let my_stream_of_bytes = FramedRead::new(my_async_read, BytesCodec::new());

tokio-util/src/codec/decoder.rs

@@ -16,20 +16,6 @@ use std::io;
 /// implementing stateful streaming parsers. In many cases, though, this type
 /// will simply be a unit struct (e.g. `struct HttpDecoder`).
 ///
-/// For some underlying data-sources, namely files and FIFOs,
-/// it's possible to temporarily read 0 bytes by reaching EOF.
-///
-/// In these cases `decode_eof` will be called until it signals
-/// fullfillment of all closing frames by returning `Ok(None)`.
-/// After that, repeated attempts to read from the [`Framed`] or [`FramedRead`]
-/// will not invoke `decode` or `decode_eof` again, until data can be read
-/// during a retry.
-///
-/// It is up to the Decoder to keep track of a restart after an EOF,
-/// and to decide how to handle such an event by, for example,
-/// allowing frames to cross EOF boundaries, re-emitting opening frames, or
-/// reseting the entire internal state.
-///
 /// [`Framed`]: crate::codec::Framed
 /// [`FramedRead`]: crate::codec::FramedRead
 pub trait Decoder {
@@ -129,18 +115,13 @@ pub trait Decoder {
     /// This method defaults to calling `decode` and returns an error if
     /// `Ok(None)` is returned while there is unconsumed data in `buf`.
     /// Typically this doesn't need to be implemented unless the framing
-    /// protocol differs near the end of the stream, or if you need to construct
-    /// frames _across_ eof boundaries on sources that can be resumed.
+    /// protocol differs near the end of the stream.
     ///
     /// Note that the `buf` argument may be empty. If a previous call to
     /// `decode_eof` consumed all the bytes in the buffer, `decode_eof` will be
     /// called again until it returns `None`, indicating that there are no more
     /// frames to yield. This behavior enables returning finalization frames
     /// that may not be based on inbound data.
-    ///
-    /// Once `None` has been returned, `decode_eof` won't be called again until
-    /// an attempt to resume the stream has been made, where the underlying stream
-    /// actually returned more data.
     fn decode_eof(&mut self, buf: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
         match self.decode(buf)? {
             Some(frame) => Ok(Some(frame)),
@@ -172,7 +153,7 @@ pub trait Decoder {
     /// calling `split` on the [`Framed`] returned by this method, which will
     /// break them into separate objects, allowing them to interact more easily.
     ///
-    /// [`Stream`]: futures_core::Stream
+    /// [`Stream`]: tokio::stream::Stream
     /// [`Sink`]: futures_sink::Sink
     /// [`Framed`]: crate::codec::Framed
     fn framed<T: AsyncRead + AsyncWrite + Sized>(self, io: T) -> Framed<T, Self>

tokio-util/src/codec/framed.rs

@@ -2,8 +2,10 @@ use crate::codec::decoder::Decoder;
 use crate::codec::encoder::Encoder;
 use crate::codec::framed_impl::{FramedImpl, RWFrames, ReadFrame, WriteFrame};
 
-use futures_core::Stream;
-use tokio::io::{AsyncRead, AsyncWrite};
+use tokio::{
+    io::{AsyncRead, AsyncWrite},
+    stream::Stream,
+};
 
 use bytes::BytesMut;
 use futures_sink::Sink;
@@ -20,7 +22,7 @@ pin_project! {
     /// You can create a `Framed` instance by using the [`Decoder::framed`] adapter, or
     /// by using the `new` function seen below.
     ///
-    /// [`Stream`]: futures_core::Stream
+    /// [`Stream`]: tokio::stream::Stream
     /// [`Sink`]: futures_sink::Sink
     /// [`AsyncRead`]: tokio::io::AsyncRead
     /// [`Decoder::framed`]: crate::codec::Decoder::framed()
@@ -52,12 +54,7 @@ where
     /// calling [`split`] on the `Framed` returned by this method, which will
     /// break them into separate objects, allowing them to interact more easily.
     ///
-    /// Note that, for some byte sources, the stream can be resumed after an EOF
-    /// by reading from it, even after it has returned `None`. Repeated attempts
-    /// to do so, without new data available, continue to return `None` without
-    /// creating more (closing) frames.
-    ///
-    /// [`Stream`]: futures_core::Stream
+    /// [`Stream`]: tokio::stream::Stream
     /// [`Sink`]: futures_sink::Sink
     /// [`Decode`]: crate::codec::Decoder
     /// [`Encoder`]: crate::codec::Encoder
@@ -91,7 +88,7 @@ where
     /// calling [`split`] on the `Framed` returned by this method, which will
     /// break them into separate objects, allowing them to interact more easily.
     ///
-    /// [`Stream`]: futures_core::Stream
+    /// [`Stream`]: tokio::stream::Stream
     /// [`Sink`]: futures_sink::Sink
     /// [`Decode`]: crate::codec::Decoder
     /// [`Encoder`]: crate::codec::Encoder
@@ -136,7 +133,7 @@ impl<T, U> Framed<T, U> {
     /// calling [`split`] on the `Framed` returned by this method, which will
     /// break them into separate objects, allowing them to interact more easily.
     ///
-    /// [`Stream`]: futures_core::Stream
+    /// [`Stream`]: tokio::stream::Stream
     /// [`Sink`]: futures_sink::Sink
     /// [`Decoder`]: crate::codec::Decoder
     /// [`Encoder`]: crate::codec::Encoder
@@ -175,16 +172,6 @@ impl<T, U> Framed<T, U> {
         &mut self.inner.inner
     }
 
-    /// Returns a pinned mutable reference to the underlying I/O stream wrapped by
-    /// `Framed`.
-    ///
-    /// Note that care should be taken to not tamper with the underlying stream
-    /// of data coming in as it may corrupt the stream of frames otherwise
-    /// being worked with.
-    pub fn get_pin_mut(self: Pin<&mut Self>) -> Pin<&mut T> {
-        self.project().inner.project().inner
-    }
-
     /// Returns a reference to the underlying codec wrapped by
     /// `Framed`.
     ///
@@ -213,16 +200,6 @@ impl<T, U> Framed<T, U> {
         &mut self.inner.state.read.buffer
     }
 
-    /// Returns a reference to the write buffer.
-    pub fn write_buffer(&self) -> &BytesMut {
-        &self.inner.state.write.buffer
-    }
-
-    /// Returns a mutable reference to the write buffer.
-    pub fn write_buffer_mut(&mut self) -> &mut BytesMut {
-        &mut self.inner.state.write.buffer
-    }
-
     /// Consumes the `Framed`, returning its underlying I/O stream.
     ///
     /// Note that care should be taken to not tamper with the underlying stream

tokio-util/src/codec/framed_impl.rs

@@ -1,10 +1,12 @@
 use crate::codec::decoder::Decoder;
 use crate::codec::encoder::Encoder;
 
-use futures_core::Stream;
-use tokio::io::{AsyncRead, AsyncWrite};
+use tokio::{
+    io::{AsyncRead, AsyncWrite},
+    stream::Stream,
+};
 
-use bytes::BytesMut;
+use bytes::{Buf, BytesMut};
 use futures_core::ready;
 use futures_sink::Sink;
 use log::trace;
@@ -116,101 +118,44 @@ where
     type Item = Result<U::Item, U::Error>;
 
     fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        use crate::util::poll_read_buf;
-
         let mut pinned = self.project();
         let state: &mut ReadFrame = pinned.state.borrow_mut();
-        // The following loops implements a state machine with each state corresponding
-        // to a combination of the `is_readable` and `eof` flags. States persist across
-        // loop entries and most state transitions occur with a return.
-        //
-        // The intitial state is `reading`.
-        //
-        // | state   | eof   | is_readable |
-        // |---------|-------|-------------|
-        // | reading | false | false       |
-        // | framing | false | true        |
-        // | pausing | true  | true        |
-        // | paused  | true  | false       |
-        //
-        //                                 `decode_eof`
-        //                                 returns `Some`             read 0 bytes
-        //                                   │       │                 │      │
-        //                                   │       ▼                 │      ▼
-        //                                   ┌───────┐ `decode_eof`    ┌──────┐
-        //                 ┌──read 0 bytes──▶│pausing│─returns `None`─▶│paused│──┐
-        //                 │                 └───────┘                 └──────┘  │
-        // pending read┐   │                     ┌──────┐                  │  ▲  │
-        //      │      │   │                     │      │                  │  │  │
-        //      │      ▼   │                     │  `decode` returns `Some`│ pending read
-        //      │  ╔═══════╗                 ┌───────┐◀─┘                  │
-        //      └──║reading║─read n>0 bytes─▶│framing│                     │
-        //         ╚═══════╝                 └───────┘◀──────read n>0 bytes┘
-        //             ▲                         │
-        //             │                         │
-        //             └─`decode` returns `None`─┘
         loop {
-            // Repeatedly call `decode` or `decode_eof` while the buffer is "readable",
-            // i.e. it _might_ contain data consumable as a frame or closing frame.
-            // Both signal that there is no such data by returning `None`.
-            //
-            // If `decode` couldn't read a frame and the upstream source has returned eof,
-            // `decode_eof` will attemp to decode the remaining bytes as closing frames.
-            //
-            // If the underlying AsyncRead is resumable, we may continue after an EOF,
-            // but must finish emmiting all of it's associated `decode_eof` frames.
-            // Furthermore, we don't want to emit any `decode_eof` frames on retried
-            // reads after an EOF unless we've actually read more data.
+            // Repeatedly call `decode` or `decode_eof` as long as it is
+            // "readable". Readable is defined as not having returned `None`. If
+            // the upstream has returned EOF, and the decoder is no longer
+            // readable, it can be assumed that the decoder will never become
+            // readable again, at which point the stream is terminated.
             if state.is_readable {
-                // pausing or framing
                 if state.eof {
-                    // pausing
                     let frame = pinned.codec.decode_eof(&mut state.buffer)?;
-                    if frame.is_none() {
-                        state.is_readable = false; // prepare pausing -> paused
-                    }
-                    // implicit pausing -> pausing or pausing -> paused
                     return Poll::Ready(frame.map(Ok));
                 }
 
-                // framing
                 trace!("attempting to decode a frame");
 
                 if let Some(frame) = pinned.codec.decode(&mut state.buffer)? {
                     trace!("frame decoded from buffer");
-                    // implicit framing -> framing
                     return Poll::Ready(Some(Ok(frame)));
                 }
 
-                // framing -> reading
                 state.is_readable = false;
             }
-            // reading or paused
-            // If we can't build a frame yet, try to read more data and try again.
-            // Make sure we've got room for at least one byte to read to ensure
-            // that we don't get a spurious 0 that looks like EOF.
+
+            assert!(!state.eof);
+
+            // Otherwise, try to read more data and try again. Make sure we've
+            // got room for at least one byte to read to ensure that we don't
+            // get a spurious 0 that looks like EOF
             state.buffer.reserve(1);
-            let bytect = match poll_read_buf(pinned.inner.as_mut(), cx, &mut state.buffer)? {
+            let bytect = match pinned.inner.as_mut().poll_read_buf(cx, &mut state.buffer)? {
                 Poll::Ready(ct) => ct,
-                // implicit reading -> reading or implicit paused -> paused
                 Poll::Pending => return Poll::Pending,
             };
             if bytect == 0 {
-                if state.eof {
-                    // We're already at an EOF, and since we've reached this path
-                    // we're also not readable. This implies that we've already finished
-                    // our `decode_eof` handling, so we can simply return `None`.
-                    // implicit paused -> paused
-                    return Poll::Ready(None);
-                }
-                // prepare reading -> paused
                 state.eof = true;
-            } else {
-                // prepare paused -> framing or noop reading -> framing
-                state.eof = false;
             }
 
-            // paused -> framing or reading -> framing or reading -> pausing
             state.is_readable = true;
         }
     }
@@ -242,7 +187,6 @@ where
     }
 
     fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        use crate::util::poll_write_buf;
         trace!("flushing framed transport");
         let mut pinned = self.project();
 
@@ -250,7 +194,8 @@ where
             let WriteFrame { buffer } = pinned.state.borrow_mut();
             trace!("writing; remaining={}", buffer.len());
 
-            let n = ready!(poll_write_buf(pinned.inner.as_mut(), cx, buffer))?;
+            let buf = &buffer;
+            let n = ready!(pinned.inner.as_mut().poll_write(cx, &buf))?;
 
             if n == 0 {
                 return Poll::Ready(Err(io::Error::new(
@@ -260,6 +205,8 @@ where
                 )
                 .into()));
             }
+
+            pinned.state.borrow_mut().buffer.advance(n);
         }
 
         // Try flushing the underlying IO

tokio-util/src/codec/framed_read.rs

@@ -1,8 +1,7 @@
 use crate::codec::framed_impl::{FramedImpl, ReadFrame};
 use crate::codec::Decoder;
 
-use futures_core::Stream;
-use tokio::io::AsyncRead;
+use tokio::{io::AsyncRead, stream::Stream};
 
 use bytes::BytesMut;
 use futures_sink::Sink;
@@ -14,7 +13,7 @@ use std::task::{Context, Poll};
 pin_project! {
     /// A [`Stream`] of messages decoded from an [`AsyncRead`].
     ///
-    /// [`Stream`]: futures_core::Stream
+    /// [`Stream`]: tokio::stream::Stream
     /// [`AsyncRead`]: tokio::io::AsyncRead
     pub struct FramedRead<T, D> {
         #[pin]
@@ -78,16 +77,6 @@ impl<T, D> FramedRead<T, D> {
         &mut self.inner.inner
     }
 
-    /// Returns a pinned mutable reference to the underlying I/O stream wrapped by
-    /// `FramedRead`.
-    ///
-    /// Note that care should be taken to not tamper with the underlying stream
-    /// of data coming in as it may corrupt the stream of frames otherwise
-    /// being worked with.
-    pub fn get_pin_mut(self: Pin<&mut Self>) -> Pin<&mut T> {
-        self.project().inner.project().inner
-    }
-
     /// Consumes the `FramedRead`, returning its underlying I/O stream.
     ///
     /// Note that care should be taken to not tamper with the underlying stream
@@ -111,11 +100,6 @@ impl<T, D> FramedRead<T, D> {
     pub fn read_buffer(&self) -> &BytesMut {
         &self.inner.state.buffer
     }
-
-    /// Returns a mutable reference to the read buffer.
-    pub fn read_buffer_mut(&mut self) -> &mut BytesMut {
-        &mut self.inner.state.buffer
-    }
 }
 
 // This impl just defers to the underlying FramedImpl

tokio-util/src/codec/framed_write.rs

@@ -1,10 +1,8 @@
 use crate::codec::encoder::Encoder;
 use crate::codec::framed_impl::{FramedImpl, WriteFrame};
 
-use futures_core::Stream;
-use tokio::io::AsyncWrite;
+use tokio::{io::AsyncWrite, stream::Stream};
 
-use bytes::BytesMut;
 use futures_sink::Sink;
 use pin_project_lite::pin_project;
 use std::fmt;
@@ -59,16 +57,6 @@ impl<T, E> FramedWrite<T, E> {
         &mut self.inner.inner
     }
 
-    /// Returns a pinned mutable reference to the underlying I/O stream wrapped by
-    /// `FramedWrite`.
-    ///
-    /// Note that care should be taken to not tamper with the underlying stream
-    /// of data coming in as it may corrupt the stream of frames otherwise
-    /// being worked with.
-    pub fn get_pin_mut(self: Pin<&mut Self>) -> Pin<&mut T> {
-        self.project().inner.project().inner
-    }
-
     /// Consumes the `FramedWrite`, returning its underlying I/O stream.
     ///
     /// Note that care should be taken to not tamper with the underlying stream
@@ -87,16 +75,6 @@ impl<T, E> FramedWrite<T, E> {
     pub fn encoder_mut(&mut self) -> &mut E {
         &mut self.inner.codec
     }
-
-    /// Returns a reference to the write buffer.
-    pub fn write_buffer(&self) -> &BytesMut {
-        &self.inner.state.buffer
-    }
-
-    /// Returns a mutable reference to the write buffer.
-    pub fn write_buffer_mut(&mut self) -> &mut BytesMut {
-        &mut self.inner.state.buffer
-    }
 }
 
 // This impl just defers to the underlying FramedImpl

tokio-util/src/codec/length_delimited.rs

@@ -39,7 +39,7 @@
 //! Specifically, given the following:
 //!
 //! ```
-//! use tokio::io::{AsyncRead, AsyncWrite};
+//! use tokio::prelude::*;
 //! use tokio_util::codec::{Framed, LengthDelimitedCodec};
 //!
 //! use futures::SinkExt;
@@ -535,14 +535,14 @@ impl LengthDelimitedCodec {
         Ok(Some(n))
     }
 
-    fn decode_data(&self, n: usize, src: &mut BytesMut) -> Option<BytesMut> {
+    fn decode_data(&self, n: usize, src: &mut BytesMut) -> io::Result<Option<BytesMut>> {
         // At this point, the buffer has already had the required capacity
         // reserved. All there is to do is read.
         if src.len() < n {
-            return None;
+            return Ok(None);
         }
 
-        Some(src.split_to(n))
+        Ok(Some(src.split_to(n)))
     }
 }
 
@@ -562,7 +562,7 @@ impl Decoder for LengthDelimitedCodec {
             DecodeState::Data(n) => n,
         };
 
-        match self.decode_data(n, src) {
+        match self.decode_data(n, src)? {
             Some(data) => {
                 // Update the decode state
                 self.state = DecodeState::Head;