v0.1.x: prepare to release tokio-threadpool 0.1.17 (#1893)

0.1.17 (December 3, 2019)

Added
- Internal APIs for overriding blocking behavior (#1752)

Signed-off-by: Eliza Weisman <[email protected]>

.cargo/audit.toml

@@ -1,8 +0,0 @@
-# See https://github.com/rustsec/rustsec/blob/59e1d2ad0b9cbc6892c26de233d4925074b4b97b/cargo-audit/audit.toml.example for example.
-
-[advisories]
-ignore = [
-    # We depend on nix 0.22 only via mio-aio, a dev-dependency.
-    # https://github.com/tokio-rs/tokio/pull/4255#issuecomment-974786349
-    "RUSTSEC-2021-0119",
-]

.cargo/config

@@ -1,2 +0,0 @@
-# [build]
-# rustflags = ["--cfg", "tokio_unstable"]

.circleci/config.yml

@@ -1,25 +0,0 @@
-version: 2.1        
-jobs:
-  test-arm:
-    machine:
-      image: ubuntu-2004:202101-01
-    resource_class: arm.medium
-    environment:
-      # Change to pin rust version
-      RUST_STABLE: 1.60.0
-    steps:
-      - checkout
-      - run:
-          name: Install Rust
-          command: |
-            curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs -o rustup.sh
-            chmod +x rustup.sh
-            ./rustup.sh -y --default-toolchain $RUST_STABLE
-            source "$HOME"/.cargo/env
-      # Only run Tokio tests
-      - run: cargo test --all-features -p tokio
-
-workflows:
-  ci:
-    jobs:
-      - test-arm

.cirrus.yml

@@ -1,56 +1,41 @@
 freebsd_instance:
-  image: freebsd-12-3-release-amd64
-env:
-  RUST_STABLE: 1.60.0
-  RUST_NIGHTLY: nightly-2022-03-21
-  RUSTFLAGS: -D warnings
+  image: freebsd-12-0-release-amd64
 
 # Test FreeBSD in a full VM on cirrus-ci.com.  Test the i686 target too, in the
 # same VM.  The binary will be built in 32-bit mode, but will execute on a
 # 64-bit kernel and in a 64-bit environment.  Our tests don't execute any of
 # the system's binaries, so the environment shouldn't matter.
 task:
-  name: FreeBSD 64-bit
-  setup_script:
-    - pkg install -y bash curl
-    - curl https://sh.rustup.rs -sSf --output rustup.sh
-    - sh rustup.sh -y --profile minimal --default-toolchain $RUST_STABLE
-    - . $HOME/.cargo/env
-    - |
-      echo "~~~~ rustc --version ~~~~"
-      rustc --version
-  test_script:
-    - . $HOME/.cargo/env
-    - cargo test --all --all-features
-
-task:
-  name: FreeBSD docs
+  name: FreeBSD 12.0
   env:
-    RUSTFLAGS: --cfg docsrs --cfg tokio_unstable
-    RUSTDOCFLAGS: --cfg docsrs --cfg tokio_unstable -Dwarnings
+    LOOM_MAX_DURATION: 10
   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 $RUST_NIGHTLY
-    - . $HOME/.cargo/env
-    - |
-      echo "~~~~ rustc --version ~~~~"
-      rustc --version
-  test_script:
-    - . $HOME/.cargo/env
-    - cargo doc --lib --no-deps --all-features --document-private-items
-
-task:
-  name: FreeBSD 32-bit
-  setup_script:
-    - pkg install -y bash curl
-    - curl https://sh.rustup.rs -sSf --output rustup.sh
-    - sh rustup.sh -y --profile minimal --default-toolchain $RUST_STABLE
+    - sh rustup.sh -y
     - . $HOME/.cargo/env
     - rustup target add i686-unknown-freebsd
     - |
-      echo "~~~~ rustc --version ~~~~"
-      rustc --version
+      # Remove any existing patch statements
+      mv Cargo.toml Cargo.toml.bck
+      sed -n '/\[patch.crates-io\]/q;p' Cargo.toml.bck > Cargo.toml
+
+      # Patch all crates
+      cat ci/patch.toml >> Cargo.toml
+
+      # Print `Cargo.toml` for debugging
+      echo "~~~~ Cargo.toml ~~~~"
+      cat Cargo.toml
+      echo "~~~~~~~~~~~~~~~~~~~~"
+  cargo_cache:
+    folder: $HOME/.cargo/registry
   test_script:
     - . $HOME/.cargo/env
-    - cargo test --all --all-features --target i686-unknown-freebsd
+    - cargo test --all
+    - cargo doc --all
+  i686_test_script:
+    - . $HOME/.cargo/env
+    - |
+      cargo test --all --exclude tokio-tls --exclude tokio-macros --target i686-unknown-freebsd
+  before_cache_script:
+    - rm -rf $HOME/.cargo/registry/index

.clippy.toml

@@ -1 +0,0 @@
-msrv = "1.49"

.github/FUNDING.yml

@@ -1,3 +0,0 @@
-# These are supported funding model platforms
-
-github: [tokio-rs]

.github/ISSUE_TEMPLATE.md

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

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,31 +0,0 @@
----
-name: Bug report
-about: Create a report to help us improve
-title: ''
-labels: A-tokio, C-bug
-assignees: ''
-
----
-
-**Version**
-List the versions of all `tokio` crates you are using. The easiest way to get
-this information is using `cargo tree` subcommand:
-
-`cargo tree | grep tokio`
-
-**Platform**
-The output of `uname -a` (UNIX), or version and 32 or 64-bit (Windows)
-
-**Description**
-Enter your issue details here.
-One way to structure the description:
-
-[short summary of the bug]
-
-I tried this code:
-
-[code sample that causes the bug]
-
-I expected to see this happen: [explanation]
-
-Instead, this happened: [explanation]

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,20 +0,0 @@
----
-name: Feature request
-about: Suggest an idea for this project
-title: ''
-labels: A-tokio, C-feature-request
-assignees: ''
-
----
-
-**Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-
-**Describe the solution you'd like**
-A clear and concise description of what you want to happen.
-
-**Describe alternatives you've considered**
-A clear and concise description of any alternative solutions or features you've considered.
-
-**Additional context**
-Add any other context or screenshots about the feature request here.

.github/ISSUE_TEMPLATE/question.md

@@ -1,16 +0,0 @@
----
-name: Question
-about: Please use the discussions tab for questions
-title: ''
-labels: ''
-assignees: ''
-
----
-
-Please post your question as a discussion here:
-https://github.com/tokio-rs/tokio/discussions
-
-
-You may also be able to find help here:
-https://discord.gg/tokio
-https://users.rust-lang.org/

.github/PULL_REQUEST_TEMPLATE.md

@@ -5,9 +5,6 @@ the requirements below.
 Bug fixes and new features should include tests.
 
 Contributors guide: https://github.com/tokio-rs/tokio/blob/master/CONTRIBUTING.md
-
-The contributors guide includes instructions for running rustfmt and building the
-documentation, which requires special commands beyond `cargo fmt` and `cargo doc`.
 -->
 
 ## Motivation

.github/labeler.yml

@@ -1,8 +0,0 @@
-
-R-loom:
-- tokio/src/sync/*
-- tokio/src/sync/**/*
-- tokio-util/src/sync/*
-- tokio-util/src/sync/**/*
-- tokio/src/runtime/*
-- tokio/src/runtime/**/*

.github/workflows/audit.yml

@@ -1,22 +0,0 @@
-name: Security Audit
-
-on:
-  push:
-    branches:
-      - master
-    paths:
-      - '**/Cargo.toml'
-  schedule:
-    - cron: '0 2 * * *' # run at 2 AM UTC
-
-jobs:
-  security-audit:
-    runs-on: ubuntu-latest
-    if: "!contains(github.event.head_commit.message, 'ci skip')"
-    steps:
-      - uses: actions/checkout@v2
-
-      - name: Audit Check
-        uses: actions-rs/audit-check@v1
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/ci.yml

@@ -1,438 +0,0 @@
-on:
-  push:
-    branches: ["master", "tokio-*.x"]
-  pull_request:
-    branches: ["master", "tokio-*.x"]
-
-name: CI
-
-env:
-  RUSTFLAGS: -Dwarnings
-  RUST_BACKTRACE: 1
-  # Change to specific Rust release to pin
-  rust_stable: 1.60.0
-  rust_nightly: nightly-2022-03-21
-  rust_clippy: 1.56.0
-  rust_min: 1.49.0
-
-defaults:
-  run:
-    shell: bash
-
-jobs:
-  # Depends on all action sthat are required for a "successful" CI run.
-  tests-pass:
-    name: all systems go
-    runs-on: ubuntu-latest
-    needs:
-      - test
-      - test-unstable
-      - test-parking_lot
-      - miri
-      - cross
-      - features
-      - minrust
-      - fmt
-      - docs
-      - valgrind
-      - loom-compile
-      - check-readme
-      - test-hyper
-      - wasm32-unknown-unknown
-    steps:
-      - run: exit 0
-
-  test:
-    name: test tokio full
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os:
-          - windows-latest
-          - ubuntu-latest
-          - macos-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Install Rust ${{ env.rust_stable }}
-        uses: actions-rs/toolchain@v1
-        with:
-            toolchain: ${{ env.rust_stable }}
-            override: true
-      - name: Install Rust
-        run: rustup update stable
-      - uses: Swatinem/rust-cache@v1
-      - name: Install cargo-hack
-        run: cargo install cargo-hack
-
-      # Run `tokio` with `full` features. This excludes testing utilities which
-      # can alter the runtime behavior of Tokio.
-      - name: test tokio full
-        run: cargo test --features full
-        working-directory: tokio
-
-      # Test **all** crates in the workspace with all features.
-      - name: test all --all-features
-        run: cargo test --workspace --all-features
-
-      # Run integration tests for each feature
-      - name: test tests-integration --each-feature
-        run: cargo hack test --each-feature
-        working-directory: tests-integration
-
-      # Run macro build tests
-      - name: test tests-build --each-feature
-        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')
-
-  test-parking_lot:
-    # The parking_lot crate has a feature called send_guard which changes when
-    # some of its types are Send. Tokio has some measures in place to prevent
-    # this from affecting when Tokio types are Send, and this test exists to
-    # ensure that those measures are working.
-    #
-    # This relies on the potentially affected Tokio type being listed in
-    # `tokio/tokio/tests/async_send_sync.rs`.
-    name: compile tests with parking lot send guards
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Install Rust ${{ env.rust_stable }}
-        uses: actions-rs/toolchain@v1
-        with:
-            toolchain: ${{ env.rust_stable }}
-            override: true
-      - uses: Swatinem/rust-cache@v1
-      - name: Enable parking_lot send_guard feature
-        # Inserts the line "plsend = ["parking_lot/send_guard"]" right after [features]
-        run: sed -i '/\[features\]/a plsend = ["parking_lot/send_guard"]' tokio/Cargo.toml
-      - name: Compile tests with all features enabled
-        run: cargo build --workspace --all-features --tests
-
-  valgrind:
-    name: valgrind
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Install Rust ${{ env.rust_stable }}
-        uses: actions-rs/toolchain@v1
-        with:
-            toolchain: ${{ env.rust_stable }}
-            override: true
-      - uses: Swatinem/rust-cache@v1
-
-      - 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 --error-exitcode=1 --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 --error-exitcode=1 --leak-check=full --show-leak-kinds=all ./target/debug/test-process-signal
-
-  test-unstable:
-    name: test tokio full --unstable
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os:
-          - windows-latest
-          - ubuntu-latest
-          - macos-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Install Rust ${{ env.rust_stable }}
-        uses: actions-rs/toolchain@v1
-        with:
-            toolchain: ${{ env.rust_stable }}
-            override: true
-      - uses: Swatinem/rust-cache@v1
-      # Run `tokio` with "unstable" cfg flag.
-      - name: test tokio full --cfg unstable
-        run: cargo test --all-features
-        working-directory: tokio
-        env:
-          RUSTFLAGS: --cfg tokio_unstable -Dwarnings
-          # in order to run doctests for unstable features, we must also pass
-          # the unstable cfg to RustDoc
-          RUSTDOCFLAGS: --cfg tokio_unstable
-
-  miri:
-    name: miri
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Install Rust ${{ env.rust_nightly }}
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: ${{ env.rust_nightly }}
-          components: miri
-          override: true
-      - uses: Swatinem/rust-cache@v1
-      - name: miri
-        # Many of tests in tokio/tests and doctests use #[tokio::test] or
-        # #[tokio::main] that calls epoll_create1 that Miri does not support.
-        run: cargo miri test --features full --lib --no-fail-fast
-        working-directory: tokio
-        env:
-          MIRIFLAGS: -Zmiri-disable-isolation -Zmiri-tag-raw-pointers
-          PROPTEST_CASES: 10
-
-  san:
-    name: san
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Install Rust ${{ env.rust_nightly }}
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: ${{ env.rust_nightly }}
-          override: true
-      - uses: Swatinem/rust-cache@v1
-      - 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
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        target:
-          - i686-unknown-linux-gnu
-          - powerpc-unknown-linux-gnu
-          - powerpc64-unknown-linux-gnu
-          - mips-unknown-linux-gnu
-          - arm-linux-androideabi
-          - mipsel-unknown-linux-musl
-    steps:
-      - uses: actions/checkout@v2
-      - name: Install Rust ${{ env.rust_stable }}
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: ${{ env.rust_stable }}
-          target: ${{ matrix.target }}
-          override: true
-      - uses: Swatinem/rust-cache@v1
-      - uses: actions-rs/cargo@v1
-        with:
-          use-cross: true
-          command: check
-          args: --workspace --all-features --target ${{ matrix.target }}
-      - uses: actions-rs/cargo@v1
-        with:
-          use-cross: true
-          command: check
-          args: --workspace --all-features --target ${{ matrix.target }}
-        env:
-          RUSTFLAGS: --cfg tokio_unstable -Dwarnings
-
-  features:
-    name: features
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Install Rust ${{ env.rust_nightly }}
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: ${{ env.rust_nightly }}
-          target: ${{ matrix.target }}
-          override: true
-      - uses: Swatinem/rust-cache@v1
-      - name: Install cargo-hack
-        run: cargo install cargo-hack
-      - name: check --each-feature
-        run: cargo hack check --all --each-feature -Z avoid-dev-deps
-      # Try with unstable feature flags
-      - name: check --each-feature --unstable
-        run: cargo hack check --all --each-feature -Z avoid-dev-deps
-        env:
-          RUSTFLAGS: --cfg tokio_unstable -Dwarnings
-
-  minrust:
-    name: minrust
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Install Rust ${{ env.rust_min }}
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: ${{ env.rust_min }}
-          override: true
-      - uses: Swatinem/rust-cache@v1
-      - name: "test --all-features"
-        run: cargo check --all-features
-        working-directory: tokio
-
-  minimal-versions:
-    name: minimal-versions
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Install Rust ${{ env.rust_nightly }}
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: ${{ env.rust_nightly }}
-          override: true
-      - uses: Swatinem/rust-cache@v1
-      - 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 hack check --all-features --ignore-private
-      - name: "check --all-features --unstable -Z minimal-versions"
-        env:
-          RUSTFLAGS: --cfg tokio_unstable -Dwarnings
-        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 hack check --all-features --ignore-private
-
-  fmt:
-    name: fmt
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Install Rust ${{ env.rust_stable }}
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: ${{ env.rust_stable }}
-          override: true
-          components: rustfmt
-      - uses: Swatinem/rust-cache@v1
-      # Check fmt
-      - name: "rustfmt --check"
-        # Workaround for rust-lang/cargo#7732
-        run: |
-          if ! rustfmt --check --edition 2018 $(git ls-files '*.rs'); then
-            printf "Please run \`rustfmt --edition 2018 \$(git ls-files '*.rs')\` to fix rustfmt errors.\nSee CONTRIBUTING.md for more details.\n" >&2
-            exit 1
-          fi
-
-  docs:
-    name: docs
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Install Rust ${{ env.rust_nightly }}
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: ${{ env.rust_nightly }}
-          override: true
-      - uses: Swatinem/rust-cache@v1
-      - name: "doc --lib --all-features"
-        run: cargo doc --lib --no-deps --all-features --document-private-items
-        env:
-          RUSTFLAGS: --cfg docsrs --cfg tokio_unstable
-          RUSTDOCFLAGS: --cfg docsrs --cfg tokio_unstable -Dwarnings
-
-  loom-compile:
-    name: build loom tests
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Install Rust ${{ env.rust_stable }}
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: ${{ env.rust_stable }}
-          override: true
-      - uses: Swatinem/rust-cache@v1
-      - name: build --cfg loom
-        run: cargo test --no-run --lib --features full
-        working-directory: tokio
-        env:
-          RUSTFLAGS: --cfg loom --cfg tokio_unstable -Dwarnings
-
-  check-readme:
-    name: Check README
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Verify that both READMEs are identical
-        run: diff README.md tokio/README.md
-
-      - name: Verify that Tokio version is up to date in README
-        working-directory: tokio
-        run: grep -q "$(sed '/^version = /!d' Cargo.toml | head -n1)" README.md
-
-  test-hyper:
-    name: Test hyper
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os:
-          - windows-latest
-          - ubuntu-latest
-          - macos-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Install Rust ${{ env.rust_stable }}
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: ${{ env.rust_stable }}
-          override: true
-      - uses: Swatinem/rust-cache@v1
-      - name: Test hyper
-        run: |
-          set -x
-          git clone https://github.com/hyperium/hyper.git
-          cd hyper
-          # checkout the latest release because HEAD maybe contains breakage.
-          tag=$(git describe --abbrev=0 --tags)
-          git checkout "${tag}"
-          echo '[workspace]' >>Cargo.toml
-          echo '[patch.crates-io]' >>Cargo.toml
-          echo 'tokio = { path = "../tokio" }' >>Cargo.toml
-          echo 'tokio-util = { path = "../tokio-util" }' >>Cargo.toml
-          echo 'tokio-stream = { path = "../tokio-stream" }' >>Cargo.toml
-          echo 'tokio-test = { path = "../tokio-test" }' >>Cargo.toml
-          git diff
-          cargo test --features full
-
-  wasm32-unknown-unknown:
-    name: test tokio for wasm32-unknown-unknown
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Install Rust ${{ env.rust_stable }}
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: ${{ env.rust_stable }}
-          override: true
-      - uses: Swatinem/rust-cache@v1
-      - name: Install wasm-pack
-        run: curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
-      - name: test tokio
-        run: wasm-pack test --node -- --features "macros sync"
-        working-directory: tokio

.github/workflows/labeler.yml

@@ -1,14 +0,0 @@
-name: "Pull Request Labeler"
-on:
-- pull_request_target
-
-# See .github/labeler.yml file
-
-jobs:
-  triage:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/labeler@v3
-      with:
-        repo-token: "${{ secrets.GITHUB_TOKEN }}"
-        sync-labels: true

.github/workflows/loom.yml

@@ -1,45 +0,0 @@
-on:
-  push:
-    branches: ["master", "tokio-*.x"]
-  pull_request:
-    types: [labeled, opened, synchronize, reopened]
-    branches: ["master", "tokio-*.x"]
-
-name: Loom
-
-env:
-  RUSTFLAGS: -Dwarnings
-  RUST_BACKTRACE: 1
-  # Change to specific Rust release to pin
-  rust_stable: 1.60.0
-
-jobs:
-  loom:
-    name: loom
-    # base_ref is null when it's not a pull request
-    if: contains(github.event.pull_request.labels.*.name, 'R-loom') || (github.base_ref == null)
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        scope:
-          - --skip loom_pool
-          - loom_pool::group_a
-          - loom_pool::group_b
-          - loom_pool::group_c
-          - loom_pool::group_d
-          - time::driver
-    steps:
-      - uses: actions/checkout@v2
-      - name: Install Rust ${{ env.rust_stable }}
-        uses: actions-rs/toolchain@v1
-        with:
-            toolchain: ${{ env.rust_stable }}
-            override: true
-      - uses: Swatinem/rust-cache@v1
-      - name: loom ${{ matrix.scope }}
-        run: cargo test --lib --release --features full -- --nocapture $SCOPE
-        working-directory: tokio
-        env:
-          RUSTFLAGS: --cfg loom --cfg tokio_unstable -Dwarnings
-          LOOM_MAX_PREEMPTIONS: 2
-          SCOPE: ${{ matrix.scope }}

.github/workflows/pr-audit.yml

@@ -1,32 +0,0 @@
-name: Pull Request Security Audit
-
-on:
-  push:
-    paths:
-      - '**/Cargo.toml'
-  pull_request:
-    paths:
-      - '**/Cargo.toml'
-
-jobs:
-  security-audit:
-    runs-on: ubuntu-latest
-    if: "!contains(github.event.head_commit.message, 'ci skip')"
-    steps:
-      - uses: actions/checkout@v2
-
-      - name: Install cargo-audit
-        uses: actions-rs/cargo@v1
-        with:
-          command: install
-          args: cargo-audit
-
-      - name: Generate lockfile
-        uses: actions-rs/cargo@v1
-        with:
-          command: generate-lockfile
-
-      - name: Audit dependencies
-        uses: actions-rs/cargo@v1
-        with:
-          command: audit

.github/workflows/stress-test.yml

@@ -1,41 +0,0 @@
-name: Stress Test
-on:
-  pull_request:
-  push:
-    branches:
-      - master
-
-env:
-  RUSTFLAGS: -Dwarnings
-  RUST_BACKTRACE: 1
-  # Change to specific Rust release to pin
-  rust_stable: 1.60.0
-
-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 ${{ env.rust_stable }}
-        uses: actions-rs/toolchain@v1
-        with:
-            toolchain: ${{ env.rust_stable }}
-            override: true
-      - uses: Swatinem/rust-cache@v1
-      - 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 }}

