proxmox-backup/src/main.rs

extern crate apitest;

use failure::*;

use std::collections::HashMap;
use lazy_static::lazy_static;

//use apitest::json_schema::*;
use apitest::api_info::*;
use apitest::json_schema::*;

//use serde_derive::{Serialize, Deserialize};
use serde_json::{json, Value};


use hyper::{Method, Body, Request, Response, Server, StatusCode};
use hyper::rt::Future;
use hyper::service::service_fn_ok;

macro_rules! http_error {
    ($status:ident, $msg:expr) => {{
        let mut resp = Response::new(Body::from($msg));
        *resp.status_mut() = StatusCode::$status;
        return resp;
    }}
}


fn handle_request(req: Request<Body>) -> Response<Body> {

    let method = req.method();
    let path = req.uri().path();
    let query = req.uri().query();
    let components: Vec<&str> = path.split('/').filter(|x| !x.is_empty()).collect();
    let comp_len = components.len();

    println!("REQUEST {} {}", method, path);
    println!("COMPO {:?}", components);

    if comp_len >= 1 && components[0] == "api3" {
        println!("GOT API REQUEST");
        if comp_len >= 2 {
            let format = components[1];
            if format != "json" {
                http_error!(NOT_FOUND, format!("Unsupported format '{}'\n", format))
            }

            if let Some(info) = ROUTER.find_method(&components[2..]) {
                println!("FOUND INFO");
                let api_method_opt = match method {
                    &Method::GET => &info.get,
                    &Method::PUT => &info.put,
                    &Method::POST => &info.post,
                    &Method::DELETE => &info.delete,
                    _ => &None,
                };
                let api_method = match api_method_opt {
                    Some(m) => m,
                    _ => http_error!(NOT_FOUND, format!("No such method '{} {}'\n", method, path)),
                };

                // fixme: handle auth

                // extract param
                let param = match query {
                    Some(data) => {
                        match parse_query_string(data, &api_method.parameters, true) {
                            Ok(query) => query,
                            Err(ref error_list) => {
                                let msg = error_list.iter().fold(String::from(""), |acc, item| {
                                    acc + &item.to_string() + "\n"
                                });
                                http_error!(BAD_REQUEST, msg);
                            }
                        }
                    }
                    None => json!({}),
                };

                match (api_method.handler)(param, &api_method) {
                    Ok(res) => {
                        let json_str = res.to_string();
                        return Response::new(Body::from(json_str));
                    }
                    Err(err) => {
                        http_error!(NOT_FOUND, format!("Method returned error '{}'\n", err));
                    }
                }

            } else {
                http_error!(NOT_FOUND, format!("No such path '{}'\n", path));
            }
        }
    }

    Response::new(Body::from("RETURN WEB GUI\n"))
}

lazy_static!{
    static ref ROUTER: MethodInfo = apitest::api3::router();
}

fn main() {
    println!("Fast Static Type Definitions 1");

    let addr = ([127, 0, 0, 1], 8007).into();

    let new_svc = || {
        // service_fn_ok converts our function into a `Service`
        service_fn_ok(handle_request)
    };

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

    // Run this server for... forever!
    hyper::rt::run(server);
}
use edition 2018 (beta) This is expected to be stable by the end of the year. 2018-11-01 13:42:27 +00:00			`extern crate apitest;`
initial version 2018-10-30 09:04:30 +00:00
move parse_query into json_schema 2018-11-05 14:20:27 +00:00			`use failure::*;`
do not use phf 2018-11-01 12:05:45 +00:00
start implementing request handler 2018-11-01 10:30:49 +00:00			`use std::collections::HashMap;`
another way to initialize the api tree 2018-11-03 09:42:48 +00:00			`use lazy_static::lazy_static;`
start implementing request handler 2018-11-01 10:30:49 +00:00
another way to initialize the api tree 2018-11-03 09:42:48 +00:00			`//use apitest::json_schema::*;`
split code into several files 2018-10-31 09:42:14 +00:00			`use apitest::api_info::*;`
move parse_query into json_schema 2018-11-05 14:20:27 +00:00			`use apitest::json_schema::*;`
split code into several files 2018-10-31 09:42:14 +00:00
another way to initialize the api tree 2018-11-03 09:42:48 +00:00			`//use serde_derive::{Serialize, Deserialize};`
try to define an static api 2018-10-30 13:06:37 +00:00			`use serde_json::{json, Value};`

start implementing request handler 2018-11-01 10:30:49 +00:00
			`use hyper::{Method, Body, Request, Response, Server, StatusCode};`
split code into several files 2018-10-31 09:42:14 +00:00			`use hyper::rt::Future;`
			`use hyper::service::service_fn_ok;`
initial version 2018-10-30 09:04:30 +00:00
start implementing request handler 2018-11-01 10:30:49 +00:00			`macro_rules! http_error {`
			`($status:ident, $msg:expr) => {{`
			`let mut resp = Response::new(Body::from($msg));`
			`*resp.status_mut() = StatusCode::$status;`
			`return resp;`
			`}}`
			`}`


			`fn handle_request(req: Request<Body>) -> Response<Body> {`
