mirror of
https://github.com/tokio-rs/tokio.git
synced 2026-08-19 00:00:09 +02:00
Carl Lerche
fe14e7b127
This patch is an intial implementation of the Tokio runtime. The Tokio runtime provides an out of the box configuration for running I/O heavy asynchronous applications. As of now, the Tokio runtime is a combination of a work-stealing thread pool as well as a background reactor to drive I/O resources. This patch also includes tokio-executor, a hopefully short lived crate that is based on the futures 0.2 executor RFC. * Implement `Park` for `Reactor` This enables the reactor to be used as the thread parker for executors. This also adds an `Error` component to `Park`. With this change, a `Reactor` and a `CurrentThread` can be combined to achieve the capabilities of tokio-core.
110 lines
3.4 KiB
Rust
110 lines
3.4 KiB
Rust
//! `Future`-powered I/O at the core of Tokio
|
|
//!
|
|
//! This crate uses the [`futures`] crate to provide an event loop ("reactor
|
|
//! core") which can be used to drive I/O like TCP and UDP. All asynchronous I/O
|
|
//! is powered by the [`mio`] crate.
|
|
//!
|
|
//! [`futures`]: ../futures/index.html
|
|
//! [`mio`]: ../mio/index.html
|
|
//!
|
|
//! The concrete types provided in this crate are relatively bare bones but are
|
|
//! intended to be the essential foundation for further projects needing an
|
|
//! event loop. In this crate you'll find:
|
|
//!
|
|
//! * TCP, both streams and listeners.
|
|
//! * UDP sockets.
|
|
//! * An event loop to run futures.
|
|
//!
|
|
//! More functionality is likely to be added over time, but otherwise the crate
|
|
//! is intended to be flexible, with the [`PollEvented`] type accepting any
|
|
//! type that implements [`mio::Evented`]. For example, the [`tokio-uds`] crate
|
|
//! uses [`PollEvented`] to provide support for Unix domain sockets.
|
|
//!
|
|
//! [`PollEvented`]: ./reactor/struct.PollEvented.html
|
|
//! [`mio::Evented`]: ../mio/event/trait.Evented.html
|
|
//! [`tokio-uds`]: https://crates.io/crates/tokio-uds
|
|
//!
|
|
//! Some other important tasks covered by this crate are:
|
|
//!
|
|
//! * All I/O is futures-aware. If any action in this crate returns "not ready"
|
|
//! or "would block", then the current future task is scheduled to receive a
|
|
//! notification when it would otherwise make progress.
|
|
//!
|
|
//! You can find more extensive documentation in terms of tutorials at
|
|
//! [https://tokio.rs](https://tokio.rs).
|
|
//!
|
|
//! # Examples
|
|
//!
|
|
//! A simple TCP echo server:
|
|
//!
|
|
//! ```no_run
|
|
//! extern crate futures;
|
|
//! extern crate tokio;
|
|
//! extern crate tokio_io;
|
|
//!
|
|
//! use futures::prelude::*;
|
|
//! use tokio_io::AsyncRead;
|
|
//! use tokio_io::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| println!("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);
|
|
//! }
|
|
//! ```
|
|
|
|
#![doc(html_root_url = "https://docs.rs/tokio/0.1.1")]
|
|
#![deny(missing_docs)]
|
|
#![deny(warnings)]
|
|
#![warn(missing_debug_implementations)]
|
|
|
|
extern crate bytes;
|
|
#[macro_use]
|
|
extern crate futures;
|
|
extern crate iovec;
|
|
extern crate mio;
|
|
extern crate slab;
|
|
#[macro_use]
|
|
extern crate tokio_io;
|
|
extern crate tokio_executor;
|
|
extern crate tokio_threadpool;
|
|
|
|
#[macro_use]
|
|
extern crate log;
|
|
|
|
pub mod executor;
|
|
pub mod net;
|
|
pub mod reactor;
|
|
pub mod runtime;
|
|
|
|
pub use executor::spawn;
|
|
pub use runtime::run;
|