.gitignore

@@ -1,4 +1,2 @@
 target
 Cargo.lock
-
-.cargo/config.toml

CODE_OF_CONDUCT.md

@@ -1,7 +0,0 @@
-# Code of Conduct
-
-The Tokio project adheres to the [Rust Code of Conduct](https://www.rust-lang.org/policies/code-of-conduct). This describes the minimum behavior expected from all contributors.
-
-## Enforcement
-
-Instances of violations of the Code of Conduct can be reported by contacting the project team at [[email protected]](mailto:[email protected]).

CONTRIBUTING.md

@@ -12,17 +12,15 @@ use your help.
 This guide will help you get started. **Do not let this guide intimidate you**.
 It should be considered a map to help you navigate the process.
 
-The [dev channel][dev] is available for any concerns not covered in this guide, please join
+You may also get help with contributing in the [dev channel][dev], please join
 us!
 
-[dev]: https://discord.gg/tokio
+[dev]: https://gitter.im/tokio-rs/dev
 
 ## Conduct
 
 The Tokio project adheres to the [Rust Code of Conduct][coc]. This describes
-the _minimum_ behavior expected from all contributors. Instances of violations of the
-Code of Conduct can be reported by contacting the project team at
-[[email protected]](mailto:[email protected]).
+the _minimum_ behavior expected from all contributors.
 
 [coc]: https://github.com/rust-lang/rust/blob/master/CODE_OF_CONDUCT.md
 
@@ -31,8 +29,8 @@ Code of Conduct can be reported by contacting the project team at
 For any issue, there are fundamentally three ways an individual can contribute:
 
 1. By opening the issue for discussion: For instance, if you believe that you
-   have discovered a bug in Tokio, creating a new issue in [the tokio-rs/tokio
-   issue tracker][issue] is the way to report it.
+   have uncovered a bug in Tokio, creating a new issue in the tokio-rs/tokio
+   issue tracker is the way to report it.
 
 2. By helping to triage the issue: This can be done by providing
    supporting details (a test case that demonstrates a bug), providing
@@ -44,25 +42,21 @@ For any issue, there are fundamentally three ways an individual can contribute:
    often, by opening a Pull Request that changes some bit of something in
    Tokio in a concrete and reviewable manner.
 
-[issue]: https://github.com/tokio-rs/tokio/issues
-
 **Anybody can participate in any stage of contribution**. We urge you to
 participate in the discussion around bugs and participate in reviewing PRs.
 
 ### Asking for General Help
 
 If you have reviewed existing documentation and still have questions or are
-having problems, you can [open a discussion] asking for help.
+having problems, you can open an issue asking for help.
 
 In exchange for receiving help, we ask that you contribute back a documentation
 PR that helps others avoid the problems that you encountered.
 
-[open a discussion]: https://github.com/tokio-rs/tokio/discussions/new
-
 ### Submitting a Bug Report
 
-When opening a new issue in the Tokio issue tracker, you will be presented
-with a basic template that should be filled in. If you believe that you have
+When opening a new issue in the Tokio issue tracker, users will be presented
+with a [basic template][template] that should be filled in. If you believe that you have
 uncovered a bug, please fill out this form, following the template to the best
 of your ability. Do not worry if you cannot answer every detail, just fill in
 what you can.
@@ -78,6 +72,7 @@ cases should be limited, as much as possible, to using only Tokio APIs.
 See [How to create a Minimal, Complete, and Verifiable example][mcve].
 
 [mcve]: https://stackoverflow.com/help/mcve
+[template]: .github/PULL_REQUEST_TEMPLATE.md
 
 ### Triaging a Bug Report
 
@@ -117,68 +112,6 @@ usually a good idea to first open an issue describing the change to solicit
 feedback and guidance. This will increase the likelihood of the PR getting
 merged.
 
-### Cargo Commands
-
-Due to the extensive use of features in Tokio, you will often need to add extra
-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
-```
-
-To build documentation including Tokio's unstable features, it is necessary to
-pass `--cfg tokio_unstable` to both RustDoc *and* rustc. To build the
-documentation for unstable features, use this command:
-
-```
-RUSTDOCFLAGS="--cfg docsrs --cfg tokio_unstable" RUSTFLAGS="--cfg tokio_unstable" 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:
-
-```
-# Mac or Linux
-rustfmt --check --edition 2018 $(git ls-files '*.rs')
-
-# Powershell
-Get-ChildItem . -Filter "*.rs" -Recurse | foreach { rustfmt --check --edition 2018 $_.FullName }
-```
-The `--check` argument prints the things that need to be fixed. If you remove
-it, `rustfmt` will update your files locally instead.
-
-You can run loom tests with
-```
-cd tokio # tokio crate in workspace
-LOOM_MAX_PREEMPTIONS=1 RUSTFLAGS="--cfg loom" \
-    cargo test --lib --release --features full -- --test-threads=1 --nocapture
-```
-
-You can run miri tests with
-```
-MIRIFLAGS="-Zmiri-disable-isolation -Zmiri-tag-raw-pointers" PROPTEST_CASES=10 \
-    cargo +nightly miri test --features full --lib
-```
-
 ### Tests
 
 If the change being proposed alters code (as opposed to only documentation for
@@ -220,6 +153,8 @@ The type level example for `tokio_timer::Timeout` provides a good example of a
 documentation test:
 
 ```
+/// # extern crate futures;
+/// # extern crate tokio;
 /// // import the `timeout` function, usually this is done
 /// // with `use tokio::prelude::*`
 /// use tokio::prelude::FutureExt;
@@ -257,6 +192,8 @@ If this were a documentation test for the `Timeout::new` function, then the
 example would explicitly use `Timeout::new`. For example:
 
 ```
+/// # extern crate futures;
+/// # extern crate tokio;
 /// use tokio::timer::Timeout;
 /// use futures::Future;
 /// use futures::sync::oneshot;
@@ -284,7 +221,7 @@ That said, if you have a number of commits that are "checkpoints" and don't
 represent a single logical change, please squash those together.
 
 Note that multiple commits often get squashed when they are landed (see the
-notes about [commit squashing](#commit-squashing)).
+notes about [commit squashing]).
 
 #### Commit message guidelines
 
@@ -355,7 +292,7 @@ in order to evaluate whether the changes are correct and necessary.
 Keep an eye out for comments from code owners to provide guidance on conflicting
 feedback.
 
-**Once the PR is open, do not rebase the commits**. See [Commit Squashing](#commit-squashing) for
+**Once the PR is open, do not rebase the commits**. See [Commit Squashing] for
 more details.
 
 ### Commit Squashing
@@ -448,176 +385,3 @@ _Adapted from the [Node.js contributing guide][node]_.
 [node]: https://github.com/nodejs/node/blob/master/CONTRIBUTING.md
 [hiding-a-comment]: https://help.github.com/articles/managing-disruptive-comments/#hiding-a-comment
 [documentation test]: https://doc.rust-lang.org/rustdoc/documentation-tests.html
-
-## 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.
-
-### 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.
- - **A-tokio-tls** This issue concerns the `tokio-tls` crate. Only used for
-   older issues, as the crate has been moved to another repository.
- - **A-tokio-test** The issue concerns the `tokio-test` crate.
- - **A-tokio-macros** This issue concerns the `tokio-macros` crate. Should only
-   be used for the procedural macros, and not `join!` or `select!`.
- - **A-ci** This issue concerns our GitHub Actions setup.
-
-### 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.
- - **C-maintenance** This is an issue or PR about stuff such as documentation,
-   GitHub Actions or code quality.
- - **C-feature-request** This is a feature request. Implementations of feature
-   requests use `C-enhancement` instead.
- - **C-feature-accepted** If you submit a PR for this feature request, we wont
-   close it with the reason "we don't want this". Issues with this label should
-   also have the `C-feature-request` label.
- - **C-musing** Stuff like tracking issues or roadmaps. "musings about a better
-   world"
- - **C-proposal** A proposal of some kind, and a request for comments.
- - **C-question** A user question. Large overlap with GitHub discussions.
- - **C-request** A non-feature request, e.g. "please add deprecation notices to
-   `-alpha.*` versions of crates"
-
-### Calls for participation
-
- - **E-help-wanted** Stuff where we want help. Often seen together with `C-bug`
-   or `C-feature-accepted`.
- - **E-easy** This is easy, ranging from quick documentation fixes to stuff you
-   can do after reading the tutorial on our website.
- - **E-medium** This is not `E-easy` or `E-hard`.
- - **E-hard** This either involves very tricky code, is something we don't know
-   how to solve, or is difficult for some other reason.
- - **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**.
-
- - **M-blocking** Things relevant to `spawn_blocking`, `block_in_place`.
- - **M-codec** The `tokio_util::codec` module.
- - **M-compat** The `tokio_util::compat` module.
- - **M-coop** Things relevant to coop.
- - **M-fs** The `tokio::fs` module.
- - **M-io** The `tokio::io` module.
- - **M-macros** Issues about any kind of macro.
- - **M-net** The `tokio::net` module.
- - **M-process** The `tokio::process` module.
- - **M-runtime** The `tokio::runtime` module.
- - **M-signal** The `tokio::signal` 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.
-
- - **T-docs** This is about documentation.
- - **T-performance** This is about performance.
- - **T-v0.1.x** This is about old Tokio.
-
-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
-each other, releasing new versions to crates.io can involve some complexities.
-When releasing a new version of a crate, follow these steps:
-
-1. **Ensure that the release crate has no path dependencies.** When the HEAD
-   version of a Tokio crate requires unreleased changes in another Tokio crate,
-   the crates.io dependency on the second crate will be replaced with a path
-   dependency. Crates with path dependencies cannot be published, so before
-   publishing the dependent crate, any path dependencies must also be published.
-   This should be done through a form of depth-first tree traversal:
-
-   1. Starting with the first path dependency in the crate to be released,
-      inspect the `Cargo.toml` for the dependency. If the dependency has any
-      path dependencies of its own, repeat this step with the first such
-      dependency.
-   2. Begin the release process for the path dependency.
-   3. Once the path dependency has been published to crates.io, update the
-      dependent crate to depend on the crates.io version.
-   4. When all path dependencies have been published, the dependent crate may
-      be published.
-
-   To verify that a crate is ready to publish, run:
-
-   ```bash
-   bin/publish --dry-run <CRATE NAME> <CRATE VERSION>
-   ```
-
-2. **Update Cargo metadata.** After releasing any path dependencies, update the
-   `version` field in `Cargo.toml` to the new version, and the `documentation`
-   field to the docs.rs URL of the new version.
-3. **Update other documentation links.** Update the "Documentation" link in the
-   crate's `README.md` to point to the docs.rs URL of the new version.
-4. **Update the changelog for the crate.** Each crate in the Tokio repository
-   has its own `CHANGELOG.md` in that crate's subdirectory. Any changes to that
-   crate since the last release should be added to the changelog. Change
-   descriptions may be taken from the Git history, but should be edited to
-   ensure a consistent format, based on [Keep A Changelog][keep-a-changelog].
-   Other entries in that crate's changelog may also be used for reference.
-5. **Perform a final audit for breaking changes.** Compare the HEAD version of
-   crate with the Git tag for the most recent release version. If there are any
-   breaking API changes, determine if those changes can be made without breaking
-   existing APIs. If so, resolve those issues. Otherwise, if it is necessary to
-   make a breaking release, update the version numbers to reflect this.
-6. **Open a pull request with your changes.** Once that pull request has been
-   approved by a maintainer and the pull request has been merged, continue to
-   the next step.
-7. **Release the crate.** Run the following command:
-
-   ```bash
-   bin/publish <NAME OF CRATE> <VERSION>
-   ```
-
-   Your editor and prompt you to edit a message for the tag. Copy the changelog
-   entry for that release version into your editor and close the window.
-
-[keep-a-changelog]: https://github.com/olivierlacan/keep-a-changelog/blob/master/CHANGELOG.md

Cargo.toml

@@ -2,15 +2,21 @@
 
 members = [
   "tokio",
-  "tokio-macros",
+  "tokio-buf",
+  "tokio-codec",
+  "tokio-current-thread",
+  "tokio-executor",
+  "tokio-fs",
+  "tokio-futures",
+  "tokio-io",
+  "tokio-reactor",
+  "tokio-signal",
+  "tokio-sync",
   "tokio-test",
-  "tokio-stream",
-  "tokio-util",
-
-  # Internal
-  "benches",
-  "examples",
-  "stress-test",
-  "tests-build",
-  "tests-integration",
+  "tokio-threadpool",
+  "tokio-timer",
+  "tokio-tcp",
+  "tokio-tls",
+  "tokio-udp",
+  "tokio-uds",
 ]

Cross.toml

@@ -1,4 +0,0 @@
-[build.env]
-passthrough = [
-    "RUSTFLAGS",
-]

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2022 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,22 +14,26 @@ the Rust programming language. It is:
 
 [![Crates.io][crates-badge]][crates-url]
 [![MIT licensed][mit-badge]][mit-url]
-[![Build Status][actions-badge]][actions-url]
-[![Discord chat][discord-badge]][discord-url]
+[![Build Status][azure-badge]][azure-url]
+[![Gitter chat][gitter-badge]][gitter-url]
 
 [crates-badge]: https://img.shields.io/crates/v/tokio.svg
 [crates-url]: https://crates.io/crates/tokio
 [mit-badge]: https://img.shields.io/badge/license-MIT-blue.svg
-[mit-url]: 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
-[discord-badge]: https://img.shields.io/discord/500028886025895936.svg?logo=discord&style=flat-square
-[discord-url]: https://discord.gg/tokio
+[mit-url]: LICENSE
+[azure-badge]: https://dev.azure.com/tokio-rs/Tokio/_apis/build/status/tokio-rs.tokio?branchName=master
+[azure-url]: https://dev.azure.com/tokio-rs/Tokio/_build/latest?definitionId=1&branchName=master
+[gitter-badge]: https://img.shields.io/gitter/room/tokio-rs/tokio.svg
+[gitter-url]: https://gitter.im/tokio-rs/tokio
 
 [Website](https://tokio.rs) |
-[Guides](https://tokio.rs/tokio/tutorial) |
-[API Docs](https://docs.rs/tokio/latest/tokio) |
-[Chat](https://discord.gg/tokio)
+[Guides](https://tokio.rs/docs/getting-started/hello-world/) |
+[API Docs](https://docs.rs/tokio/0.1.20/tokio) |
+[Chat](https://gitter.im/tokio-rs/tokio)
+
+The API docs for the master branch are published [here][master-dox].
+
+[master-dox]: https://tokio-rs.github.io/tokio/doc/tokio/
 
 ## Overview
 
@@ -38,86 +42,73 @@ asynchronous applications with the Rust programming language. At a high
 level, it provides a few major components:
 
 * A multithreaded, work-stealing based task [scheduler].
-* A reactor backed by the operating system's event queue (epoll, kqueue,
+* A [reactor] backed by the operating system's event queue (epoll, kqueue,
   IOCP, etc...).
 * Asynchronous [TCP and UDP][net] sockets.
 
 These components provide the runtime components necessary for building
 an asynchronous application.
 
-[net]: https://docs.rs/tokio/latest/tokio/net/index.html
-[scheduler]: https://docs.rs/tokio/latest/tokio/runtime/index.html
+[net]: https://docs.rs/tokio/0.1.20/tokio/net/index.html
+[reactor]: https://docs.rs/tokio/0.1.20/tokio/reactor/index.html
+[scheduler]: https://docs.rs/tokio/0.1.20/tokio/runtime/index.html
 
 ## Example
 
-A basic TCP echo server with Tokio.
+A basic TCP echo server with Tokio:
 
-Make sure you activated the full features of the tokio crate on Cargo.toml:
+```rust
+extern crate tokio;
 
-```toml
-[dependencies]
-tokio = { version = "1.18.4", features = ["full"] }
-```
-Then, on your main.rs:
-
-```rust,no_run
+use tokio::prelude::*;
+use tokio::io::copy;
 use tokio::net::TcpListener;
-use tokio::io::{AsyncReadExt, AsyncWriteExt};
 
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let listener = TcpListener::bind("127.0.0.1:8080").await?;
+fn main() {
+    // Bind the server's socket.
+    let addr = "127.0.0.1:12345".parse().unwrap();
+    let listener = TcpListener::bind(&addr)
+        .expect("unable to bind TCP listener");
 
-    loop {
-        let (mut socket, _) = listener.accept().await?;
+    // Pull out a stream of sockets for incoming connections
+    let server = listener.incoming()
+        .map_err(|e| eprintln!("accept failed = {:?}", e))
+        .for_each(|sock| {
+            // Split up the reading and writing parts of the
+            // socket.
+            let (reader, writer) = sock.split();
 
-        tokio::spawn(async move {
-            let mut buf = [0; 1024];
+            // A future that echos the data and returns how
+            // many bytes were copied...
+            let bytes_copied = copy(reader, writer);
 
-            // In a loop, read data from the socket and write the data back.
-            loop {
-                let n = match socket.read(&mut buf).await {
-                    // socket closed
-                    Ok(n) if n == 0 => return,
-                    Ok(n) => n,
-                    Err(e) => {
-                        eprintln!("failed to read from socket; err = {:?}", e);
-                        return;
-                    }
-                };
+            // ... after which we'll print what happened.
+            let handle_conn = bytes_copied.map(|amt| {
+                println!("wrote {:?} bytes", amt)
+            }).map_err(|err| {
+                eprintln!("IO error {:?}", err)
+            });
 
-                // Write the data back
-                if let Err(e) = socket.write_all(&buf[0..n]).await {
-                    eprintln!("failed to write to socket; err = {:?}", e);
-                    return;
-                }
-            }
+            // Spawn the future as a concurrent task.
+            tokio::spawn(handle_conn)
         });
-    }
+
+    // Start the Tokio runtime
+    tokio::run(server);
 }
 ```
 
-More examples can be found [here][examples]. For a larger "real world" example, see the
-[mini-redis] repository.
-
-[examples]: https://github.com/tokio-rs/tokio/tree/master/examples
-[mini-redis]: https://github.com/tokio-rs/mini-redis/
-
-To see a list of the available features flags that can be enabled, check our
-[docs][feature-flag-docs].
+More examples can be found [here](tokio/examples).
 
 ## Getting Help
 
 First, see if the answer to your question can be found in the [Guides] or the
 [API documentation]. If the answer is not there, there is an active community in
-the [Tokio Discord server][chat]. We would be happy to try to answer your
-question. You can also ask your question on [the discussions page][discussions].
+the [Tokio Gitter channel][chat]. We would be happy to try to answer your
+question.  Last, if that doesn't work, try opening an [issue] with the question.
 
-[Guides]: https://tokio.rs/tokio/tutorial
-[API documentation]: https://docs.rs/tokio/latest/tokio
-[chat]: https://discord.gg/tokio
-[discussions]: https://github.com/tokio-rs/tokio/discussions
-[feature-flag-docs]: https://docs.rs/tokio/#feature-flags
+[chat]: https://gitter.im/tokio-rs/tokio
+[issue]: https://github.com/tokio-rs/tokio/issues/new
 
 ## Contributing
 
@@ -125,80 +116,88 @@ question. You can also ask your question on [the discussions page][discussions].
 you! We have a [contributing guide][guide] to help you get involved in the Tokio
 project.
 
-[guide]: https://github.com/tokio-rs/tokio/blob/master/CONTRIBUTING.md
+[guide]: CONTRIBUTING.md
+
+## Project layout
+
+The `tokio` crate, found at the root, is primarily intended for use by
+application developers.  Library authors should depend on the sub crates, which
+have greater guarantees of stability.
+
+The crates included as part of Tokio are:
+
+* [`tokio-current-thread`]: Schedule the execution of futures on the current
+  thread.
+
+* [`tokio-executor`]: Task execution related traits and utilities.
+
+* [`tokio-fs`]: Filesystem (and standard in / out) APIs.
+
+* [`tokio-futures`]: Experimental `std::future::Future` and `async` / `await` support.
+
+* [`tokio-codec`]: Utilities for encoding and decoding protocol frames.
+
+* [`tokio-io`]: Asynchronous I/O related traits and utilities.
+
+* [`tokio-macros`]: Macros for usage with Tokio.
+
+* [`tokio-reactor`]: Event loop that drives I/O resources (like TCP and UDP
+  sockets).
+
+* [`tokio-tcp`]: TCP bindings for use with `tokio-io` and `tokio-reactor`.
+
+* [`tokio-threadpool`]: Schedules the execution of futures across a pool of
+  threads.
+
+* [ `tokio-timer`]: Time related APIs.
+
+* [`tokio-udp`]: UDP bindings for use with `tokio-io` and `tokio-reactor`.
+
+* [`tokio-uds`]: Unix Domain Socket bindings for use with `tokio-io` and
+  `tokio-reactor`.
+
+[`tokio-codec`]: tokio-codec
+[`tokio-current-thread`]: tokio-current-thread
+[`tokio-executor`]: tokio-executor
+[`tokio-fs`]: tokio-fs
+[`tokio-futures`]: tokio-futures
+[`tokio-io`]: tokio-io
+[`tokio-macros`]: tokio-macros
+[`tokio-reactor`]: tokio-reactor
+[`tokio-tcp`]: tokio-tcp
+[`tokio-threadpool`]: tokio-threadpool
+[`tokio-timer`]: tokio-timer
+[`tokio-udp`]: tokio-udp
+[`tokio-uds`]: tokio-uds
 
 ## Related Projects
 
 In addition to the crates in this repository, the Tokio project also maintains
 several other libraries, including:
 
-* [`hyper`]: A fast and correct HTTP/1.1 and HTTP/2 implementation for Rust.
-
-* [`tonic`]: A gRPC over HTTP/2 implementation focused on high performance, interoperability, and flexibility.
-
-* [`warp`]: A super-easy, composable, web server framework for warp speeds.
-
-* [`tower`]: A library of modular and reusable components for building robust networking clients and servers.
-
-* [`tracing`] (formerly `tokio-trace`): A framework for application-level tracing and async-aware diagnostics.
-
-* [`rdbc`]: A Rust database connectivity library for MySQL, Postgres and SQLite.
+* [`tracing`] (formerly `tokio-trace`): A framework for application-level
+  tracing and async-aware diagnostics.
 
 * [`mio`]: A low-level, cross-platform abstraction over OS I/O APIs that powers
   `tokio`.
 
 * [`bytes`]: Utilities for working with bytes, including efficient byte buffers.
 
-* [`loom`]: A testing tool for concurrent Rust code
-
-[`warp`]: https://github.com/seanmonstar/warp
-[`hyper`]: https://github.com/hyperium/hyper
-[`tonic`]: https://github.com/hyperium/tonic
-[`tower`]: https://github.com/tower-rs/tower
-[`loom`]: https://github.com/tokio-rs/loom
-[`rdbc`]: https://github.com/tokio-rs/rdbc
 [`tracing`]: https://github.com/tokio-rs/tracing
 [`mio`]: https://github.com/tokio-rs/mio
 [`bytes`]: https://github.com/tokio-rs/bytes
 
 ## Supported Rust Versions
 
-Tokio will keep a rolling MSRV (minimum supported rust version) policy of **at
-least** 6 months. When increasing the MSRV, the new Rust version must have been
-released at least six months ago. The current MSRV is 1.49.0.
-
-## Release schedule
-
-Tokio doesn't follow a fixed release schedule, but we typically make one to two
-new minor releases each month. We make patch releases for bugfixes as necessary.
-
-## Bug patching policy
-
-For the purposes of making patch releases with bugfixes, we have designated
-certain minor releases as LTS (long term support) releases. Whenever a bug
-warrants a patch release with a fix for the bug, it will be backported and
-released as a new patch release for each LTS minor version. Our current LTS
-releases are:
-
- * `1.8.x` - LTS release until February 2022.
- * `1.14.x` - LTS release until June 2022.
-
-Each LTS release will continue to receive backported fixes for at least half a
-year. If you wish to use a fixed minor release in your project, we recommend
-that you use an LTS release.
-
-To use a fixed minor version, you can specify the version with a tilde. For
-example, to specify that you wish to use the newest `1.8.x` patch release, you
-can use the following dependency specification:
-```text
-tokio = { version = "~1.8", features = [...] }
-```
+Tokio is built against the latest stable, nightly, and beta Rust releases. The
+minimum version supported is the stable release from three months before the
+current stable release version. For example, if the latest stable Rust is 1.29,
+the minimum version supported is 1.26. The current Tokio version is not
+guaranteed to build on Rust versions earlier than the minimum supported version.
 
 ## License
 
-This project is licensed under the [MIT license].
-
-[MIT license]: https://github.com/tokio-rs/tokio/blob/master/LICENSE
+This project is licensed under the [MIT license](LICENSE).
 
 ### Contribution
 

SECURITY.md

@@ -1,13 +0,0 @@
-## Report a security issue
-
-The Tokio project team welcomes security reports and is committed to providing prompt attention to security issues. Security issues should be reported privately via [[email protected]](mailto:[email protected]). Security issues should not be reported via the public Github Issue tracker.
-
-## Vulnerability coordination
-
-Remediation of security vulnerabilities is prioritized by the project team. The project team coordinates remediation with third-party project stakeholders via [Github Security Advisories](https://help.github.com/en/github/managing-security-vulnerabilities/about-github-security-advisories). Third-party stakeholders may include the reporter of the issue, affected direct or indirect users of Tokio, and maintainers of upstream dependencies if applicable.
-
-Downstream project maintainers and Tokio users can request participation in coordination of applicable security issues by sending your contact email address, Github username(s) and any other salient information to [[email protected]](mailto:[email protected]). Participation in security issue coordination processes is at the discretion of the Tokio team.
-
-## Security advisories
-
-The project team is committed to transparency in the security issue disclosure process. The Tokio team announces security issues via [project Github Release notes](https://github.com/tokio-rs/tokio/releases) and the [RustSec advisory database](https://github.com/RustSec/advisory-db) (i.e. `cargo-audit`).

azure-pipelines.yml

@@ -0,0 +1,103 @@
+trigger: ["master", "v0.1.x"]
+pr: ["master", "v0.1.x"]
+
+jobs:
+# Check formatting
+- template: ci/azure-rustfmt.yml
+  parameters:
+    name: rustfmt
+
+# Test top level crate
+- template: ci/azure-test-stable.yml
+  parameters:
+    name: test_tokio
+    displayName: Test tokio
+    cross: true
+    crates:
+      - tokio
+
+# Test crates that are platform specific
+- template: ci/azure-test-stable.yml
+  parameters:
+    name: test_sub_cross
+    displayName: Test sub crates -
+    cross: true
+    crates:
+      - tokio-fs
+      - tokio-reactor
+      - tokio-signal
+      - tokio-tcp
+      - tokio-tls
+      - tokio-udp
+      - tokio-uds
+
+# Test crates that are NOT platform specific
+- template: ci/azure-test-stable.yml
+  parameters:
+    name: test_linux
+    displayName: Test sub crates -
+    crates:
+      - tokio-buf
+      - tokio-codec
+      - tokio-current-thread
+      - tokio-executor
+      - tokio-io
+      - tokio-sync
+      - tokio-threadpool
+      - tokio-timer
+      - tokio-test
+
+- template: ci/azure-cargo-check.yml
+  parameters:
+    name: features
+    displayName: Check feature permtuations
+    rust: stable
+    crates:
+      tokio:
+        - codec
+        - fs
+        - io
+        - reactor
+        - rt-full
+        - tcp
+        - timer
+        - udp
+        - uds
+        - sync
+        - experimental-tracing
+      tokio-buf:
+        - util
+
+# Try cross compiling
+- template: ci/azure-cross-compile.yml
+  parameters:
+    name: cross_32bit_linux
+    target: i686-unknown-linux-gnu
+
+# This represents the minimum Rust version supported by
+# Tokio. Updating this should be done in a dedicated PR and
+# cannot be greater than two 0.x releases prior to the
+# current stable.
+#
+# Tests are not run as tests may require newer versions of
+# rust.
+- template: ci/azure-check-minrust.yml
+  parameters:
+    name: minrust
+    rust_version: 1.31.0
+
+- template: ci/azure-tsan.yml
+  parameters:
+    name: tsan
+
+- template: ci/azure-deploy-docs.yml
+  parameters:
+    dependsOn:
+      - rustfmt
+      - test_tokio
+      - test_sub_cross
+      - test_linux
+      - features
+      - cross_32bit_linux
+      - minrust
+      - tsan

benches/Cargo.toml

@@ -1,52 +0,0 @@
-[package]
-name = "benches"
-version = "0.0.0"
-publish = false
-edition = "2018"
-
-[dependencies]
-tokio = { version = "1.5.0", path = "../tokio", features = ["full"] }
-bencher = "0.1.5"
-
-[dev-dependencies]
-tokio-util = { version = "0.7.0", 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"
-harness = false
-
-[[bench]]
-name = "rt_multi_threaded"
-path = "rt_multi_threaded.rs"
-harness = false
-
-
-[[bench]]
-name = "sync_rwlock"
-path = "sync_rwlock.rs"
-harness = false
-
-[[bench]]
-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: &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/latency.rs

@@ -0,0 +1,114 @@
+#![feature(test)]
+
+extern crate test;
+#[macro_use]
+extern crate futures;
+extern crate tokio;
+
+use std::io;
+use std::net::SocketAddr;
+use std::thread;
+
+use futures::sync::mpsc;
+use futures::sync::oneshot;
+use futures::{Future, Poll, Sink, Stream};
+use test::Bencher;
+use tokio::net::UdpSocket;
+
+/// UDP echo server
+struct EchoServer {
+    socket: UdpSocket,
+    buf: Vec<u8>,
+    to_send: Option<(usize, SocketAddr)>,
+}
+
+impl EchoServer {
+    fn new(s: UdpSocket) -> Self {
+        EchoServer {
+            socket: s,
+            to_send: None,
+            buf: vec![0u8; 1600],
+        }
+    }
+}
+
+impl Future for EchoServer {
+    type Item = ();
+    type Error = io::Error;
+
+    fn poll(&mut self) -> Poll<(), io::Error> {
+        loop {
+            if let Some(&(size, peer)) = self.to_send.as_ref() {
+                try_ready!(self.socket.poll_send_to(&self.buf[..size], &peer));
+                self.to_send = None;
+            }
+            self.to_send = Some(try_ready!(self.socket.poll_recv_from(&mut self.buf)));
+        }
+    }
+}
+
+#[bench]
+fn udp_echo_latency(b: &mut Bencher) {
+    let any_addr = "127.0.0.1:0".to_string();
+    let any_addr = any_addr.parse::<SocketAddr>().unwrap();
+
+    let (stop_c, stop_p) = oneshot::channel::<()>();
+    let (tx, rx) = oneshot::channel();
+
+    let child = thread::spawn(move || {
+        let socket = tokio::net::UdpSocket::bind(&any_addr).unwrap();
+        tx.send(socket.local_addr().unwrap()).unwrap();
+
+        let server = EchoServer::new(socket);
+        let server = server.select(stop_p.map_err(|_| panic!()));
+        let server = server.map_err(|_| ());
+        server.wait().unwrap();
+    });
+
+    let client = std::net::UdpSocket::bind(&any_addr).unwrap();
+
+    let server_addr = rx.wait().unwrap();
+    let mut buf = [0u8; 1000];
+
+    // warmup phase; for some reason initial couple of
+    // runs are much slower
+    //
+    // TODO: Describe the exact reasons; caching? branch predictor? lazy closures?
+    for _ in 0..8 {
+        client.send_to(&buf, &server_addr).unwrap();
+        let _ = client.recv_from(&mut buf).unwrap();
+    }
+
+    b.iter(|| {
+        client.send_to(&buf, &server_addr).unwrap();
+        let _ = client.recv_from(&mut buf).unwrap();
+    });
+
+    stop_c.send(()).unwrap();
+    child.join().unwrap();
+}
+
+#[bench]
+fn futures_channel_latency(b: &mut Bencher) {
+    let (mut in_tx, in_rx) = mpsc::channel(32);
+    let (out_tx, out_rx) = mpsc::channel::<_>(32);
+
+    let child = thread::spawn(|| out_tx.send_all(in_rx.then(|r| r.unwrap())).wait());
+    let mut rx_iter = out_rx.wait();
+
+    // warmup phase; for some reason initial couple of runs are much slower
+    //
+    // TODO: Describe the exact reasons; caching? branch predictor? lazy closures?
+    for _ in 0..8 {
+        in_tx.start_send(Ok(1usize)).unwrap();
+        let _ = rx_iter.next();
+    }
+
+    b.iter(|| {
+        in_tx.start_send(Ok(1usize)).unwrap();
+        let _ = rx_iter.next();
+    });
+
+    drop(in_tx);
+    child.join().unwrap().unwrap();
+}

benches/mio-ops.rs

@@ -0,0 +1,56 @@
+// Measure cost of different operations
+// to get a sense of performance tradeoffs
+#![feature(test)]
+
+extern crate mio;
+extern crate test;
+
+use test::Bencher;
+
+use mio::tcp::TcpListener;
+use mio::{PollOpt, Ready, Token};
+
+#[bench]
+fn mio_register_deregister(b: &mut Bencher) {
+    let addr = "127.0.0.1:0".parse().unwrap();
+    // Setup the server socket
+    let sock = TcpListener::bind(&addr).unwrap();
+    let poll = mio::Poll::new().unwrap();
+
+    const CLIENT: Token = Token(1);
+
+    b.iter(|| {
+        poll.register(&sock, CLIENT, Ready::readable(), PollOpt::edge())
+            .unwrap();
+        poll.deregister(&sock).unwrap();
+    });
+}
+
+#[bench]
+fn mio_reregister(b: &mut Bencher) {
+    let addr = "127.0.0.1:0".parse().unwrap();
+    // Setup the server socket
+    let sock = TcpListener::bind(&addr).unwrap();
+    let poll = mio::Poll::new().unwrap();
+
+    const CLIENT: Token = Token(1);
+    poll.register(&sock, CLIENT, Ready::readable(), PollOpt::edge())
+        .unwrap();
+
+    b.iter(|| {
+        poll.reregister(&sock, CLIENT, Ready::readable(), PollOpt::edge())
+            .unwrap();
+    });
+    poll.deregister(&sock).unwrap();
+}
+
+#[bench]
+fn mio_poll(b: &mut Bencher) {
+    let poll = mio::Poll::new().unwrap();
+    let timeout = std::time::Duration::new(0, 0);
+    let mut events = mio::Events::with_capacity(1024);
+
+    b.iter(|| {
+        poll.poll(&mut events, Some(timeout)).unwrap();
+    });
+}

benches/rt_multi_threaded.rs

@@ -1,151 +0,0 @@
-//! Benchmark implementation details of the threaded scheduler. These benches are
-//! intended to be used as a form of regression testing and not as a general
-//! purpose benchmark demonstrating real-world performance.
-
-use tokio::runtime::{self, Runtime};
-use tokio::sync::oneshot;
-
-use bencher::{benchmark_group, benchmark_main, Bencher};
-use std::sync::atomic::AtomicUsize;
-use std::sync::atomic::Ordering::Relaxed;
-use std::sync::{mpsc, Arc};
-
-fn spawn_many(b: &mut Bencher) {
-    const NUM_SPAWN: usize = 10_000;
-
-    let rt = rt();
-
-    let (tx, rx) = mpsc::sync_channel(1000);
-    let rem = Arc::new(AtomicUsize::new(0));
-
-    b.iter(|| {
-        rem.store(NUM_SPAWN, Relaxed);
-
-        rt.block_on(async {
-            for _ in 0..NUM_SPAWN {
-                let tx = tx.clone();
-                let rem = rem.clone();
-
-                tokio::spawn(async move {
-                    if 1 == rem.fetch_sub(1, Relaxed) {
-                        tx.send(()).unwrap();
-                    }
-                });
-            }
-
-            let _ = rx.recv().unwrap();
-        });
-    });
-}
-
-fn yield_many(b: &mut Bencher) {
-    const NUM_YIELD: usize = 1_000;
-    const TASKS: usize = 200;
-
-    let rt = rt();
-
-    let (tx, rx) = mpsc::sync_channel(TASKS);
-
-    b.iter(move || {
-        for _ in 0..TASKS {
-            let tx = tx.clone();
-
-            rt.spawn(async move {
-                for _ in 0..NUM_YIELD {
-                    tokio::task::yield_now().await;
-                }
-
-                tx.send(()).unwrap();
-            });
-        }
-
-        for _ in 0..TASKS {
-            let _ = rx.recv().unwrap();
-        }
-    });
-}
-
-fn ping_pong(b: &mut Bencher) {
-    const NUM_PINGS: usize = 1_000;
-
-    let rt = rt();
-
-    let (done_tx, done_rx) = mpsc::sync_channel(1000);
-    let rem = Arc::new(AtomicUsize::new(0));
-
-    b.iter(|| {
-        let done_tx = done_tx.clone();
-        let rem = rem.clone();
-        rem.store(NUM_PINGS, Relaxed);
-
-        rt.block_on(async {
-            tokio::spawn(async move {
-                for _ in 0..NUM_PINGS {
-                    let rem = rem.clone();
-                    let done_tx = done_tx.clone();
-
-                    tokio::spawn(async move {
-                        let (tx1, rx1) = oneshot::channel();
-                        let (tx2, rx2) = oneshot::channel();
-
-                        tokio::spawn(async move {
-                            rx1.await.unwrap();
-                            tx2.send(()).unwrap();
-                        });
-
-                        tx1.send(()).unwrap();
-                        rx2.await.unwrap();
-
-                        if 1 == rem.fetch_sub(1, Relaxed) {
-                            done_tx.send(()).unwrap();
-                        }
-                    });
-                }
-            });
-
-            done_rx.recv().unwrap();
-        });
-    });
-}
-
-fn chained_spawn(b: &mut Bencher) {
-    const ITER: usize = 1_000;
-
-    let rt = rt();
-
-    fn iter(done_tx: mpsc::SyncSender<()>, n: usize) {
-        if n == 0 {
-            done_tx.send(()).unwrap();
-        } else {
-            tokio::spawn(async move {
-                iter(done_tx, n - 1);
-            });
-        }
-    }
-
-    let (done_tx, done_rx) = mpsc::sync_channel(1000);
-
-    b.iter(move || {
-        let done_tx = done_tx.clone();
-
-        rt.block_on(async {
-            tokio::spawn(async move {
-                iter(done_tx, ITER);
-            });
-
-            done_rx.recv().unwrap();
-        });
-    });
-}
-
-fn rt() -> Runtime {
-    runtime::Builder::new_multi_thread()
-        .worker_threads(4)
-        .enable_all()
-        .build()
-        .unwrap()
-}
-
-benchmark_group!(scheduler, spawn_many, ping_pong, yield_many, chained_spawn,);
-
-benchmark_main!(scheduler);

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

@@ -1,84 +0,0 @@
-//! Benchmark spawning a task onto the basic and threaded Tokio executors.
-//! This essentially measure the time to enqueue a task in the local and remote
-//! case.
-
-#[macro_use]
-extern crate bencher;
-
-use bencher::{black_box, Bencher};
-
-async fn work() -> usize {
-    let val = 1 + 1;
-    tokio::task::yield_now().await;
-    black_box(val)
-}
-
-fn basic_scheduler_spawn(bench: &mut Bencher) {
-    let runtime = tokio::runtime::Builder::new_current_thread()
-        .build()
-        .unwrap();
-    bench.iter(|| {
-        runtime.block_on(async {
-            let h = tokio::spawn(work());
-            assert_eq!(h.await.unwrap(), 2);
-        });
-    });
-}
-
-fn basic_scheduler_spawn10(bench: &mut Bencher) {
-    let runtime = tokio::runtime::Builder::new_current_thread()
-        .build()
-        .unwrap();
-    bench.iter(|| {
-        runtime.block_on(async {
-            let mut handles = Vec::with_capacity(10);
-            for _ in 0..10 {
-                handles.push(tokio::spawn(work()));
-            }
-            for handle in handles {
-                assert_eq!(handle.await.unwrap(), 2);
-            }
-        });
-    });
-}
-
-fn threaded_scheduler_spawn(bench: &mut Bencher) {
-    let runtime = tokio::runtime::Builder::new_multi_thread()
-        .worker_threads(1)
-        .build()
-        .unwrap();
-    bench.iter(|| {
-        runtime.block_on(async {
-            let h = tokio::spawn(work());
-            assert_eq!(h.await.unwrap(), 2);
-        });
-    });
-}
-
-fn threaded_scheduler_spawn10(bench: &mut Bencher) {
-    let runtime = tokio::runtime::Builder::new_multi_thread()
-        .worker_threads(1)
-        .build()
-        .unwrap();
-    bench.iter(|| {
-        runtime.block_on(async {
-            let mut handles = Vec::with_capacity(10);
-            for _ in 0..10 {
-                handles.push(tokio::spawn(work()));
-            }
-            for handle in handles {
-                assert_eq!(handle.await.unwrap(), 2);
-            }
-        });
-    });
-}
-
-bencher::benchmark_group!(
-    spawn,
-    basic_scheduler_spawn,
-    basic_scheduler_spawn10,
-    threaded_scheduler_spawn,
-    threaded_scheduler_spawn10,
-);
-
-bencher::benchmark_main!(spawn);

benches/sync_mpsc.rs

@@ -1,179 +0,0 @@
-use bencher::{black_box, Bencher};
-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));
-    });
-}
-
-fn create_100_medium(b: &mut Bencher) {
-    b.iter(|| {
-        black_box(&mpsc::channel::<Medium>(100));
-    });
-}
-
-fn create_100_000_medium(b: &mut Bencher) {
-    b.iter(|| {
-        black_box(&mpsc::channel::<Medium>(100_000));
-    });
-}
-
-fn send_medium(b: &mut Bencher) {
-    let rt = rt();
-
-    b.iter(|| {
-        let (tx, mut rx) = mpsc::channel::<Medium>(1000);
-
-        let _ = rt.block_on(tx.send([0; 64]));
-
-        rt.block_on(rx.recv()).unwrap();
-    });
-}
-
-fn send_large(b: &mut Bencher) {
-    let rt = rt();
-
-    b.iter(|| {
-        let (tx, mut rx) = mpsc::channel::<Large>(1000);
-
-        let _ = rt.block_on(tx.send([[0; 64]; 64]));
-
-        rt.block_on(rx.recv()).unwrap();
-    });
-}
-
-fn contention_bounded(b: &mut Bencher) {
-    let rt = rt();
-
-    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();
-                tokio::spawn(async move {
-                    for i in 0..1000 {
-                        tx.send(i).await.unwrap();
-                    }
-                });
-            }
-
-            for _ in 0..1_000 * 5 {
-                let _ = rx.recv().await;
-            }
-        })
-    });
-}
-
-fn contention_bounded_full(b: &mut Bencher) {
-    let rt = rt();
-
-    b.iter(|| {
-        rt.block_on(async move {
-            let (tx, mut rx) = mpsc::channel::<usize>(100);
-
-            for _ in 0..5 {
-                let tx = tx.clone();
-                tokio::spawn(async move {
-                    for i in 0..1000 {
-                        tx.send(i).await.unwrap();
-                    }
-                });
-            }
-
-            for _ in 0..1_000 * 5 {
-                let _ = rx.recv().await;
-            }
-        })
-    });
-}
-
-fn contention_unbounded(b: &mut Bencher) {
-    let rt = rt();
-
-    b.iter(|| {
-        rt.block_on(async move {
-            let (tx, mut rx) = mpsc::unbounded_channel::<usize>();
-
-            for _ in 0..5 {
-                let tx = tx.clone();
-                tokio::spawn(async move {
-                    for i in 0..1000 {
-                        tx.send(i).unwrap();
-                    }
-                });
-            }
-
-            for _ in 0..1_000 * 5 {
-                let _ = rx.recv().await;
-            }
-        })
-    });
-}
-
-fn uncontented_bounded(b: &mut Bencher) {
-    let rt = rt();
-
-    b.iter(|| {
-        rt.block_on(async move {
-            let (tx, mut rx) = mpsc::channel::<usize>(1_000_000);
-
-            for i in 0..5000 {
-                tx.send(i).await.unwrap();
-            }
-
-            for _ in 0..5_000 {
-                let _ = rx.recv().await;
-            }
-        })
-    });
-}
-
-fn uncontented_unbounded(b: &mut Bencher) {
-    let rt = rt();
-
-    b.iter(|| {
-        rt.block_on(async move {
-            let (tx, mut rx) = mpsc::unbounded_channel::<usize>();
-
-            for i in 0..5000 {
-                tx.send(i).unwrap();
-            }
-
-            for _ in 0..5_000 {
-                let _ = rx.recv().await;
-            }
-        })
-    });
-}
-
-bencher::benchmark_group!(
-    create,
-    create_1_medium,
-    create_100_medium,
-    create_100_000_medium
-);
-
-bencher::benchmark_group!(send, send_medium, send_large);
-
-bencher::benchmark_group!(
-    contention,
-    contention_bounded,
-    contention_bounded_full,
-    contention_unbounded,
-    uncontented_bounded,
-    uncontented_unbounded
-);
-
-bencher::benchmark_main!(create, send, contention);

benches/sync_rwlock.rs

@@ -1,142 +0,0 @@
-use bencher::{black_box, Bencher};
-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)
-        .build()
-        .unwrap();
-
-    let lock = Arc::new(RwLock::new(()));
-    b.iter(|| {
-        let lock = lock.clone();
-        rt.block_on(async move {
-            for _ in 0..6 {
-                let read = lock.read().await;
-                black_box(read);
-            }
-        })
-    });
-}
-
-fn read_concurrent_uncontended_multi(b: &mut Bencher) {
-    let rt = tokio::runtime::Builder::new_multi_thread()
-        .worker_threads(6)
-        .build()
-        .unwrap();
-
-    async fn task(lock: Arc<RwLock<()>>) {
-        let read = lock.read().await;
-        black_box(read);
-    }
-
-    let lock = Arc::new(RwLock::new(()));
-    b.iter(|| {
-        let lock = lock.clone();
-        rt.block_on(async move {
-            let j = tokio::try_join! {
-                task::spawn(task(lock.clone())),
-                task::spawn(task(lock.clone())),
-                task::spawn(task(lock.clone())),
-                task::spawn(task(lock.clone())),
-                task::spawn(task(lock.clone())),
-                task::spawn(task(lock.clone()))
-            };
-            j.unwrap();
-        })
-    });
-}
-
-fn read_concurrent_uncontended(b: &mut Bencher) {
-    let rt = tokio::runtime::Builder::new_current_thread()
-        .build()
-        .unwrap();
-
-    async fn task(lock: Arc<RwLock<()>>) {
-        let read = lock.read().await;
-        black_box(read);
-    }
-
-    let lock = Arc::new(RwLock::new(()));
-    b.iter(|| {
-        let lock = lock.clone();
-        rt.block_on(async move {
-            tokio::join! {
-                task(lock.clone()),
-                task(lock.clone()),
-                task(lock.clone()),
-                task(lock.clone()),
-                task(lock.clone()),
-                task(lock.clone())
-            };
-        })
-    });
-}
-
-fn read_concurrent_contended_multi(b: &mut Bencher) {
-    let rt = tokio::runtime::Builder::new_multi_thread()
-        .worker_threads(6)
-        .build()
-        .unwrap();
-
-    async fn task(lock: Arc<RwLock<()>>) {
-        let read = lock.read().await;
-        black_box(read);
-    }
-
-    let lock = Arc::new(RwLock::new(()));
-    b.iter(|| {
-        let lock = lock.clone();
-        rt.block_on(async move {
-            let write = lock.write().await;
-            let j = tokio::try_join! {
-                async move { drop(write); Ok(()) },
-                task::spawn(task(lock.clone())),
-                task::spawn(task(lock.clone())),
-                task::spawn(task(lock.clone())),
-                task::spawn(task(lock.clone())),
-                task::spawn(task(lock.clone())),
-            };
-            j.unwrap();
-        })
-    });
-}
-
-fn read_concurrent_contended(b: &mut Bencher) {
-    let rt = tokio::runtime::Builder::new_current_thread()
-        .build()
-        .unwrap();
-
-    async fn task(lock: Arc<RwLock<()>>) {
-        let read = lock.read().await;
-        black_box(read);
-    }
-
-    let lock = Arc::new(RwLock::new(()));
-    b.iter(|| {
-        let lock = lock.clone();
-        rt.block_on(async move {
-            let write = lock.write().await;
-            tokio::join! {
-                async move { drop(write) },
-                task(lock.clone()),
-                task(lock.clone()),
-                task(lock.clone()),
-                task(lock.clone()),
-                task(lock.clone()),
-            };
-        })
-    });
-}
-
-bencher::benchmark_group!(
-    sync_rwlock,
-    read_uncontended,
-    read_concurrent_uncontended,
-    read_concurrent_uncontended_multi,
-    read_concurrent_contended,
-    read_concurrent_contended_multi
-);
-
-bencher::benchmark_main!(sync_rwlock);

benches/sync_semaphore.rs

@@ -1,125 +0,0 @@
-use bencher::Bencher;
-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)
-        .build()
-        .unwrap();
-
-    let s = Arc::new(Semaphore::new(10));
-    b.iter(|| {
-        let s = s.clone();
-        rt.block_on(async move {
-            for _ in 0..6 {
-                let permit = s.acquire().await;
-                drop(permit);
-            }
-        })
-    });
-}
-
-async fn task(s: Arc<Semaphore>) {
-    let permit = s.acquire().await;
-    drop(permit);
-}
-
-fn uncontended_concurrent_multi(b: &mut Bencher) {
-    let rt = tokio::runtime::Builder::new_multi_thread()
-        .worker_threads(6)
-        .build()
-        .unwrap();
-
-    let s = Arc::new(Semaphore::new(10));
-    b.iter(|| {
-        let s = s.clone();
-        rt.block_on(async move {
-            let j = tokio::try_join! {
-                task::spawn(task(s.clone())),
-                task::spawn(task(s.clone())),
-                task::spawn(task(s.clone())),
-                task::spawn(task(s.clone())),
-                task::spawn(task(s.clone())),
-                task::spawn(task(s.clone()))
-            };
-            j.unwrap();
-        })
-    });
-}
-
-fn uncontended_concurrent_single(b: &mut Bencher) {
-    let rt = tokio::runtime::Builder::new_current_thread()
-        .build()
-        .unwrap();
-
-    let s = Arc::new(Semaphore::new(10));
-    b.iter(|| {
-        let s = s.clone();
-        rt.block_on(async move {
-            tokio::join! {
-                task(s.clone()),
-                task(s.clone()),
-                task(s.clone()),
-                task(s.clone()),
-                task(s.clone()),
-                task(s.clone())
-            };
-        })
-    });
-}
-
-fn contended_concurrent_multi(b: &mut Bencher) {
-    let rt = tokio::runtime::Builder::new_multi_thread()
-        .worker_threads(6)
-        .build()
-        .unwrap();
-
-    let s = Arc::new(Semaphore::new(5));
-    b.iter(|| {
-        let s = s.clone();
-        rt.block_on(async move {
-            let j = tokio::try_join! {
-                task::spawn(task(s.clone())),
-                task::spawn(task(s.clone())),
-                task::spawn(task(s.clone())),
-                task::spawn(task(s.clone())),
-                task::spawn(task(s.clone())),
-                task::spawn(task(s.clone()))
-            };
-            j.unwrap();
-        })
-    });
-}
-
-fn contended_concurrent_single(b: &mut Bencher) {
-    let rt = tokio::runtime::Builder::new_current_thread()
-        .build()
-        .unwrap();
-
-    let s = Arc::new(Semaphore::new(5));
-    b.iter(|| {
-        let s = s.clone();
-        rt.block_on(async move {
-            tokio::join! {
-                task(s.clone()),
-                task(s.clone()),
-                task(s.clone()),
-                task(s.clone()),
-                task(s.clone()),
-                task(s.clone())
-            };
-        })
-    });
-}
-
-bencher::benchmark_group!(
-    sync_semaphore,
-    uncontended,
-    uncontended_concurrent_multi,
-    uncontended_concurrent_single,
-    contended_concurrent_multi,
-    contended_concurrent_single
-);
-
-bencher::benchmark_main!(sync_semaphore);

benches/tcp.rs

@@ -0,0 +1,260 @@
+#![feature(test)]
+
+extern crate futures;
+extern crate tokio;
+
+#[macro_use]
+extern crate tokio_io;
+
+pub extern crate test;
+
+mod prelude {
+    pub use futures::*;
+    pub use tokio::net::{TcpListener, TcpStream};
+    pub use tokio::reactor::Reactor;
+    pub use tokio_io::io::read_to_end;
+
+    pub use std::io::{self, Read, Write};
+    pub use std::thread;
+    pub use std::time::Duration;
+    pub use test::{self, Bencher};
+}
+
+mod connect_churn {
+    use prelude::*;
+
+    const NUM: usize = 300;
+    const CONCURRENT: usize = 8;
+
+    #[bench]
+    fn one_thread(b: &mut Bencher) {
+        let addr = "127.0.0.1:0".parse().unwrap();
+
+        b.iter(move || {
+            let listener = TcpListener::bind(&addr).unwrap();
+            let addr = listener.local_addr().unwrap();
+
+            // Spawn a single future that accepts & drops connections
+            let serve_incomings = listener
+                .incoming()
+                .map_err(|e| panic!("server err: {:?}", e))
+                .for_each(|_| Ok(()));
+
+            let connects = stream::iter_result((0..NUM).map(|_| {
+                Ok(TcpStream::connect(&addr).and_then(|sock| {
+                    sock.set_linger(Some(Duration::from_secs(0))).unwrap();
+                    read_to_end(sock, vec![])
+                }))
+            }));
+
+            let connects_concurrent = connects
+                .buffer_unordered(CONCURRENT)
+                .map_err(|e| panic!("client err: {:?}", e))
+                .for_each(|_| Ok(()));
+
+            serve_incomings
+                .select(connects_concurrent)
+                .map(|_| ())
+                .map_err(|_| ())
+                .wait()
+                .unwrap();
+        });
+    }
+
+    fn n_workers(n: usize, b: &mut Bencher) {
+        let (shutdown_tx, shutdown_rx) = sync::oneshot::channel();
+        let (addr_tx, addr_rx) = sync::oneshot::channel();
+
+        // Spawn reactor thread
+        let server_thread = thread::spawn(move || {
+            // Bind the TCP listener
+            let listener = TcpListener::bind(&"127.0.0.1:0".parse().unwrap()).unwrap();
+
+            // Get the address being listened on.
+            let addr = listener.local_addr().unwrap();
+
+            // Send the remote & address back to the main thread
+            addr_tx.send(addr).unwrap();
+
+            // Spawn a single future that accepts & drops connections
+            let serve_incomings = listener
+                .incoming()
+                .map_err(|e| panic!("server err: {:?}", e))
+                .for_each(|_| Ok(()));
+
+            // Run server
+            serve_incomings
+                .select(shutdown_rx)
+                .map(|_| ())
+                .map_err(|_| ())
+                .wait()
+                .unwrap();
+        });
+
+        // Get the bind addr of the server
+        let addr = addr_rx.wait().unwrap();
+
+        b.iter(move || {
+            use std::sync::{Arc, Barrier};
+
+            // Create a barrier to coordinate threads
+            let barrier = Arc::new(Barrier::new(n + 1));
+
+            // Spawn worker threads
+            let threads: Vec<_> = (0..n)
+                .map(|_| {
+                    let barrier = barrier.clone();
+                    let addr = addr.clone();
+
+                    thread::spawn(move || {
+                        let connects = stream::iter_result((0..(NUM / n)).map(|_| {
+                            Ok(TcpStream::connect(&addr)
+                                .map_err(|e| panic!("connect err: {:?}", e))
+                                .and_then(|sock| {
+                                    sock.set_linger(Some(Duration::from_secs(0))).unwrap();
+                                    read_to_end(sock, vec![])
+                                }))
+                        }));
+
+                        barrier.wait();
+
+                        connects
+                            .buffer_unordered(CONCURRENT)
+                            .map_err(|e| panic!("client err: {:?}", e))
+                            .for_each(|_| Ok(()))
+                            .wait()
+                            .unwrap();
+                    })
+                })
+                .collect();
+
+            barrier.wait();
+
+            for th in threads {
+                th.join().unwrap();
+            }
+        });
+
+        // Shutdown the server
+        shutdown_tx.send(()).unwrap();
+        server_thread.join().unwrap();
+    }
+
+    #[bench]
+    fn two_threads(b: &mut Bencher) {
+        n_workers(1, b);
+    }
+
+    #[bench]
+    fn multi_threads(b: &mut Bencher) {
+        n_workers(4, b);
+    }
+}
+
+mod transfer {
+    use prelude::*;
+    use std::{cmp, mem};
+
+    const MB: usize = 3 * 1024 * 1024;
+
+    struct Drain {
+        sock: TcpStream,
+        chunk: usize,
+    }
+
+    impl Future for Drain {
+        type Item = ();
+        type Error = io::Error;
+
+        fn poll(&mut self) -> Poll<(), io::Error> {
+            let mut buf: [u8; 1024] = unsafe { mem::uninitialized() };
+
+            loop {
+                match try_nb!(self.sock.read(&mut buf[..self.chunk])) {
+                    0 => return Ok(Async::Ready(())),
+                    _ => {}
+                }
+            }
+        }
+    }
+
+    struct Transfer {
+        sock: TcpStream,
+        rem: usize,
+        chunk: usize,
+    }
+
+    impl Future for Transfer {
+        type Item = ();
+        type Error = io::Error;
+
+        fn poll(&mut self) -> Poll<(), io::Error> {
+            while self.rem > 0 {
+                let len = cmp::min(self.rem, self.chunk);
+                let buf = &DATA[..len];
+
+                let n = try_nb!(self.sock.write(&buf));
+                self.rem -= n;
+            }
+
+            Ok(Async::Ready(()))
+        }
+    }
+
+    static DATA: [u8; 1024] = [0; 1024];
+
+    fn one_thread(b: &mut Bencher, read_size: usize, write_size: usize) {
+        let addr = "127.0.0.1:0".parse().unwrap();
+
+        b.iter(move || {
+            let listener = TcpListener::bind(&addr).unwrap();
+            let addr = listener.local_addr().unwrap();
+
+            // Spawn a single future that accepts 1 connection, Drain it and drops
+            let server = listener
+                .incoming()
+                .into_future() // take the first connection
+                .map_err(|(e, _other_incomings)| e)
+                .map(|(connection, _other_incomings)| connection.unwrap())
+                .and_then(|sock| {
+                    sock.set_linger(Some(Duration::from_secs(0))).unwrap();
+                    let drain = Drain {
+                        sock: sock,
+                        chunk: read_size,
+                    };
+                    drain
+                        .map(|_| ())
+                        .map_err(|e| panic!("server error: {:?}", e))
+                })
+                .map_err(|e| panic!("server err: {:?}", e));
+
+            let client = TcpStream::connect(&addr)
+                .and_then(move |sock| Transfer {
+                    sock: sock,
+                    rem: MB,
+                    chunk: write_size,
+                })
+                .map_err(|e| panic!("client err: {:?}", e));
+
+            server.join(client).wait().unwrap();
+        });
+    }
+
+    mod small_chunks {
+        use prelude::*;
+
+        #[bench]
+        fn one_thread(b: &mut Bencher) {
+            super::one_thread(b, 32, 32);
+        }
+    }
+
+    mod big_chunks {
+        use prelude::*;
+
+        #[bench]
+        fn one_thread(b: &mut Bencher) {
+            super::one_thread(b, 1_024, 1_024);
+        }
+    }
+}

bin/publish

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

bin/update-doc

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

ci/azure-cargo-check.yml

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

ci/azure-check-minrust.yml

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

ci/azure-cross-compile.yml

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

ci/azure-deploy-docs.yml

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

ci/azure-install-rust.yml

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

ci/azure-is-release.yml

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

ci/azure-patch-crates.yml

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

ci/azure-rustfmt.yml

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

ci/azure-test-stable.yml

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

ci/azure-tsan.yml

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

ci/patch.toml

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

ci/tsan

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

examples/Cargo.toml

@@ -1,87 +0,0 @@
-[package]
-name = "examples"
-version = "0.0.0"
-publish = false
-edition = "2018"
-
-# If you copy one of the examples into a new project, you should be using
-# [dependencies] instead, and delete the **path**.
-[dev-dependencies]
-tokio = { version = "1.0.0", path = "../tokio", features = ["full", "tracing"] }
-tokio-util = { version = "0.7.0", path = "../tokio-util", features = ["full"] }
-tokio-stream = { version = "0.1", path = "../tokio-stream" }
-
-tracing = "0.1"
-tracing-subscriber = { version = "0.3.1", default-features = false, features = ["fmt", "ansi", "env-filter", "tracing-log"] }
-bytes = "1.0.0"
-futures = { version = "0.3.0", features = ["thread-pool"]}
-http = "0.2"
-serde = "1.0"
-serde_derive = "1.0"
-serde_json = "1.0"
-httparse = "1.0"
-httpdate = "1.0"
-rand = "0.8.3"
-
-[target.'cfg(windows)'.dev-dependencies.winapi]
-version = "0.3.8"
-
-[[example]]
-name = "chat"
-path = "chat.rs"
-
-[[example]]
-name = "connect"
-path = "connect.rs"
-
-[[example]]
-name = "echo-udp"
-path = "echo-udp.rs"
-
-[[example]]
-name = "echo"
-path = "echo.rs"
-
-[[example]]
-name = "hello_world"
-path = "hello_world.rs"
-
-[[example]]
-name = "print_each_packet"
-path = "print_each_packet.rs"
-
-[[example]]
-name = "proxy"
-path = "proxy.rs"
-
-[[example]]
-name = "tinydb"
-path = "tinydb.rs"
-
-[[example]]
-name = "udp-client"
-path = "udp-client.rs"
-
-[[example]]
-name = "udp-codec"
-path = "udp-codec.rs"
-
-[[example]]
-name = "tinyhttp"
-path = "tinyhttp.rs"
-
-[[example]]
-name = "custom-executor-tokio-context"
-path = "custom-executor-tokio-context.rs"
-
-[[example]]
-name = "named-pipe"
-path = "named-pipe.rs"
-
-[[example]]
-name = "named-pipe-ready"
-path = "named-pipe-ready.rs"
-
-[[example]]
-name = "named-pipe-multi-client"
-path = "named-pipe-multi-client.rs"

examples/README.md

@@ -1,23 +0,0 @@
-## Examples of how to use Tokio
-
-This directory contains a number of examples showcasing various capabilities of
-the `tokio` crate.
-
-All examples can be executed with:
-
-```
-cargo run --example $name
-```
-
-A good starting point for the examples would be [`hello_world`](hello_world.rs)
-and [`echo`](echo.rs). Additionally [the tokio website][tokioweb] contains
-additional guides for some of the examples.
-
-For a larger "real world" example, see the [`mini-redis`][redis] repository.
-
-If you've got an example you'd like to see here, please feel free to open an
-issue. Otherwise if you've got an example you'd like to add, please feel free
-to make a PR!
-
-[tokioweb]: https://tokio.rs/tokio/tutorial
-[redis]: https://github.com/tokio-rs/mini-redis

examples/chat.rs

@@ -1,243 +0,0 @@
-//! A chat server that broadcasts a message to all connections.
-//!
-//! This example is explicitly more verbose than it has to be. This is to
-//! illustrate more concepts.
-//!
-//! A chat server for telnet clients. After a telnet client connects, the first
-//! line should contain the client's name. After that, all lines sent by a
-//! client are broadcasted to all other connected clients.
-//!
-//! Because the client is telnet, lines are delimited by "\r\n".
-//!
-//! You can test this out by running:
-//!
-//!     cargo run --example chat
-//!
-//! And then in another terminal run:
-//!
-//!     telnet localhost 6142
-//!
-//! You can run the `telnet` command in any number of additional windows.
-//!
-//! You can run the second command in multiple windows and then chat between the
-//! two, seeing the messages from the other client as they're received. For all
-//! connected clients they'll all join the same room and see everyone else's
-//! messages.
-
-#![warn(rust_2018_idioms)]
-
-use tokio::net::{TcpListener, TcpStream};
-use tokio::sync::{mpsc, Mutex};
-use tokio_stream::StreamExt;
-use tokio_util::codec::{Framed, LinesCodec};
-
-use futures::SinkExt;
-use std::collections::HashMap;
-use std::env;
-use std::error::Error;
-use std::io;
-use std::net::SocketAddr;
-use std::sync::Arc;
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn Error>> {
-    use tracing_subscriber::{fmt::format::FmtSpan, EnvFilter};
-    // Configure a `tracing` subscriber that logs traces emitted by the chat
-    // server.
-    tracing_subscriber::fmt()
-        // Filter what traces are displayed based on the RUST_LOG environment
-        // variable.
-        //
-        // Traces emitted by the example code will always be displayed. You
-        // can set `RUST_LOG=tokio=trace` to enable additional traces emitted by
-        // Tokio itself.
-        .with_env_filter(EnvFilter::from_default_env().add_directive("chat=info".parse()?))
-        // Log events when `tracing` spans are created, entered, exited, or
-        // closed. When Tokio's internal tracing support is enabled (as
-        // described above), this can be used to track the lifecycle of spawned
-        // tasks on the Tokio runtime.
-        .with_span_events(FmtSpan::FULL)
-        // Set this subscriber as the default, to collect all traces emitted by
-        // the program.
-        .init();
-
-    // Create the shared state. This is how all the peers communicate.
-    //
-    // The server task will hold a handle to this. For every new client, the
-    // `state` handle is cloned and passed into the task that processes the
-    // client connection.
-    let state = Arc::new(Mutex::new(Shared::new()));
-
-    let addr = env::args()
-        .nth(1)
-        .unwrap_or_else(|| "127.0.0.1:6142".to_string());
-
-    // 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?;
-
-    tracing::info!("server running on {}", addr);
-
-    loop {
-        // Asynchronously wait for an inbound TcpStream.
-        let (stream, addr) = listener.accept().await?;
-
-        // Clone a handle to the `Shared` state for the new connection.
-        let state = Arc::clone(&state);
-
-        // Spawn our handler to be run asynchronously.
-        tokio::spawn(async move {
-            tracing::debug!("accepted connection");
-            if let Err(e) = process(state, stream, addr).await {
-                tracing::info!("an error occurred; error = {:?}", e);
-            }
-        });
-    }
-}
-
-/// Shorthand for the transmit half of the message channel.
-type Tx = mpsc::UnboundedSender<String>;
-
-/// Shorthand for the receive half of the message channel.
-type Rx = mpsc::UnboundedReceiver<String>;
-
-/// Data that is shared between all peers in the chat server.
-///
-/// This is the set of `Tx` handles for all connected clients. Whenever a
-/// message is received from a client, it is broadcasted to all peers by
-/// iterating over the `peers` entries and sending a copy of the message on each
-/// `Tx`.
-struct Shared {
-    peers: HashMap<SocketAddr, Tx>,
-}
-
-/// The state for each connected client.
-struct Peer {
-    /// The TCP socket wrapped with the `Lines` codec, defined below.
-    ///
-    /// This handles sending and receiving data on the socket. When using
-    /// `Lines`, we can work at the line level instead of having to manage the
-    /// raw byte operations.
-    lines: Framed<TcpStream, LinesCodec>,
-
-    /// Receive half of the message channel.
-    ///
-    /// This is used to receive messages from peers. When a message is received
-    /// off of this `Rx`, it will be written to the socket.
-    rx: Rx,
-}
-
-impl Shared {
-    /// Create a new, empty, instance of `Shared`.
-    fn new() -> Self {
-        Shared {
-            peers: HashMap::new(),
-        }
-    }
-
-    /// Send a `LineCodec` encoded message to every peer, except
-    /// for the sender.
-    async fn broadcast(&mut self, sender: SocketAddr, message: &str) {
-        for peer in self.peers.iter_mut() {
-            if *peer.0 != sender {
-                let _ = peer.1.send(message.into());
-            }
-        }
-    }
-}
-
-impl Peer {
-    /// Create a new instance of `Peer`.
-    async fn new(
-        state: Arc<Mutex<Shared>>,
-        lines: Framed<TcpStream, LinesCodec>,
-    ) -> io::Result<Peer> {
-        // Get the client socket address
-        let addr = lines.get_ref().peer_addr()?;
-
-        // Create a channel for this peer
-        let (tx, rx) = mpsc::unbounded_channel();
-
-        // Add an entry for this `Peer` in the shared state map.
-        state.lock().await.peers.insert(addr, tx);
-
-        Ok(Peer { lines, rx })
-    }
-}
-
-/// Process an individual chat client
-async fn process(
-    state: Arc<Mutex<Shared>>,
-    stream: TcpStream,
-    addr: SocketAddr,
-) -> Result<(), Box<dyn Error>> {
-    let mut lines = Framed::new(stream, LinesCodec::new());
-
-    // Send a prompt to the client to enter their username.
-    lines.send("Please enter your username:").await?;
-
-    // Read the first line from the `LineCodec` stream to get the username.
-    let username = match lines.next().await {
-        Some(Ok(line)) => line,
-        // We didn't get a line so we return early here.
-        _ => {
-            tracing::error!("Failed to get username from {}. Client disconnected.", addr);
-            return Ok(());
-        }
-    };
-
-    // Register our peer with state which internally sets up some channels.
-    let mut peer = Peer::new(state.clone(), lines).await?;
-
-    // A client has connected, let's let everyone know.
-    {
-        let mut state = state.lock().await;
-        let msg = format!("{} has joined the chat", username);
-        tracing::info!("{}", msg);
-        state.broadcast(addr, &msg).await;
-    }
-
-    // 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() => {
-                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,
-            },
-        }
-    }
-
-    // If this section is reached it means that the client was disconnected!
-    // Let's let everyone still connected know about it.
-    {
-        let mut state = state.lock().await;
-        state.peers.remove(&addr);
-
-        let msg = format!("{} has left the chat", username);
-        tracing::info!("{}", msg);
-        state.broadcast(addr, &msg).await;
-    }
-
-    Ok(())
-}

examples/connect.rs

@@ -1,147 +0,0 @@
-//! An example of hooking up stdin/stdout to either a TCP or UDP stream.
-//!
-//! This example will connect to a socket address specified in the argument list
-//! and then forward all data read on stdin to the server, printing out all data
-//! received on stdout. An optional `--udp` argument can be passed to specify
-//! that the connection should be made over UDP instead of TCP, translating each
-//! line entered on stdin to a UDP packet to be sent to the remote address.
-//!
-//! Note that this is not currently optimized for performance, especially
-//! around buffer management. Rather it's intended to show an example of
-//! working with a client.
-//!
-//! This example can be quite useful when interacting with the other examples in
-//! this repository! Many of them recommend running this as a simple "hook up
-//! stdin/stdout to a server" to get up and running.
-
-#![warn(rust_2018_idioms)]
-
-use futures::StreamExt;
-use tokio::io;
-use tokio_util::codec::{BytesCodec, FramedRead, FramedWrite};
-
-use std::env;
-use std::error::Error;
-use std::net::SocketAddr;
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn Error>> {
-    // Determine if we're going to run in TCP or UDP mode
-    let mut args = env::args().skip(1).collect::<Vec<_>>();
-    let tcp = match args.iter().position(|a| a == "--udp") {
-        Some(i) => {
-            args.remove(i);
-            false
-        }
-        None => true,
-    };
-
-    // Parse what address we're going to connect to
-    let addr = args
-        .first()
-        .ok_or("this program requires at least one argument")?;
-    let addr = addr.parse::<SocketAddr>()?;
-
-    let stdin = FramedRead::new(io::stdin(), BytesCodec::new());
-    let stdin = stdin.map(|i| i.map(|bytes| bytes.freeze()));
-    let stdout = FramedWrite::new(io::stdout(), BytesCodec::new());
-
-    if tcp {
-        tcp::connect(&addr, stdin, stdout).await?;
-    } else {
-        udp::connect(&addr, stdin, stdout).await?;
-    }
-
-    Ok(())
-}
-
-mod tcp {
-    use bytes::Bytes;
-    use futures::{future, Sink, SinkExt, Stream, StreamExt};
-    use std::{error::Error, io, net::SocketAddr};
-    use tokio::net::TcpStream;
-    use tokio_util::codec::{BytesCodec, FramedRead, FramedWrite};
-
-    pub async fn connect(
-        addr: &SocketAddr,
-        mut stdin: impl Stream<Item = Result<Bytes, io::Error>> + Unpin,
-        mut stdout: impl Sink<Bytes, Error = io::Error> + Unpin,
-    ) -> Result<(), Box<dyn Error>> {
-        let mut stream = TcpStream::connect(addr).await?;
-        let (r, w) = stream.split();
-        let mut sink = FramedWrite::new(w, BytesCodec::new());
-        // filter map Result<BytesMut, Error> stream into just a Bytes stream to match stdout Sink
-        // on the event of an Error, log the error and end the stream
-        let mut stream = FramedRead::new(r, BytesCodec::new())
-            .filter_map(|i| match i {
-                //BytesMut into Bytes
-                Ok(i) => future::ready(Some(i.freeze())),
-                Err(e) => {
-                    println!("failed to read from socket; error={}", e);
-                    future::ready(None)
-                }
-            })
-            .map(Ok);
-
-        match future::join(sink.send_all(&mut stdin), stdout.send_all(&mut stream)).await {
-            (Err(e), _) | (_, Err(e)) => Err(e.into()),
-            _ => Ok(()),
-        }
-    }
-}
-
-mod udp {
-    use bytes::Bytes;
-    use futures::{Sink, SinkExt, Stream, StreamExt};
-    use std::error::Error;
-    use std::io;
-    use std::net::SocketAddr;
-    use tokio::net::UdpSocket;
-
-    pub async fn connect(
-        addr: &SocketAddr,
-        stdin: impl Stream<Item = Result<Bytes, io::Error>> + Unpin,
-        stdout: impl Sink<Bytes, Error = io::Error> + Unpin,
-    ) -> Result<(), Box<dyn Error>> {
-        // We'll bind our UDP socket to a local IP/port, but for now we
-        // basically let the OS pick both of those.
-        let bind_addr = if addr.ip().is_ipv4() {
-            "0.0.0.0:0"
-        } else {
-            "[::]:0"
-        };
-
-        let socket = UdpSocket::bind(&bind_addr).await?;
-        socket.connect(addr).await?;
-
-        tokio::try_join!(send(stdin, &socket), recv(stdout, &socket))?;
-
-        Ok(())
-    }
-
-    async fn send(
-        mut stdin: impl Stream<Item = Result<Bytes, io::Error>> + Unpin,
-        writer: &UdpSocket,
-    ) -> Result<(), io::Error> {
-        while let Some(item) = stdin.next().await {
-            let buf = item?;
-            writer.send(&buf[..]).await?;
-        }
-
-        Ok(())
-    }
-
-    async fn recv(
-        mut stdout: impl Sink<Bytes, Error = io::Error> + Unpin,
-        reader: &UdpSocket,
-    ) -> Result<(), io::Error> {
-        loop {
-            let mut buf = vec![0; 1024];
-            let n = reader.recv(&mut buf[..]).await?;
-
-            if n > 0 {
-                stdout.send(Bytes::from(buf)).await?;
-            }
-        }
-    }
-}

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.rs

@@ -1,78 +0,0 @@
-//! A "hello world" echo server with Tokio
-//!
-//! This server will create a TCP listener, accept connections in a loop, and
-//! write back everything that's read off of each TCP connection.
-//!
-//! Because the Tokio runtime uses a thread pool, each TCP connection is
-//! processed concurrently with all other TCP connections across multiple
-//! threads.
-//!
-//! To see this server in action, you can run this in one terminal:
-//!
-//!     cargo run --example echo
-//!
-//! and in another terminal you can run:
-//!
-//!     cargo run --example connect 127.0.0.1:8080
-//!
-//! Each line you type in to the `connect` terminal should be echo'd back to
-//! you! If you open up multiple terminals running the `connect` example you
-//! should be able to see them all make progress simultaneously.
-
-#![warn(rust_2018_idioms)]
-
-use tokio::io::{AsyncReadExt, AsyncWriteExt};
-use tokio::net::TcpListener;
-
-use std::env;
-use std::error::Error;
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn Error>> {
-    // Allow passing an address to listen on as the first argument of this
-    // program, but otherwise we'll just set up our TCP listener on
-    // 127.0.0.1:8080 for connections.
-    let addr = env::args()
-        .nth(1)
-        .unwrap_or_else(|| "127.0.0.1:8080".to_string());
-
-    // 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?;
-    println!("Listening on: {}", addr);
-
-    loop {
-        // Asynchronously wait for an inbound socket.
-        let (mut socket, _) = listener.accept().await?;
-
-        // And this is where much of the magic of this server happens. We
-        // crucially want all clients to make progress concurrently, rather than
-        // blocking one on completion of another. To achieve this we use the
-        // `tokio::spawn` function to execute the work in the background.
-        //
-        // Essentially here we're executing a new task to run concurrently,
-        // which will allow all of our clients to be processed concurrently.
-
-        tokio::spawn(async move {
-            let mut buf = vec![0; 1024];
-
-            // In a loop, read data from the socket and write the data back.
-            loop {
-                let n = socket
-                    .read(&mut buf)
-                    .await
-                    .expect("failed to read data from socket");
-
-                if n == 0 {
-                    return;
-                }
-
-                socket
-                    .write_all(&buf[0..n])
-                    .await
-                    .expect("failed to write data to socket");
-            }
-        });
-    }
-}

examples/hello_world.rs

@@ -1,33 +0,0 @@
-//! Hello world server.
-//!
-//! A simple client that opens a TCP stream, writes "hello world\n", and closes
-//! the connection.
-//!
-//! You can test this out by running:
-//!
-//!     ncat -l 6142
-//!
-//! And then in another terminal run:
-//!
-//!     cargo run --example hello_world
-
-#![warn(rust_2018_idioms)]
-
-use tokio::io::AsyncWriteExt;
-use tokio::net::TcpStream;
-
-use std::error::Error;
-
-#[tokio::main]
-pub async fn main() -> Result<(), Box<dyn Error>> {
-    // Open a TCP stream to the socket address.
-    //
-    // Note that this is the Tokio TcpStream, which is fully async.
-    let mut stream = TcpStream::connect("127.0.0.1:6142").await?;
-    println!("created stream");
-
-    let result = stream.write(b"hello world\n").await;
-    println!("wrote to stream; success={:?}", result.is_ok());
-
-    Ok(())
-}

examples/named-pipe-multi-client.rs

@@ -1,98 +0,0 @@
-use std::io;
-
-#[cfg(windows)]
-async fn windows_main() -> io::Result<()> {
-    use std::time::Duration;
-    use tokio::io::{AsyncReadExt, AsyncWriteExt};
-    use tokio::net::windows::named_pipe::{ClientOptions, ServerOptions};
-    use tokio::time;
-    use winapi::shared::winerror;
-
-    const PIPE_NAME: &str = r"\\.\pipe\named-pipe-multi-client";
-    const N: usize = 10;
-
-    // The first server needs to be constructed early so that clients can
-    // be correctly connected. Otherwise a waiting client will error.
-    //
-    // Here we also make use of `first_pipe_instance`, which will ensure
-    // that there are no other servers up and running already.
-    let mut server = ServerOptions::new()
-        .first_pipe_instance(true)
-        .create(PIPE_NAME)?;
-
-    let server = tokio::spawn(async move {
-        // Artificial workload.
-        time::sleep(Duration::from_secs(1)).await;
-
-        for _ in 0..N {
-            // Wait for client to connect.
-            server.connect().await?;
-            let mut inner = server;
-
-            // Construct the next server to be connected before sending the one
-            // we already have of onto a task. This ensures that the server
-            // isn't closed (after it's done in the task) before a new one is
-            // available. Otherwise the client might error with
-            // `io::ErrorKind::NotFound`.
-            server = ServerOptions::new().create(PIPE_NAME)?;
-
-            let _ = tokio::spawn(async move {
-                let mut buf = vec![0u8; 4];
-                inner.read_exact(&mut buf).await?;
-                inner.write_all(b"pong").await?;
-                Ok::<_, io::Error>(())
-            });
-        }
-
-        Ok::<_, io::Error>(())
-    });
-
-    let mut clients = Vec::new();
-
-    for _ in 0..N {
-        clients.push(tokio::spawn(async move {
-            // This showcases a generic connect loop.
-            //
-            // We immediately try to create a client, if it's not found or
-            // the pipe is busy we use the specialized wait function on the
-            // client builder.
-            let mut client = loop {
-                match ClientOptions::new().open(PIPE_NAME) {
-                    Ok(client) => break client,
-                    Err(e) if e.raw_os_error() == Some(winerror::ERROR_PIPE_BUSY as i32) => (),
-                    Err(e) => return Err(e),
-                }
-
-                time::sleep(Duration::from_millis(5)).await;
-            };
-
-            let mut buf = [0u8; 4];
-            client.write_all(b"ping").await?;
-            client.read_exact(&mut buf).await?;
-            Ok::<_, io::Error>(buf)
-        }));
-    }
-
-    for client in clients {
-        let result = client.await?;
-        assert_eq!(&result?[..], b"pong");
-    }
-
-    server.await??;
-    Ok(())
-}
-
-#[tokio::main]
-async fn main() -> io::Result<()> {
-    #[cfg(windows)]
-    {
-        windows_main().await?;
-    }
-
-    #[cfg(not(windows))]
-    {
-        println!("Named pipes are only supported on Windows!");
-    }
-
-    Ok(())
-}

examples/named-pipe-ready.rs

@@ -1,161 +0,0 @@
-use std::io;
-
-#[cfg(windows)]
-async fn windows_main() -> io::Result<()> {
-    use tokio::io::Interest;
-    use tokio::net::windows::named_pipe::{ClientOptions, ServerOptions};
-
-    const PIPE_NAME: &str = r"\\.\pipe\named-pipe-single-client";
-
-    let server = ServerOptions::new().create(PIPE_NAME)?;
-
-    let server = tokio::spawn(async move {
-        // Note: we wait for a client to connect.
-        server.connect().await?;
-
-        let buf = {
-            let mut read_buf = [0u8; 5];
-            let mut read_buf_cursor = 0;
-
-            loop {
-                server.readable().await?;
-
-                let buf = &mut read_buf[read_buf_cursor..];
-
-                match server.try_read(buf) {
-                    Ok(n) => {
-                        read_buf_cursor += n;
-
-                        if read_buf_cursor == read_buf.len() {
-                            break;
-                        }
-                    }
-                    Err(e) if e.kind() == io::ErrorKind::WouldBlock => {
-                        continue;
-                    }
-                    Err(e) => {
-                        return Err(e);
-                    }
-                }
-            }
-
-            read_buf
-        };
-
-        {
-            let write_buf = b"pong\n";
-            let mut write_buf_cursor = 0;
-
-            loop {
-                let buf = &write_buf[write_buf_cursor..];
-
-                if buf.is_empty() {
-                    break;
-                }
-
-                server.writable().await?;
-
-                match server.try_write(buf) {
-                    Ok(n) => {
-                        write_buf_cursor += n;
-                    }
-                    Err(e) if e.kind() == io::ErrorKind::WouldBlock => {
-                        continue;
-                    }
-                    Err(e) => {
-                        return Err(e);
-                    }
-                }
-            }
-        }
-
-        Ok::<_, io::Error>(buf)
-    });
-
-    let client = tokio::spawn(async move {
-        // There's no need to use a connect loop here, since we know that the
-        // server is already up - `open` was called before spawning any of the
-        // tasks.
-        let client = ClientOptions::new().open(PIPE_NAME)?;
-
-        let mut read_buf = [0u8; 5];
-        let mut read_buf_cursor = 0;
-        let write_buf = b"ping\n";
-        let mut write_buf_cursor = 0;
-
-        loop {
-            let mut interest = Interest::READABLE;
-            if write_buf_cursor < write_buf.len() {
-                interest |= Interest::WRITABLE;
-            }
-
-            let ready = client.ready(interest).await?;
-
-            if ready.is_readable() {
-                let buf = &mut read_buf[read_buf_cursor..];
-
-                match client.try_read(buf) {
-                    Ok(n) => {
-                        read_buf_cursor += n;
-
-                        if read_buf_cursor == read_buf.len() {
-                            break;
-                        }
-                    }
-                    Err(e) if e.kind() == io::ErrorKind::WouldBlock => {
-                        continue;
-                    }
-                    Err(e) => {
-                        return Err(e);
-                    }
-                }
-            }
-
-            if ready.is_writable() {
-                let buf = &write_buf[write_buf_cursor..];
-
-                if buf.is_empty() {
-                    continue;
-                }
-
-                match client.try_write(buf) {
-                    Ok(n) => {
-                        write_buf_cursor += n;
-                    }
-                    Err(e) if e.kind() == io::ErrorKind::WouldBlock => {
-                        continue;
-                    }
-                    Err(e) => {
-                        return Err(e);
-                    }
-                }
-            }
-        }
-
-        let buf = String::from_utf8_lossy(&read_buf).into_owned();
-
-        Ok::<_, io::Error>(buf)
-    });
-
-    let (server, client) = tokio::try_join!(server, client)?;
-
-    assert_eq!(server?, *b"ping\n");
-    assert_eq!(client?, "pong\n");
-
-    Ok(())
-}
-
-#[tokio::main]
-async fn main() -> io::Result<()> {
-    #[cfg(windows)]
-    {
-        windows_main().await?;
-    }
-
-    #[cfg(not(windows))]
-    {
-        println!("Named pipes are only supported on Windows!");
-    }
-
-    Ok(())
-}

examples/named-pipe.rs

@@ -1,60 +0,0 @@
-use std::io;
-
-#[cfg(windows)]
-async fn windows_main() -> io::Result<()> {
-    use tokio::io::AsyncWriteExt;
-    use tokio::io::{AsyncBufReadExt, BufReader};
-    use tokio::net::windows::named_pipe::{ClientOptions, ServerOptions};
-
-    const PIPE_NAME: &str = r"\\.\pipe\named-pipe-single-client";
-
-    let server = ServerOptions::new().create(PIPE_NAME)?;
-
-    let server = tokio::spawn(async move {
-        // Note: we wait for a client to connect.
-        server.connect().await?;
-
-        let mut server = BufReader::new(server);
-
-        let mut buf = String::new();
-        server.read_line(&mut buf).await?;
-        server.write_all(b"pong\n").await?;
-        Ok::<_, io::Error>(buf)
-    });
-
-    let client = tokio::spawn(async move {
-        // There's no need to use a connect loop here, since we know that the
-        // server is already up - `open` was called before spawning any of the
-        // tasks.
-        let client = ClientOptions::new().open(PIPE_NAME)?;
-
-        let mut client = BufReader::new(client);
-
-        let mut buf = String::new();
-        client.write_all(b"ping\n").await?;
-        client.read_line(&mut buf).await?;
-        Ok::<_, io::Error>(buf)
-    });
-
-    let (server, client) = tokio::try_join!(server, client)?;
-
-    assert_eq!(server?, "ping\n");
-    assert_eq!(client?, "pong\n");
-
-    Ok(())
-}
-
-#[tokio::main]
-async fn main() -> io::Result<()> {
-    #[cfg(windows)]
-    {
-        windows_main().await?;
-    }
-
-    #[cfg(not(windows))]
-    {
-        println!("Named pipes are only supported on Windows!");
-    }
-
-    Ok(())
-}

examples/print_each_packet.rs

@@ -1,106 +0,0 @@
-//! A "print-each-packet" server with Tokio
-//!
-//! This server will create a TCP listener, accept connections in a loop, and
-//! put down in the stdout everything that's read off of each TCP connection.
-//!
-//! Because the Tokio runtime uses a thread pool, each TCP connection is
-//! processed concurrently with all other TCP connections across multiple
-//! threads.
-//!
-//! To see this server in action, you can run this in one terminal:
-//!
-//!     cargo run --example print\_each\_packet
-//!
-//! and in another terminal you can run:
-//!
-//!     cargo run --example connect 127.0.0.1:8080
-//!
-//! Each line you type in to the `connect` terminal should be written to terminal!
-//!
-//! Minimal js example:
-//!
-//! ```js
-//! var net = require("net");
-//!
-//! var listenPort = 8080;
-//!
-//! var server = net.createServer(function (socket) {
-//!     socket.on("data", function (bytes) {
-//!         console.log("bytes", bytes);
-//!     });
-//!
-//!     socket.on("end", function() {
-//!         console.log("Socket received FIN packet and closed connection");
-//!     });
-//!     socket.on("error", function (error) {
-//!         console.log("Socket closed with error", error);
-//!     });
-//!
-//!     socket.on("close", function (with_error) {
-//!         if (with_error) {
-//!             console.log("Socket closed with result: Err(SomeError)");
-//!         } else {
-//!             console.log("Socket closed with result: Ok(())");
-//!         }
-//!     });
-//!
-//! });
-//!
-//! server.listen(listenPort);
-//!
-//! console.log("Listening on:", listenPort);
-//! ```
-//!
-
-#![warn(rust_2018_idioms)]
-
-use tokio::net::TcpListener;
-use tokio_stream::StreamExt;
-use tokio_util::codec::{BytesCodec, Decoder};
-
-use std::env;
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    // Allow passing an address to listen on as the first argument of this
-    // program, but otherwise we'll just set up our TCP listener on
-    // 127.0.0.1:8080 for connections.
-    let addr = env::args()
-        .nth(1)
-        .unwrap_or_else(|| "127.0.0.1:8080".to_string());
-
-    // Next up we create a TCP listener which will listen for incoming
-    // connections. This TCP listener is bound to the address we determined
-    // above and must be associated with an event loop, so we pass in a handle
-    // to our event loop. After the socket's created we inform that we're ready
-    // to go and start accepting connections.
-    let listener = TcpListener::bind(&addr).await?;
-    println!("Listening on: {}", addr);
-
-    loop {
-        // Asynchronously wait for an inbound socket.
-        let (socket, _) = listener.accept().await?;
-
-        // And this is where much of the magic of this server happens. We
-        // crucially want all clients to make progress concurrently, rather than
-        // blocking one on completion of another. To achieve this we use the
-        // `tokio::spawn` function to execute the work in the background.
-        //
-        // Essentially here we're executing a new task to run concurrently,
-        // which will allow all of our clients to be processed concurrently.
-        tokio::spawn(async move {
-            // We're parsing each socket with the `BytesCodec` included in `tokio::codec`.
-            let mut framed = BytesCodec::new().framed(socket);
-
-            // We loop while there are messages coming from the Stream `framed`.
-            // The stream will return None once the client disconnects.
-            while let Some(message) = framed.next().await {
-                match message {
-                    Ok(bytes) => println!("bytes: {:?}", bytes),
-                    Err(err) => println!("Socket closed with error: {:?}", err),
-                }
-            }
-            println!("Socket received FIN packet and closed connection");
-        });
-    }
-}

examples/proxy.rs

@@ -1,79 +0,0 @@
-//! A proxy that forwards data to another server and forwards that server's
-//! responses back to clients.
-//!
-//! Because the Tokio runtime uses a thread pool, each TCP connection is
-//! processed concurrently with all other TCP connections across multiple
-//! threads.
-//!
-//! You can showcase this by running this in one terminal:
-//!
-//!     cargo run --example proxy
-//!
-//! This in another terminal
-//!
-//!     cargo run --example echo
-//!
-//! And finally this in another terminal
-//!
-//!     cargo run --example connect 127.0.0.1:8081
-//!
-//! This final terminal will connect to our proxy, which will in turn connect to
-//! the echo server, and you'll be able to see data flowing between them.
-
-#![warn(rust_2018_idioms)]
-
-use tokio::io;
-use tokio::io::AsyncWriteExt;
-use tokio::net::{TcpListener, TcpStream};
-
-use futures::FutureExt;
-use std::env;
-use std::error::Error;
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn Error>> {
-    let listen_addr = env::args()
-        .nth(1)
-        .unwrap_or_else(|| "127.0.0.1:8081".to_string());
-    let server_addr = env::args()
-        .nth(2)
-        .unwrap_or_else(|| "127.0.0.1:8080".to_string());
-
-    println!("Listening on: {}", listen_addr);
-    println!("Proxying to: {}", server_addr);
-
-    let listener = TcpListener::bind(listen_addr).await?;
-
-    while let Ok((inbound, _)) = listener.accept().await {
-        let transfer = transfer(inbound, server_addr.clone()).map(|r| {
-            if let Err(e) = r {
-                println!("Failed to transfer; error={}", e);
-            }
-        });
-
-        tokio::spawn(transfer);
-    }
-
-    Ok(())
-}
-
-async fn transfer(mut inbound: TcpStream, proxy_addr: String) -> Result<(), Box<dyn Error>> {
-    let mut outbound = TcpStream::connect(proxy_addr).await?;
-
-    let (mut ri, mut wi) = inbound.split();
-    let (mut ro, mut wo) = outbound.split();
-
-    let client_to_server = async {
-        io::copy(&mut ri, &mut wo).await?;
-        wo.shutdown().await
-    };
-
-    let server_to_client = async {
-        io::copy(&mut ro, &mut wi).await?;
-        wi.shutdown().await
-    };
-
-    tokio::try_join!(client_to_server, server_to_client)?;
-
-    Ok(())
-}

examples/tinydb.rs

@@ -1,224 +0,0 @@
-//! A "tiny database" and accompanying protocol
-//!
-//! This example shows the usage of shared state amongst all connected clients,
-//! namely a database of key/value pairs. Each connected client can send a
-//! series of GET/SET commands to query the current value of a key or set the
-//! value of a key.
-//!
-//! This example has a simple protocol you can use to interact with the server.
-//! To run, first run this in one terminal window:
-//!
-//!     cargo run --example tinydb
-//!
-//! and next in another windows run:
-//!
-//!     cargo run --example connect 127.0.0.1:8080
-//!
-//! In the `connect` window you can type in commands where when you hit enter
-//! you'll get a response from the server for that command. An example session
-//! is:
-//!
-//!
-//!     $ cargo run --example connect 127.0.0.1:8080
-//!     GET foo
-//!     foo = bar
-//!     GET FOOBAR
-//!     error: no key FOOBAR
-//!     SET FOOBAR my awesome string
-//!     set FOOBAR = `my awesome string`, previous: None
-//!     SET foo tokio
-//!     set foo = `tokio`, previous: Some("bar")
-//!     GET foo
-//!     foo = tokio
-//!
-//! Namely you can issue two forms of commands:
-//!
-//! * `GET $key` - this will fetch the value of `$key` from the database and
-//!   return it. The server's database is initially populated with the key `foo`
-//!   set to the value `bar`
-//! * `SET $key $value` - this will set the value of `$key` to `$value`,
-//!   returning the previous value, if any.
-
-#![warn(rust_2018_idioms)]
-
-use tokio::net::TcpListener;
-use tokio_stream::StreamExt;
-use tokio_util::codec::{Framed, LinesCodec};
-
-use futures::SinkExt;
-use std::collections::HashMap;
-use std::env;
-use std::error::Error;
-use std::sync::{Arc, Mutex};
-
-/// The in-memory database shared amongst all clients.
-///
-/// This database will be shared via `Arc`, so to mutate the internal map we're
-/// going to use a `Mutex` for interior mutability.
-struct Database {
-    map: Mutex<HashMap<String, String>>,
-}
-
-/// Possible requests our clients can send us
-enum Request {
-    Get { key: String },
-    Set { key: String, value: String },
-}
-
-/// Responses to the `Request` commands above
-enum Response {
-    Value {
-        key: String,
-        value: String,
-    },
-    Set {
-        key: String,
-        value: String,
-        previous: Option<String>,
-    },
-    Error {
-        msg: String,
-    },
-}
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn Error>> {
-    // Parse the address we're going to run this server on
-    // and set up our TCP listener to accept connections.
-    let addr = env::args()
-        .nth(1)
-        .unwrap_or_else(|| "127.0.0.1:8080".to_string());
-
-    let listener = TcpListener::bind(&addr).await?;
-    println!("Listening on: {}", addr);
-
-    // Create the shared state of this server that will be shared amongst all
-    // clients. We populate the initial database and then create the `Database`
-    // structure. Note the usage of `Arc` here which will be used to ensure that
-    // each independently spawned client will have a reference to the in-memory
-    // database.
-    let mut initial_db = HashMap::new();
-    initial_db.insert("foo".to_string(), "bar".to_string());
-    let db = Arc::new(Database {
-        map: Mutex::new(initial_db),
-    });
-
-    loop {
-        match listener.accept().await {
-            Ok((socket, _)) => {
-                // After getting a new connection first we see a clone of the database
-                // being created, which is creating a new reference for this connected
-                // client to use.
-                let db = db.clone();
-
-                // Like with other small servers, we'll `spawn` this client to ensure it
-                // runs concurrently with all other clients. The `move` keyword is used
-                // here to move ownership of our db handle into the async closure.
-                tokio::spawn(async move {
-                    // Since our protocol is line-based we use `tokio_codecs`'s `LineCodec`
-                    // to convert our stream of bytes, `socket`, into a `Stream` of lines
-                    // as well as convert our line based responses into a stream of bytes.
-                    let mut lines = Framed::new(socket, LinesCodec::new());
-
-                    // Here for every line we get back from the `Framed` decoder,
-                    // we parse the request, and if it's valid we generate a response
-                    // based on the values in the database.
-                    while let Some(result) = lines.next().await {
-                        match result {
-                            Ok(line) => {
-                                let response = handle_request(&line, &db);
-
-                                let response = response.serialize();
-
-                                if let Err(e) = lines.send(response.as_str()).await {
-                                    println!("error on sending response; error = {:?}", e);
-                                }
-                            }
-                            Err(e) => {
-                                println!("error on decoding from socket; error = {:?}", e);
-                            }
-                        }
-                    }
-
-                    // The connection will be closed at this point as `lines.next()` has returned `None`.
-                });
-            }
-            Err(e) => println!("error accepting socket; error = {:?}", e),
-        }
-    }
-}
-
-fn handle_request(line: &str, db: &Arc<Database>) -> Response {
-    let request = match Request::parse(line) {
-        Ok(req) => req,
-        Err(e) => return Response::Error { msg: e },
-    };
-
-    let mut db = db.map.lock().unwrap();
-    match request {
-        Request::Get { key } => match db.get(&key) {
-            Some(value) => Response::Value {
-                key,
-                value: value.clone(),
-            },
-            None => Response::Error {
-                msg: format!("no key {}", key),
-            },
-        },
-        Request::Set { key, value } => {
-            let previous = db.insert(key.clone(), value.clone());
-            Response::Set {
-                key,
-                value,
-                previous,
-            }
-        }
-    }
-}
-
-impl Request {
-    fn parse(input: &str) -> Result<Request, String> {
-        let mut parts = input.splitn(3, ' ');
-        match parts.next() {
-            Some("GET") => {
-                let key = parts.next().ok_or("GET must be followed by a key")?;
-                if parts.next().is_some() {
-                    return Err("GET's key must not be followed by anything".into());
-                }
-                Ok(Request::Get {
-                    key: key.to_string(),
-                })
-            }
-            Some("SET") => {
-                let key = match parts.next() {
-                    Some(key) => key,
-                    None => return Err("SET must be followed by a key".into()),
-                };
-                let value = match parts.next() {
-                    Some(value) => value,
-                    None => return Err("SET needs a value".into()),
-                };
-                Ok(Request::Set {
-                    key: key.to_string(),
-                    value: value.to_string(),
-                })
-            }
-            Some(cmd) => Err(format!("unknown command: {}", cmd)),
-            None => Err("empty input".into()),
-        }
-    }
-}
-
-impl Response {
-    fn serialize(&self) -> String {
-        match *self {
-            Response::Value { ref key, ref value } => format!("{} = {}", key, value),
-            Response::Set {
-                ref key,
-                ref value,
-                ref previous,
-            } => format!("set {} = `{}`, previous: {:?}", key, value, previous),
-            Response::Error { ref msg } => format!("error: {}", msg),
-        }
-    }
-}

examples/udp-codec.rs

@@ -1,80 +0,0 @@
-//! This example leverages `BytesCodec` to create a UDP client and server which
-//! speak a custom protocol.
-//!
-//! Here we're using the codec from `tokio-codec` to convert a UDP socket to a stream of
-//! client messages. These messages are then processed and returned back as a
-//! new message with a new destination. Overall, we then use this to construct a
-//! "ping pong" pair where two sockets are sending messages back and forth.
-
-#![warn(rust_2018_idioms)]
-
-use tokio::net::UdpSocket;
-use tokio::{io, time};
-use tokio_stream::StreamExt;
-use tokio_util::codec::BytesCodec;
-use tokio_util::udp::UdpFramed;
-
-use bytes::Bytes;
-use futures::{FutureExt, SinkExt};
-use std::env;
-use std::error::Error;
-use std::net::SocketAddr;
-use std::time::Duration;
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn Error>> {
-    let addr = env::args()
-        .nth(1)
-        .unwrap_or_else(|| "127.0.0.1:0".to_string());
-
-    // Bind both our sockets and then figure out what ports we got.
-    let a = UdpSocket::bind(&addr).await?;
-    let b = UdpSocket::bind(&addr).await?;
-
-    let b_addr = b.local_addr()?;
-
-    let mut a = UdpFramed::new(a, BytesCodec::new());
-    let mut b = UdpFramed::new(b, BytesCodec::new());
-
-    // Start off by sending a ping from a to b, afterwards we just print out
-    // what they send us and continually send pings
-    let a = ping(&mut a, b_addr);
-
-    // The second client we have will receive the pings from `a` and then send
-    // back pongs.
-    let b = pong(&mut b);
-
-    // Run both futures simultaneously of `a` and `b` sending messages back and forth.
-    match tokio::try_join!(a, b) {
-        Err(e) => println!("an error occurred; error = {:?}", e),
-        _ => println!("done!"),
-    }
-
-    Ok(())
-}
-
-async fn ping(socket: &mut UdpFramed<BytesCodec>, b_addr: SocketAddr) -> Result<(), io::Error> {
-    socket.send((Bytes::from(&b"PING"[..]), b_addr)).await?;
-
-    for _ in 0..4usize {
-        let (bytes, addr) = socket.next().map(|e| e.unwrap()).await?;
-
-        println!("[a] recv: {}", String::from_utf8_lossy(&bytes));
-
-        socket.send((Bytes::from(&b"PING"[..]), addr)).await?;
-    }
-
-    Ok(())
-}
-
-async fn pong(socket: &mut UdpFramed<BytesCodec>) -> Result<(), io::Error> {
-    let timeout = Duration::from_millis(200);
-
-    while let Ok(Some(Ok((bytes, addr)))) = time::timeout(timeout, socket.next()).await {
-        println!("[b] recv: {}", String::from_utf8_lossy(&bytes));
-
-        socket.send((Bytes::from(&b"PONG"[..]), addr)).await?;
-    }
-
-    Ok(())
-}

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

@@ -1,16 +0,0 @@
-[package]
-name = "tests-build"
-version = "0.1.0"
-authors = ["Tokio Contributors <[email protected]>"]
-edition = "2018"
-publish = false
-
-[features]
-full = ["tokio/full"]
-rt = ["tokio/rt", "tokio/macros"]
-
-[dependencies]
-tokio = { path = "../tokio", optional = true }
-
-[dev-dependencies]
-trybuild = "1.0"

tests-build/README.md

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

tests-build/src/lib.rs

@@ -1,2 +0,0 @@
-#[cfg(feature = "tokio")]
-pub use tokio;

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.
- --> tests/fail/macros_core_no_default.rs:3:1
-  |
-3 | #[tokio::main]
-  | ^^^^^^^^^^^^^^
-  |
-  = note: this error originates in the attribute macro `tokio::main` (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`
- --> tests/fail/macros_dead_code.rs:6:10
-  |
-6 | async fn f() {}
-  |          ^
-  |
-note: the lint level is defined here
- --> tests/fail/macros_dead_code.rs:1:9
-  |
-1 | #![deny(dead_code)]
-  |         ^^^^^^^^^

tests-build/tests/fail/macros_invalid_input.rs

@@ -1,51 +0,0 @@
-#![deny(duplicate_macro_attributes)]
-
-use tests_build::tokio;
-
-#[tokio::main]
-fn main_is_not_async() {}
-
-#[tokio::main(foo)]
-async fn main_attr_has_unknown_args() {}
-
-#[tokio::main(threadpool::bar)]
-async fn main_attr_has_path_args() {}
-
-#[tokio::test]
-fn test_is_not_async() {}
-
-#[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(crate = 456)]
-async fn test_crate_not_ident_int() {}
-
-#[tokio::test(crate = "456")]
-async fn test_crate_not_ident_invalid() {}
-
-#[tokio::test(crate = "abc::edf")]
-async fn test_crate_not_ident_path() {}
-
-#[tokio::test]
-#[test]
-async fn test_has_second_test_attr() {}
-
-fn main() {}

tests-build/tests/fail/macros_invalid_input.stderr

@@ -1,101 +0,0 @@
-error: the `async` keyword is missing from the function declaration
- --> tests/fail/macros_invalid_input.rs:6:1
-  |
-6 | fn main_is_not_async() {}
-  | ^^
-
-error: Unknown attribute foo is specified; expected one of: `flavor`, `worker_threads`, `start_paused`, `crate`
- --> tests/fail/macros_invalid_input.rs:8:15
-  |
-8 | #[tokio::main(foo)]
-  |               ^^^
-
-error: Must have specified ident
-  --> tests/fail/macros_invalid_input.rs:11:15
-   |
-11 | #[tokio::main(threadpool::bar)]
-   |               ^^^^^^^^^^^^^^^
-
-error: the `async` keyword is missing from the function declaration
-  --> tests/fail/macros_invalid_input.rs:15:1
-   |
-15 | fn test_is_not_async() {}
-   | ^^
-
-error: Unknown attribute foo is specified; expected one of: `flavor`, `worker_threads`, `start_paused`, `crate`
-  --> tests/fail/macros_invalid_input.rs:17:15
-   |
-17 | #[tokio::test(foo)]
-   |               ^^^
-
-error: Unknown attribute foo is specified; expected one of: `flavor`, `worker_threads`, `start_paused`, `crate`
-  --> tests/fail/macros_invalid_input.rs:20:15
-   |
-20 | #[tokio::test(foo = 123)]
-   |               ^^^^^^^^^
-
-error: Failed to parse value of `flavor` as string.
-  --> tests/fail/macros_invalid_input.rs:23:24
-   |
-23 | #[tokio::test(flavor = 123)]
-   |                        ^^^
-
-error: No such runtime flavor `foo`. The runtime flavors are `current_thread` and `multi_thread`.
-  --> tests/fail/macros_invalid_input.rs:26:24
-   |
-26 | #[tokio::test(flavor = "foo")]
-   |                        ^^^^^
-
-error: The `start_paused` option requires the `current_thread` runtime flavor. Use `#[tokio::test(flavor = "current_thread")]`
-  --> tests/fail/macros_invalid_input.rs:29:55
-   |
-29 | #[tokio::test(flavor = "multi_thread", start_paused = false)]
-   |                                                       ^^^^^
-
-error: Failed to parse value of `worker_threads` as integer.
-  --> tests/fail/macros_invalid_input.rs:32:57
-   |
-32 | #[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")]`
-  --> tests/fail/macros_invalid_input.rs:35:59
-   |
-35 | #[tokio::test(flavor = "current_thread", worker_threads = 4)]
-   |                                                           ^
-
-error: Failed to parse value of `crate` as ident.
-  --> tests/fail/macros_invalid_input.rs:38:23
-   |
-38 | #[tokio::test(crate = 456)]
-   |                       ^^^
-
-error: Failed to parse value of `crate` as ident: "456"
-  --> tests/fail/macros_invalid_input.rs:41:23
-   |
-41 | #[tokio::test(crate = "456")]
-   |                       ^^^^^
-
-error: Failed to parse value of `crate` as ident: "abc::edf"
-  --> tests/fail/macros_invalid_input.rs:44:23
-   |
-44 | #[tokio::test(crate = "abc::edf")]
-   |                       ^^^^^^^^^^
-
-error: second test attribute is supplied
-  --> tests/fail/macros_invalid_input.rs:48:1
-   |
-48 | #[test]
-   | ^^^^^^^
-
-error: duplicated attribute
-  --> tests/fail/macros_invalid_input.rs:48:1
-   |
-48 | #[test]
-   | ^^^^^^^
-   |
-note: the lint level is defined here
-  --> tests/fail/macros_invalid_input.rs:1:9
-   |
-1  | #![deny(duplicate_macro_attributes)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^

tests-build/tests/fail/macros_type_mismatch.rs

@@ -1,35 +0,0 @@
-use tests_build::tokio;
-
-#[tokio::main]
-async fn missing_semicolon_or_return_type() {
-    Ok(())
-}
-
-#[tokio::main]
-async fn missing_return_type() {
-    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
-       |
-    23 |     Ok(Ok(());)
-       |
-    23 |     Err(Ok(());)
-       |
-    */
-    Ok(());
-}
-
-// https://github.com/tokio-rs/tokio/issues/4635
-#[allow(redundant_semicolons)]
-#[rustfmt::skip]
-#[tokio::main]
-async fn issue_4635() {
-    return 1;
-    ;
-}
-
-fn main() {}

tests-build/tests/fail/macros_type_mismatch.stderr

@@ -1,48 +0,0 @@
-error[E0308]: mismatched types
- --> tests/fail/macros_type_mismatch.rs:5:5
-  |
-4 | async fn missing_semicolon_or_return_type() {
-  |                                             - possibly return type missing here?
-5 |     Ok(())
-  |     ^^^^^^ expected `()`, found enum `Result`
-  |
-  = note: expected unit type `()`
-                  found enum `Result<(), _>`
-
-error[E0308]: mismatched types
-  --> tests/fail/macros_type_mismatch.rs:10:5
-   |
-9  | async fn missing_return_type() {
-   |                                - possibly return type missing here?
-10 |     return Ok(());
-   |     ^^^^^^^^^^^^^^ expected `()`, found enum `Result`
-   |
-   = note: expected unit type `()`
-                   found enum `Result<(), _>`
-
-error[E0308]: mismatched types
-  --> tests/fail/macros_type_mismatch.rs:23:5
-   |
-14 | async fn extra_semicolon() -> Result<(), ()> {
-   |                               -------------- expected `Result<(), ()>` because of return type
-...
-23 |     Ok(());
-   |     ^^^^^^^ expected enum `Result`, found `()`
-   |
-   = note:   expected enum `Result<(), ()>`
-           found unit type `()`
-help: try wrapping the expression in a variant of `Result`
-   |
-23 |     Ok(Ok(());)
-   |     +++       +
-23 |     Err(Ok(());)
-   |     ++++       +
-
-error[E0308]: mismatched types
-  --> tests/fail/macros_type_mismatch.rs:32:5
-   |
-30 | async fn issue_4635() {
-   |                       - possibly return type missing here?
-31 |     return 1;
-32 |     ;
-   |     ^ expected `()`, found integer

tests-build/tests/macros.rs

@@ -1,27 +0,0 @@
-#[test]
-fn compile_fail_full() {
-    let t = trybuild::TestCases::new();
-
-    #[cfg(feature = "full")]
-    t.pass("tests/pass/forward_args_and_output.rs");
-
-    #[cfg(feature = "full")]
-    t.pass("tests/pass/macros_main_return.rs");
-
-    #[cfg(feature = "full")]
-    t.pass("tests/pass/macros_main_loop.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/macros_clippy.rs

@@ -1,7 +0,0 @@
-#[cfg(feature = "full")]
-#[tokio::test]
-async fn test_with_semicolon_without_return_type() {
-    #![deny(clippy::semicolon_if_nothing_returned)]
-
-    dbg!(0);
-}

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

@@ -1,14 +0,0 @@
-use tests_build::tokio;
-
-#[tokio::main]
-async fn main() -> Result<(), ()> {
-    loop {
-        if !never() {
-            return Ok(());
-        }
-    }
-}
-
-fn never() -> bool {
-    std::time::Instant::now() > std::time::Instant::now()
-}

tests-build/tests/pass/macros_main_return.rs

@@ -1,6 +0,0 @@
-use tests_build::tokio;
-
-#[tokio::main]
-async fn main() -> Result<(), ()> {
-    return Ok(());
-}

tests-integration/Cargo.toml

@@ -1,42 +0,0 @@
-[package]
-name = "tests-integration"
-version = "0.1.0"
-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-net", "tokio/process", "tokio/signal"]
-
-full = [
-    "macros",
-    "rt",
-    "rt-multi-thread",
-
-    "tokio/full",
-    "tokio-test"
-]
-macros = ["tokio/macros"]
-sync = ["tokio/sync"]
-rt = ["tokio/rt"]
-rt-multi-thread = ["rt", "tokio/rt-multi-thread"]
-
-[dependencies]
-tokio = { path = "../tokio" }
-tokio-test = { path = "../tokio-test", optional = true }
-doc-comment = "0.3.1"
-futures = { version = "0.3.0", features = ["async-await"] }

tests-integration/README.md

@@ -1 +0,0 @@
-Tests that require additional components than just the `tokio` crate.

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

@@ -1,20 +0,0 @@
-//! A cat-like utility that can be used as a subprocess to test I/O
-//! stream communication.
-
-use std::io;
-use std::io::Write;
-
-fn main() {
-    let stdin = io::stdin();
-    let mut stdout = io::stdout();
-    let mut line = String::new();
-    loop {
-        line.clear();
-        stdin.read_line(&mut line).unwrap();
-        if line.is_empty() {
-            break;
-        }
-        stdout.write_all(line.as_bytes()).unwrap();
-    }
-    stdout.flush().unwrap();
-}

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/src/lib.rs

@@ -1,2 +0,0 @@
-#[cfg(feature = "full")]
-doc_comment::doc_comment!(include_str!("../../README.md"));

tests-integration/tests/macros_main.rs

@@ -1,28 +0,0 @@
-#![cfg(all(feature = "macros", feature = "rt"))]
-
-#[tokio::main]
-async fn basic_main() -> usize {
-    1
-}
-
-#[tokio::main]
-async fn generic_fun<T: Default>() -> T {
-    T::default()
-}
-
-#[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 shell() {
-    assert_eq!(1, basic_main());
-    assert_eq!(bool::default(), generic_fun::<bool>())
-}

tests-integration/tests/macros_pin.rs

@@ -1,12 +0,0 @@
-use futures::executor::block_on;
-
-async fn my_async_fn() {}
-
-#[test]
-fn pin() {
-    block_on(async {
-        let future = my_async_fn();
-        tokio::pin!(future);
-        (&mut future).await
-    });
-}

tests-integration/tests/macros_select.rs

@@ -1,33 +0,0 @@
-#![cfg(feature = "macros")]
-
-use futures::channel::oneshot;
-use futures::executor::block_on;
-use std::thread;
-
-#[test]
-fn join_with_select() {
-    block_on(async {
-        let (tx1, mut rx1) = oneshot::channel::<i32>();
-        let (tx2, mut rx2) = oneshot::channel::<i32>();
-
-        thread::spawn(move || {
-            tx1.send(123).unwrap();
-            tx2.send(456).unwrap();
-        });
-
-        let mut a = None;
-        let mut b = None;
-
-        while a.is_none() || b.is_none() {
-            tokio::select! {
-                v1 = (&mut rx1), if a.is_none() => a = Some(v1.unwrap()),
-                v2 = (&mut rx2), if b.is_none() => b = Some(v2.unwrap()),
-            }
-        }
-
-        let (a, b) = (a.unwrap(), b.unwrap());
-
-        assert_eq!(a, 123);
-        assert_eq!(b, 456);
-    });
-}

tests-integration/tests/process_stdio.rs

@@ -1,192 +0,0 @@
-#![warn(rust_2018_idioms)]
-#![cfg(feature = "full")]
-
-use tokio::io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader};
-use tokio::join;
-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"));
-    cmd.stdin(Stdio::piped()).stdout(Stdio::piped());
-    cmd
-}
-
-async fn feed_cat(mut cat: Child, n: usize) -> io::Result<ExitStatus> {
-    let mut stdin = cat.stdin.take().unwrap();
-    let stdout = cat.stdout.take().unwrap();
-
-    // Produce n lines on the child's stdout.
-    let write = async {
-        for i in 0..n {
-            let bytes = format!("line {}\n", i).into_bytes();
-            stdin.write_all(&bytes).await.unwrap();
-        }
-
-        drop(stdin);
-    };
-
-    let read = async {
-        let mut reader = BufReader::new(stdout).lines();
-        let mut num_lines = 0;
-
-        // Try to read `n + 1` lines, ensuring the last one is empty
-        // (i.e. EOF is reached after `n` lines.
-        loop {
-            let data = reader
-                .next_line()
-                .await
-                .unwrap_or_else(|_| Some(String::new()))
-                .expect("failed to read line");
-
-            let num_read = data.len();
-            let done = num_lines >= n;
-
-            match (done, num_read) {
-                (false, 0) => panic!("broken pipe"),
-                (true, n) if n != 0 => panic!("extraneous data"),
-                _ => {
-                    let expected = format!("line {}", num_lines);
-                    assert_eq!(expected, data);
-                }
-            };
-
-            num_lines += 1;
-            if num_lines >= n {
-                break;
-            }
-        }
-    };
-
-    // Compose reading and writing concurrently.
-    future::join3(write, read, cat.wait())
-        .map(|(_, _, status)| status)
-        .await
-}
-
-/// Check for the following properties when feeding stdin and
-/// consuming stdout of a cat-like process:
-///
-/// - A number of lines that amounts to a number of bytes exceeding a
-///   typical OS buffer size can be fed to the child without
-///   deadlock. This tests that we also consume the stdout
-///   concurrently; otherwise this would deadlock.
-///
-/// - We read the same lines from the child that we fed it.
-///
-/// - The child does produce EOF on stdout after the last line.
-#[tokio::test]
-async fn feed_a_lot() {
-    let child = cat().spawn().unwrap();
-    let status = feed_cat(child, 10000).await.unwrap();
-    assert_eq!(status.code(), Some(0));
-}
-
-#[tokio::test]
-async fn wait_with_output_captures() {
-    let mut child = cat().spawn().unwrap();
-    let mut stdin = child.stdin.take().unwrap();
-
-    let write_bytes = b"1234";
-
-    let future = async {
-        stdin.write_all(write_bytes).await?;
-        drop(stdin);
-        let out = child.wait_with_output();
-        out.await
-    };
-
-    let output = future.await.unwrap();
-
-    assert!(output.status.success());
-    assert_eq!(output.stdout, write_bytes);
-    assert_eq!(output.stderr.len(), 0);
-}
-
-#[tokio::test]
-async fn status_closes_any_pipes() {
-    // Cat will open a pipe between the parent and child.
-    // If `status_async` doesn't ensure the handles are closed,
-    // we would end up blocking forever (and time out).
-    let child = cat().status();
-
-    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());
-}

tokio-buf/CHANGELOG.md

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

tokio-buf/Cargo.toml

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

tokio-buf/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2022 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-buf/README.md

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

tokio-buf/src/lib.rs

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