1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138
#![doc(html_root_url = "https://docs.rs/tokio/0.1.22")] #![deny(missing_docs, warnings, missing_debug_implementations)] //! 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][runtime]. //! * A [reactor] backed by the operating system's event queue (epoll, kqueue, //! IOCP, etc...). //! * Asynchronous [TCP and UDP][net] sockets. //! * Asynchronous [filesystem][fs] operations. //! * [Timer][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]. //! //! [website]: https://tokio.rs/docs/getting-started/hello-world/ //! [futures]: http://docs.rs/futures/0.1 //! //! # Examples //! //! A simple TCP echo server: //! //! ```no_run //! 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); //! } //! ``` macro_rules! if_runtime { ($($i:item)*) => ($( #[cfg(any(feature = "rt-full"))] $i )*) } #[macro_use] extern crate futures; #[cfg(feature = "io")] extern crate bytes; #[cfg(feature = "reactor")] extern crate mio; #[cfg(feature = "rt-full")] extern crate num_cpus; #[cfg(feature = "codec")] extern crate tokio_codec; #[cfg(feature = "rt-full")] extern crate tokio_current_thread; #[cfg(feature = "fs")] extern crate tokio_fs; #[cfg(feature = "io")] extern crate tokio_io; #[cfg(feature = "reactor")] extern crate tokio_reactor; #[cfg(feature = "sync")] extern crate tokio_sync; #[cfg(feature = "tcp")] extern crate tokio_tcp; #[cfg(feature = "rt-full")] extern crate tokio_threadpool; #[cfg(feature = "timer")] extern crate tokio_timer; #[cfg(feature = "udp")] extern crate tokio_udp; #[cfg(feature = "experimental-tracing")] extern crate tracing_core; #[cfg(all(unix, feature = "uds"))] extern crate tokio_uds; #[cfg(feature = "timer")] pub mod clock; #[cfg(feature = "codec")] pub mod codec; #[cfg(feature = "fs")] pub mod fs; #[cfg(feature = "io")] pub mod io; #[cfg(any(feature = "tcp", feature = "udp", feature = "uds"))] pub mod net; pub mod prelude; #[cfg(feature = "reactor")] pub mod reactor; #[cfg(feature = "sync")] pub mod sync; #[cfg(feature = "timer")] pub mod timer; pub mod util; if_runtime! { extern crate tokio_executor; pub mod executor; pub mod runtime; pub use executor::spawn; pub use runtime::run; }