main.rs

extern crate futures;
#[macro_use] extern crate log;
extern crate serde;
#[macro_use] extern crate serde_derive;
extern crate simply_service;

use {
    std::sync::atomic::{AtomicUsize, Ordering},

    simply_service::{Request, Response, Server, Method},
};

#[derive(Serialize, Deserialize)]
struct HelloRequest {
    name: String,
}

#[derive(Serialize, Deserialize)]
struct HelloResponse {
    message: String,
}

fn hello(shared: &Shared, request: &Request) -> Response {
    let request: HelloRequest = request.deserialize_body();

    info!("Saying hello to {}", request.name);
    shared.hello_count.fetch_add(1, Ordering::Relaxed);

    Response::serialize_body(HelloResponse {
        message: format!("Hello, {}!", request.name)
    })
}

#[derive(Serialize, Deserialize)]
struct HelloCountResponse {
    count: usize,
}

fn hello_count(shared: &Shared, _request: &Request) -> Response {
    let count = shared.hello_count.load(Ordering::Relaxed);
    info!("Reporting hello count {}", count);

    Response::serialize_body(HelloCountResponse {
        count,
    })
}

struct Shared {
    hello_count: AtomicUsize,
}

fn main() {
    simply_service::setup_logging();

    let shared = Shared {
        hello_count: Default::default(),
    };

    let mut server = Server::build();
    server.add_route("/hello", Method::GET, hello_count);
    server.add_route("/hello", Method::POST, hello);
    server.run(shared);
}