echo.rs

extern crate futures;
extern crate hyper;
extern crate env_logger;
#[macro_use] extern crate log;
extern crate tokio_core;
extern crate futures_cpupool;

use hyper::{Post, StatusCode};
use hyper::header::ContentLength;
use hyper::server::{Http, Service, Request, Response};
use futures::{future, Future, Stream};
use futures_cpupool::CpuPool;

#[derive(Clone)]
struct Echo {
    thread_pool: CpuPool,
}

impl Service for Echo {
    type Request = Request;
    type Response = Response;
    type Error = hyper::Error;
    type Future = futures::BoxFuture<Response, hyper::Error>;

    fn call(&self, req: Request) -> Self::Future {
        let (method, uri, _version, headers, body) = req.deconstruct();
        match (method, uri.path()) {
            (Post, "/echo") => {
                let mut res = Response::new();
                if let Some(len) = headers.get::<ContentLength>() {
                    debug!("len:{}", len);
                    res.headers_mut().set(len.clone());
                }
                self.thread_pool.spawn_fn(move || {
                    let v = body.collect().wait()?;
                    let value = v.iter().fold(vec![], |mut acc, chunk| {
                        acc.extend_from_slice(chunk.as_ref());
                        acc
                    });
                    debug!("value: {:?}", &value);
                    Ok(res.with_body(value))
                }).boxed()
            },
            _ => future::ok(Response::new().with_status(StatusCode::NotFound)).boxed()
        }
    }
}

fn main() {
    env_logger::init().unwrap();
    let addr = "127.0.0.1:1337".parse().unwrap();
    let thread_pool = CpuPool::new_num_cpus();
    let server = Http::new().bind(&addr, move || Ok(Echo { thread_pool: thread_pool.clone() })).unwrap();
    println!("Listening on http://{}", server.local_addr().unwrap());
    server.run().unwrap();
}