hyper-test.rs

extern crate hyper;
extern crate futures;

use hyper::server::{Service, Http, Request, Response};

struct Environment {
}

struct HttpService<'a> {
    pub env: &'a Environment,
}

impl <'a> HttpService<'a> {
    pub fn new(env: &'a Environment) -> Self {
        HttpService {
            env: env
        }
    }
}

impl <'a> Service for HttpService<'a> {
    type Request = Request;
    type Response = Response;
    type Future = futures::future::FutureResult<Self::Response, Self::Error>;
    type Error = hyper::Error;

    fn call(&self, _req: Request) -> Self::Future {
        futures::future::ok(Response::new())
    }
}

fn foo() {
    let addr = "127.0.0.1:3000".parse().unwrap();
    let env = Environment{};

    let server = Http::new().bind(&addr,
                                  move || Ok(HttpService::new(&env)));

    server.unwrap().run().unwrap();
}

extern crate tokio_core;
fn bar() {
    use tokio_core::net::TcpListener;
    
    let addr = "127.0.0.1:3000".parse().unwrap();
    let env = Environment{};

    let mut core = tokio_core::reactor::Core::new().unwrap();
    let handle = core.handle();

    use futures::Stream;
    use futures::Future;

    let listener = TcpListener::bind(&addr, &handle).unwrap()
        .incoming()
        .for_each(move |(socket, addr)| {
            let svc = HttpService::new(&env);
            let fut = Http::<hyper::Chunk>::new()
                .serve_connection(socket, svc)
                .map(|_| ())
                .map_err(|_| panic!("err"));
            handle.spawn(fut);
            Ok(())
        });;
}

[ensc@sheridan /]$ rustc --version
rustc 1.22.1