Untitled

#![feature(trait_alias)]
use futures::future::{self, Future};
use hyper::server::conn::AddrStream;
use hyper::service::{make_service_fn, service_fn};
use hyper::{Body, Method, Request, Response};

//

#[cfg_attr(rustfmt, rustfmt_skip)]
pub trait RetFut = Future<Item = Response<Body>, Error = hyper::Error>;

#[derive(Debug, Clone)]
pub struct Route {
    pub method: Method,
}

#[derive(Debug, Clone)]
pub struct Router {
    routes: Vec<Route>,
}
impl Router {
    pub fn builder() -> RouterBuilder {
        RouterBuilder::new()
    }

    pub fn handle_req(&self, req: Request<Body>) -> impl RetFut {
        match (req.method(), req.uri().path()) {
            _ => future::ok(Response::new(Body::from("Hello world"))),
        }
    }
}

#[derive(Debug, Default)]
pub struct RouterBuilder {
    routes: Vec<Route>,
}
impl RouterBuilder {
    pub fn new() -> Self {
        RouterBuilder { routes: vec![] }
    }

    pub fn build(self) -> Router {
        Router {
            routes: self.routes,
        }
    }
}

fn main() {
    let addr = "0.0.0.0:8080".parse().unwrap();

    let make_svc = make_service_fn(move |_socket: &AddrStream| {
        let router: Router = Router::builder().build();
        service_fn(move |req: Request<Body>| router.handle_req(req))
    });

    let server = hyper::Server::bind(&addr)
        .serve(make_svc)
        .map_err(|e| eprintln!("server error: {}", e));

    hyper::rt::run(server);
}