#![deny(warnings)] // Note: `hyper::upgrade` docs link to this upgrade. use std::str; use hyper::server::conn::Http; use tokio::io::{AsyncReadExt, AsyncWriteExt}; use tokio::net::{TcpListener, TcpStream}; use tokio::sync::watch; use hyper::header::{HeaderValue, UPGRADE}; use hyper::service::service_fn; use hyper::upgrade::Upgraded; use hyper::{Body, Request, Response, StatusCode}; use std::net::SocketAddr; // A simple type alias so as to DRY. type Result = std::result::Result>; /// Handle server-side I/O after HTTP upgraded. async fn server_upgraded_io(mut upgraded: Upgraded) -> Result<()> { // we have an upgraded connection that we can read and // write on directly. // // since we completely control this example, we know exactly // how many bytes the client will write, so just read exact... let mut vec = vec![0; 7]; upgraded.read_exact(&mut vec).await?; println!("server[foobar] recv: {:?}", str::from_utf8(&vec)); // and now write back the server 'foobar' protocol's // response... upgraded.write_all(b"barr=foo").await?; println!("server[foobar] sent"); Ok(()) } /// Our server HTTP handler to initiate HTTP upgrades. async fn server_upgrade(mut req: Request) -> Result> { let mut res = Response::new(Body::empty()); // Send a 400 to any request that doesn't have // an `Upgrade` header. if !req.headers().contains_key(UPGRADE) { *res.status_mut() = StatusCode::BAD_REQUEST; return Ok(res); } // Setup a future that will eventually receive the upgraded // connection and talk a new protocol, and spawn the future // into the runtime. // // Note: This can't possibly be fulfilled until the 101 response // is returned below, so it's better to spawn this future instead // waiting for it to complete to then return a response. tokio::task::spawn(async move { match hyper::upgrade::on(&mut req).await { Ok(upgraded) => { if let Err(e) = server_upgraded_io(upgraded).await { eprintln!("server foobar io error: {}", e) }; } Err(e) => eprintln!("upgrade error: {}", e), } }); // Now return a 101 Response saying we agree to the upgrade to some // made-up 'foobar' protocol. *res.status_mut() = StatusCode::SWITCHING_PROTOCOLS; res.headers_mut() .insert(UPGRADE, HeaderValue::from_static("foobar")); Ok(res) } /// Handle client-side I/O after HTTP upgraded. async fn client_upgraded_io(mut upgraded: Upgraded) -> Result<()> { // We've gotten an upgraded connection that we can read // and write directly on. Let's start out 'foobar' protocol. upgraded.write_all(b"foo=bar").await?; println!("client[foobar] sent"); let mut vec = Vec::new(); upgraded.read_to_end(&mut vec).await?; println!("client[foobar] recv: {:?}", str::from_utf8(&vec)); Ok(()) } /// Our client HTTP handler to initiate HTTP upgrades. async fn client_upgrade_request(addr: SocketAddr) -> Result<()> { let req = Request::builder() .uri(format!("http://{}/", addr)) .header(UPGRADE, "foobar") .body(Body::empty()) .unwrap(); let stream = TcpStream::connect(addr).await?; let (mut sender, conn) = hyper::client::conn::handshake(stream).await?; tokio::task::spawn(async move { if let Err(err) = conn.await { println!("Connection failed: {:?}", err); } }); let res = sender.send_request(req).await?; if res.status() != StatusCode::SWITCHING_PROTOCOLS { panic!("Our server didn't upgrade: {}", res.status()); } match hyper::upgrade::on(res).await { Ok(upgraded) => { if let Err(e) = client_upgraded_io(upgraded).await { eprintln!("client foobar io error: {}", e) }; } Err(e) => eprintln!("upgrade error: {}", e), } Ok(()) } #[tokio::main] async fn main() { // For this example, we just make a server and our own client to talk to // it, so the exact port isn't important. Instead, let the OS give us an // unused port. let addr: SocketAddr = ([127, 0, 0, 1], 0).into(); let listener = TcpListener::bind(addr).await.expect("failed to bind"); // We need the assigned address for the client to send it messages. let addr = listener.local_addr().unwrap(); // For this example, a oneshot is used to signal that after 1 request, // the server should be shutdown. let (tx, mut rx) = watch::channel(false); // Spawn server on the default executor, // which is usually a thread-pool from tokio default runtime. tokio::task::spawn(async move { loop { tokio::select! { res = listener.accept() => { let (stream, _) = res.expect("Failed to accept"); let mut rx = rx.clone(); tokio::task::spawn(async move { let conn = Http::new().serve_connection(stream, service_fn(server_upgrade)); // Don't forget to enable upgrades on the connection. let mut conn = conn.with_upgrades(); let mut conn = Pin::new(&mut conn); tokio::select! { res = &mut conn => { if let Err(err) = res { println!("Error serving connection: {:?}", err); return; } } // Continue polling the connection after enabling graceful shutdown. _ = rx.changed() => { conn.graceful_shutdown(); } } }); } _ = rx.changed() => { break; } } } }); // Client requests a HTTP connection upgrade. let request = client_upgrade_request(addr.clone()); if let Err(e) = request.await { eprintln!("client error: {}", e); } // Complete the oneshot so that the server stops // listening and the process can close down. let _ = tx.send(true); }