hyper_example.rs

extern crate hyper;
extern crate futures;
extern crate unicase;

use hyper::Post;
use hyper::header::{Headers, AccessControlAllowOrigin, AccessControlAllowHeaders};
use hyper::server::{Http, Request, Response, Service};
use futures::Stream;
use futures::future::*;
use unicase::Ascii;
use std::str;

struct WebService;

impl Service for WebService {
    type Request = Request;
    type Response = Response;
    type Error = hyper::Error;
    type Future = Box<futures::Future<Item = Self::Response, Error = Self::Error>>;

    fn call(&self, req: Request) -> Self::Future {
        let (method, uri, _version, headers, body) = req.deconstruct();
        let response = Response::new();
        let mut headers = Headers::new();
        let content_type = Ascii::new("Content-Type".to_owned());
        let access_control_ah = Ascii::new("Access-Control-Allow-Headers".to_owned());
        
        headers.set(AccessControlAllowHeaders(vec![content_type, access_control_ah]));
        headers.set(AccessControlAllowOrigin::Any);
        match method {
            Post => {
                let body = body
                    .fold(Vec::new(), |mut acc, chunk| {
                        acc.extend_from_slice(&*chunk);
                        futures::future::ok::<_, Self::Error>(acc)
                    })
                    .and_then(|v| {
                        let stringify = String::from_utf8(v).unwrap();
                        println!("{}", stringify);
                        Ok::<_, Self::Error>(stringify)
                    })
                    .and_then(|_| {
                        futures::future::ok(response.with_headers(headers))
                    }).boxed();
                body
            },
            _ => Box::new(futures::future::ok(response.with_headers(headers)))
        }
    }
}

fn main() {
    let addr = "0.0.0.0:3000".parse().unwrap();
    let server = Http::new().bind(&addr, || Ok(WebService)).unwrap();
    server.run().unwrap();
}