Crate tokio

A runtime for writing reliable, asynchronous, and slim applications.

Tokio is an event-driven, non-blocking I/O platform for writing asynchronous applications with the Rust programming language. At a high level, it provides a few major components:

• A multi threaded, work-stealing based task scheduler.
• A reactor backed by the operating system's event queue (epoll, kqueue, IOCP, etc...).
• Asynchronous TCP and UDP sockets.
• Asynchronous filesystem operations.
• Timer API for scheduling work in the future.

Tokio is built using futures as the abstraction for managing the complexity of asynchronous programming.

Guide level documentation is found on the website.

Examples

A simple TCP echo server:

extern crate tokio;

use tokio::prelude::*;
use tokio::io::copy;
use tokio::net::TcpListener;

fn main() {
    // Bind the server's socket.
    let addr = "127.0.0.1:12345".parse().unwrap();
    let listener = TcpListener::bind(&addr)
        .expect("unable to bind TCP listener");

    // Pull out a stream of sockets for incoming connections
    let server = listener.incoming()
        .map_err(|e| eprintln!("accept failed = {:?}", e))
        .for_each(|sock| {
            // Split up the reading and writing parts of the
            // socket.
            let (reader, writer) = sock.split();

            // A future that echos the data and returns how
            // many bytes were copied...
            let bytes_copied = copy(reader, writer);

            // ... after which we'll print what happened.
            let handle_conn = bytes_copied.map(|amt| {
                println!("wrote {:?} bytes", amt)
            }).map_err(|err| {
                eprintln!("IO error {:?}", err)
            });

            // Spawn the future as a concurrent task.
            tokio::spawn(handle_conn)
        });

    // Start the Tokio runtime
    tokio::run(server);
}

Re-exports

pub use executor::spawn;

Modules

clock	A configurable source of time.
codec	Utilities for encoding and decoding frames.
executor	Task execution utilities.
fs	Asynchronous filesystem manipulation operations.
io	Asynchronous I/O.
net	TCP/UDP/Unix bindings for tokio.
prelude	A "prelude" for users of the tokio crate.
reactor	Event loop that drives Tokio I/O resources.
runtime	A batteries included runtime for applications using Tokio.
sync	Future-aware synchronization
timer	Utilities for tracking time.
util	Utilities for working with Tokio.

Functions

run	Start the Tokio runtime using the supplied future to bootstrap execution.