Crate tk_easyloop

A main loop wrapper around tokio to provide thread-local loop which:

• Avoids padding a Handle in to every function

• Mostly avoids common error: thread 'foo' panicked at 'no Task is currently running', by providing convenient run function for all your code involving futures

Example

extern crate futures;
extern crate tk_easyloop;

use std::time::Duration;
use tk_easyloop::{run, timeout};

fn main() {
    run(|| {
        // should return some future, let's use a timeout
        timeout(Duration::new(1, 0))
    }).unwrap();
}

Multi-threaded Example

This crate uses thread-local storage for storing loop, but it doesn’t mean multi-treading doesn’t work. Multiple threads can be used too.

extern crate tk_easyloop;
use std::thread;
use std::time::Duration;
use tk_easyloop::{run, timeout};

fn main() {
    let mut threads = Vec::new();
    for thread_no in 0..10 {
        threads.push(thread::spawn(move || {
            run(|| {
                timeout(Duration::new(1, 0))
            })
        }))
    }
    for t in threads {
        t.join().unwrap().unwrap();
    }
}

See examples/multi-threaded.rs for more comprehensive example.

Functions

handle

Returns current loop handle

interval

Create an interval tied to the current loop

is_running

Returns true if there is an event loop currently running

run

Run the main loop and initialize it by running a function

run_forever

Run the main loop and initialize it by running a function, which spawns more futures in the main loop. Then run loop indefinitely.

spawn

Spawn a future to the current main loop

spawn_fn

Spawn a closure to the current main loop

timeout

Create a timeout tied to the current loop

timeout_at

Create a timeout tied to the current loop