Skip to content
Streamline updating a Tokio 0.1 application to Tokio 0.2.
Rust
Branch: master
Clone or download
bryanburgers and hawkw Add `Runtime::enter` (#25)
* Add `Runtime::enter`

Add a `Runtime::enter` function that allows the caller to enter the
runtime context without calling `run`, `spawn`, or `block_on`. This
mirrors the `enter` function from Tokio 0.2's runtime.

* Fix tests

Fix the current_thread test that would fail all the time. Also fix the
threadpool test which was failing intermittently.

* Clean up unnecessary code
Latest commit 1d7f57a Jan 21, 2020
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
.github/workflows
src
tests Add `Runtime::enter` (#25) Jan 22, 2020
.gitignore
CHANGELOG.md
Cargo.toml
README.md

README.md

Tokio Compat

Compatibility layers between tokio 0.2 and legacy versions.

Crates.io Documentation MIT licensed Build Status Discord

Website | Guides | API Docs | Chat

Overview

This crate provides compatibility runtimes that allow running both futures 0.1 futures that use tokio 0.1 runtime services and std::future futures that use tokio 0.2 runtime services.

Examples

Spawning both tokio 0.1 and tokio 0.2 futures:

use futures_01::future::lazy;

tokio_compat::run(lazy(|| {
    // spawn a `futures` 0.1 future using the `spawn` function from the
    // `tokio` 0.1 crate:
    tokio_01::spawn(lazy(|| {
        println!("hello from tokio 0.1!");
        Ok(())
    }));

    // spawn an `async` block future on the same runtime using `tokio`
    // 0.2's `spawn`:
    tokio_02::spawn(async {
        println!("hello from tokio 0.2!");
    });

    Ok(())
}))

Futures on the compat runtime can use timer APIs from both 0.1 and 0.2 versions of tokio:

use std::time::{Duration, Instant};
use futures_01::future::lazy;
use tokio_compat::prelude::*;

tokio_compat::run_std(async {
    // Wait for a `tokio` 0.1 `Delay`...
    let when = Instant::now() + Duration::from_millis(10);
    tokio_01::timer::Delay::new(when)
        // convert the delay future into a `std::future` that we can `await`.
        .compat()
        .await
        .expect("tokio 0.1 timer should work!");
    println!("10 ms have elapsed");

    // Wait for a `tokio` 0.2 `Delay`...
    let when = Instant::now() + Duration::from_millis(20);
    tokio_02::timer::delay(when).await;
    println!("20 ms have elapsed");
});

License

This project is licensed under the MIT 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.

You can’t perform that action at this time.