split code into several files 2018-10-31 09:42:14 +00:00
			`let method = req.method();`
			`let path = req.uri().path();`
start implementing request handler 2018-11-01 10:30:49 +00:00			`let query = req.uri().query();`
			`let components: Vec<&str> = path.split('/').filter(\|x\| !x.is_empty()).collect();`
			`let comp_len = components.len();`
split code into several files 2018-10-31 09:42:14 +00:00
			`println!("REQUEST {} {}", method, path);`
start implementing request handler 2018-11-01 10:30:49 +00:00			`println!("COMPO {:?}", components);`

			`if comp_len >= 1 && components[0] == "api3" {`
			`println!("GOT API REQUEST");`
			`if comp_len >= 2 {`
			`let format = components[1];`
			`if format != "json" {`
			`http_error!(NOT_FOUND, format!("Unsupported format '{}'\n", format))`
			`}`

avoid static references 2018-11-03 14:10:21 +00:00			`if let Some(info) = ROUTER.find_method(&components[2..]) {`
start implementing request handler 2018-11-01 10:30:49 +00:00			`println!("FOUND INFO");`
			`let api_method_opt = match method {`
avoid static references 2018-11-03 14:10:21 +00:00			`&Method::GET => &info.get,`
move parse_query into json_schema 2018-11-05 14:20:27 +00:00			`&Method::PUT => &info.put,`
			`&Method::POST => &info.post,`
			`&Method::DELETE => &info.delete,`
avoid static references 2018-11-03 14:10:21 +00:00			`_ => &None,`
start implementing request handler 2018-11-01 10:30:49 +00:00			`};`
new subdirmap macro, cleanups 2018-11-01 14:41:08 +00:00			`let api_method = match api_method_opt {`
start implementing request handler 2018-11-01 10:30:49 +00:00			`Some(m) => m,`
			`_ => http_error!(NOT_FOUND, format!("No such method '{} {}'\n", method, path)),`
			`};`

code cleanup 2018-11-07 12:58:09 +00:00			`// fixme: handle auth`
start implementing request handler 2018-11-01 10:30:49 +00:00
			`// extract param`
new subdirmap macro, cleanups 2018-11-01 14:41:08 +00:00			`let param = match query {`
move parse_query into json_schema 2018-11-05 14:20:27 +00:00			`Some(data) => {`
test for required parameters 2018-11-06 13:18:13 +00:00			`match parse_query_string(data, &api_method.parameters, true) {`
move parse_query into json_schema 2018-11-05 14:20:27 +00:00			`Ok(query) => query,`
implement simple schema parser 2018-11-06 12:10:10 +00:00			`Err(ref error_list) => {`
code cleanup 2018-11-07 12:58:09 +00:00			`let msg = error_list.iter().fold(String::from(""), \|acc, item\| {`
			`acc + &item.to_string() + "\n"`
			`});`
implement simple schema parser 2018-11-06 12:10:10 +00:00			`http_error!(BAD_REQUEST, msg);`
			`}`
move parse_query into json_schema 2018-11-05 14:20:27 +00:00			`}`
			`}`
start implementing request handler 2018-11-01 10:30:49 +00:00			`None => json!({}),`
			`};`

pass ApiMethod to handler 2018-11-07 10:06:37 +00:00			`match (api_method.handler)(param, &api_method) {`
new subdirmap macro, cleanups 2018-11-01 14:41:08 +00:00			`Ok(res) => {`
			`let json_str = res.to_string();`
			`return Response::new(Body::from(json_str));`
			`}`
			`Err(err) => {`
			`http_error!(NOT_FOUND, format!("Method returned error '{}'\n", err));`
			`}`
			`}`

start implementing request handler 2018-11-01 10:30:49 +00:00			`} else {`
			`http_error!(NOT_FOUND, format!("No such path '{}'\n", path));`
			`}`
			`}`
			`}`
split code into several files 2018-10-31 09:42:14 +00:00
start implementing request handler 2018-11-01 10:30:49 +00:00			`Response::new(Body::from("RETURN WEB GUI\n"))`
split code into several files 2018-10-31 09:42:14 +00:00			`}`

another way to initialize the api tree 2018-11-03 09:42:48 +00:00			`lazy_static!{`
avoid static references 2018-11-03 14:10:21 +00:00			`static ref ROUTER: MethodInfo = apitest::api3::router();`
another way to initialize the api tree 2018-11-03 09:42:48 +00:00			`}`

initial version 2018-10-30 09:04:30 +00:00			`fn main() {`
			`println!("Fast Static Type Definitions 1");`

split code into several files 2018-10-31 09:42:14 +00:00			`let addr = ([127, 0, 0, 1], 8007).into();`

			`let new_svc = \|\| {`
			// service_fn_ok converts our function into a `Service`
start implementing request handler 2018-11-01 10:30:49 +00:00			`service_fn_ok(handle_request)`
split code into several files 2018-10-31 09:42:14 +00:00			`};`

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

			`// Run this server for... forever!`
			`hyper::rt::run(server);`
initial version 2018-10-30 09:04:30 +00:00			`}`