use std::collections::HashMap; use std::convert::Infallible; use std::sync::{Arc, Mutex}; use hyper::server::Server; use hyper::service::{make_service_fn, service_fn}; use hyper::{Body, Method, Request, Response}; use tower::util::BoxCloneService; use tower::Service as _; // GET / async fn index(_req: Request) -> hyper::Result> { Ok(Response::new(Body::from("Hello, world!"))) } // GET /blog async fn blog(_req: Request) -> hyper::Result> { Ok(Response::new(Body::from("..."))) } // 404 handler async fn not_found(_req: Request) -> hyper::Result> { Ok(Response::builder().status(404).body(Body::empty()).unwrap()) } // We can use `BoxCloneService` to erase the type of each handler service. // // We still need a `Mutex` around each service because `BoxCloneService` doesn't // require the service to implement `Sync`. type Service = Mutex, Response, hyper::Error>>; // We use a `HashMap` to hold a `Router` for each HTTP method. This allows us // to register the same route for multiple methods. type Router = HashMap>; async fn route(router: Arc, req: Request) -> hyper::Result> { // find the subrouter for this request method let router = match router.get(req.method()) { Some(router) => router, // if there are no routes for this method, respond with 405 Method Not Allowed None => return Ok(Response::builder().status(405).body(Body::empty()).unwrap()), }; // find the service for this request path match router.at(req.uri().path()) { Ok(found) => { // lock the service for a very short time, just to clone the service let mut service = found.value.lock().unwrap().clone(); service.call(req).await } // if we there is no matching service, call the 404 handler Err(_) => not_found(req).await, } } #[tokio::main] async fn main() { // Create a router and register our routes. let mut router = Router::new(); // GET / => `index` router .entry(Method::GET) .or_default() .insert("/", BoxCloneService::new(service_fn(index)).into()) .unwrap(); // GET /blog => `blog` router .entry(Method::GET) .or_default() .insert("/blog", BoxCloneService::new(service_fn(blog)).into()) .unwrap(); // boilerplate for the hyper service let router = Arc::new(router); let make_service = make_service_fn(|_| { let router = router.clone(); async { Ok::<_, Infallible>(service_fn(move |request| route(router.clone(), request))) } }); // run the server Server::bind(&([127, 0, 0, 1], 3000).into()) .serve(make_service) .await .unwrap() }