diff options
author | Eliza Weisman <eliza@buoyant.io> | 2019-03-22 15:25:42 -0700 |
---|---|---|
committer | GitHub <noreply@github.com> | 2019-03-22 15:25:42 -0700 |
commit | 30330da11a56dfdd11bdbef50dba073a9edc36b2 (patch) | |
tree | bf4e8e90293a3c75a2bf5281572e1c01eceab3cb /examples/echo.rs | |
parent | 6e4945025cdc6f2b71d9b30aaa23c5517cca1504 (diff) |
chore: Fix examples not working with `cargo run` (#998)
* chore: Fix examples not working with `cargo run`
## Motivation
PR #991 moved the `tokio` crate to its own subdirectory, but did not
move the `examples` directory into `tokio/examples`. While attempting to
use the examples for testing another change, I noticed that #991 had
broken the ability to use `cargo run`, as the examples were no longer
considered part of a crate that cargo was aware of:
```
tokio on master [$] via 🦀v1.33.0 at ☸️ aks-eliza-dev
➜ cargo run --example chat
error: no example target named `chat`
Did you mean `echo`?
```
## Solution
This branch moves the examples into the `tokio` directory, so cargo is
now once again aware of them:
```
tokio on eliza/fix-examples [$] via 🦀v1.33.0 at ☸️ aks-eliza-dev
➜ cargo run --example chat
Compiling tokio-executor v0.1.7 (/Users/eliza/Code/tokio/tokio-executor)
Compiling tokio-reactor v0.1.9
Compiling tokio-threadpool v0.1.13
Compiling tokio-current-thread v0.1.6
Compiling tokio-timer v0.2.10
Compiling tokio-uds v0.2.5
Compiling tokio-udp v0.1.3
Compiling tokio-tcp v0.1.3
Compiling tokio-fs v0.1.6
Compiling tokio v0.1.18 (/Users/eliza/Code/tokio/tokio)
Finished dev [unoptimized + debuginfo] target(s) in 7.04s
Running `target/debug/examples/chat`
server running on localhost:6142
```
Signed-off-by: Eliza Weisman <eliza@buoyant.io>
Signed-off-by: Eliza Weisman <eliza@buoyant.io>
Diffstat (limited to 'examples/echo.rs')
-rw-r--r-- | examples/echo.rs | 115 |
1 files changed, 0 insertions, 115 deletions
diff --git a/examples/echo.rs b/examples/echo.rs deleted file mode 100644 index 45f808f8..00000000 --- a/examples/echo.rs +++ /dev/null @@ -1,115 +0,0 @@ -//! A "hello world" echo server with Tokio -//! -//! This server will create a TCP listener, accept connections in a loop, and -//! write back everything that's read off of each TCP connection. -//! -//! Because the Tokio runtime uses a thread pool, each TCP connection is -//! processed concurrently with all other TCP connections across multiple -//! threads. -//! -//! To see this server in action, you can run this in one terminal: -//! -//! cargo run --example echo -//! -//! and in another terminal you can run: -//! -//! cargo run --example connect 127.0.0.1:8080 -//! -//! Each line you type in to the `connect` terminal should be echo'd back to -//! you! If you open up multiple terminals running the `connect` example you -//! should be able to see them all make progress simultaneously. - -#![deny(warnings)] - -extern crate tokio; - -use tokio::io; -use tokio::net::TcpListener; -use tokio::prelude::*; - -use std::env; -use std::net::SocketAddr; - -fn main() -> Result<(), Box<std::error::Error>> { - // Allow passing an address to listen on as the first argument of this - // program, but otherwise we'll just set up our TCP listener on - // 127.0.0.1:8080 for connections. - let addr = env::args().nth(1).unwrap_or("127.0.0.1:8080".to_string()); - let addr = addr.parse::<SocketAddr>()?; - - // Next up we create a TCP listener which will listen for incoming - // connections. This TCP listener is bound to the address we determined - // above and must be associated with an event loop, so we pass in a handle - // to our event loop. After the socket's created we inform that we're ready - // to go and start accepting connections. - let socket = TcpListener::bind(&addr)?; - println!("Listening on: {}", addr); - - // Here we convert the `TcpListener` to a stream of incoming connections - // with the `incoming` method. We then define how to process each element in - // the stream with the `for_each` method. - // - // This combinator, defined on the `Stream` trait, will allow us to define a - // computation to happen for all items on the stream (in this case TCP - // connections made to the server). The return value of the `for_each` - // method is itself a future representing processing the entire stream of - // connections, and ends up being our server. - let done = socket - .incoming() - .map_err(|e| println!("failed to accept socket; error = {:?}", e)) - .for_each(move |socket| { - // Once we're inside this closure this represents an accepted client - // from our server. The `socket` is the client connection (similar to - // how the standard library operates). - // - // We just want to copy all data read from the socket back onto the - // socket itself (e.g. "echo"). We can use the standard `io::copy` - // combinator in the `tokio-core` crate to do precisely this! - // - // The `copy` function takes two arguments, where to read from and where - // to write to. We only have one argument, though, with `socket`. - // Luckily there's a method, `Io::split`, which will split an Read/Write - // stream into its two halves. This operation allows us to work with - // each stream independently, such as pass them as two arguments to the - // `copy` function. - // - // The `copy` function then returns a future, and this future will be - // resolved when the copying operation is complete, resolving to the - // amount of data that was copied. - let (reader, writer) = socket.split(); - let amt = io::copy(reader, writer); - - // After our copy operation is complete we just print out some helpful - // information. - let msg = amt.then(move |result| { - match result { - Ok((amt, _, _)) => println!("wrote {} bytes", amt), - Err(e) => println!("error: {}", e), - } - - Ok(()) - }); - - // And this is where much of the magic of this server happens. We - // crucially want all clients to make progress concurrently, rather than - // blocking one on completion of another. To achieve this we use the - // `tokio::spawn` function to execute the work in the background. - // - // This function will transfer ownership of the future (`msg` in this - // case) to the Tokio runtime thread pool that. The thread pool will - // drive the future to completion. - // - // Essentially here we're executing a new task to run concurrently, - // which will allow all of our clients to be processed concurrently. - tokio::spawn(msg) - }); - - // And finally now that we've define what our server is, we run it! - // - // This starts the Tokio runtime, spawns the server task, and blocks the - // current thread until all tasks complete execution. Since the `done` task - // never completes (it just keeps accepting sockets), `tokio::run` blocks - // forever (until ctrl-c is pressed). - tokio::run(done); - Ok(()) -} |