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 tokio::prelude::*;
use tokio::timer::Delay;

//use hyper::body::Payload;
use hyper::http::request::Parts;
use hyper::{Method, Body, Request, Response, Server, StatusCode};
use hyper::rt::{Future, Stream};
use hyper::service::service_fn;

use futures::future::*;

use std::time::{Duration, Instant};

type BoxFut = Box<Future<Item = Response<Body>, Error = failure::Error> + Send>;

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

macro_rules! http_error_future {
    ($status:ident, $msg:expr) => {{
        let resp = error_response!($status, $msg);
        return Box::new(ok(resp));
    }}
}

fn get_request_parameters_async<'a>(
    info: &'a ApiMethod,
    parts: Parts,
    req_body: Body,
) -> Box<Future<Item = Value, Error = failure::Error> + Send + 'a>
{
    let resp = req_body.concat2()
        .map_err(|err| format_err!("Promlems reading request body: {}", err))
        .and_then(move |body| {

            let bytes = String::from_utf8(body.to_vec())?; // why copy??

            println!("GOT BODY {:?}", bytes);

            let mut test_required = true;

            let mut params = json!({});

            if bytes.len() > 0 {
                params = parse_query_string(&bytes, &info.parameters, true)?;
                test_required = false;
            }

            if let Some(query_str) = parts.uri.query() {
                let query_params = parse_query_string(query_str, &info.parameters, test_required)?;

                for (k, v) in query_params.as_object().unwrap() {
                    params[k] = v.clone(); // fixme: why clone()??
                }
            }

            println!("GOT PARAMS {}", params);
            Ok(params)
        });

    Box::new(resp)
}

fn handle_async_api_request<'a>(
    info: &'a ApiMethod,
    parts: Parts,
    req_body: Body,
) -> Box<Future<Item = Response<Body>, Error = failure::Error> + Send + 'a>
{
    let params = get_request_parameters_async(info, parts, req_body);

    let resp = params
        .and_then(move |params| {

            println!("GOT PARAMS {}", params);

            /*
            let when = Instant::now() + Duration::from_millis(3000);
            let task = Delay::new(when).then(|_| {
                println!("A LAZY TASK");
                ok(())
            });

            tokio::spawn(task);
             */

            (info.async_handler)(params, info)
        });

    Box::new(resp)
}

fn handle_sync_api_request<'a>(
    info: &'a ApiMethod,
    parts: Parts,
    req_body: Body,
) -> Box<Future<Item = Response<Body>, Error = failure::Error> + Send + 'a>
{
    let params = get_request_parameters_async(info, parts, req_body);

    let resp = params
        .and_then(move |params| {

            println!("GOT PARAMS {}", params);

            /*
            let when = Instant::now() + Duration::from_millis(3000);
            let task = Delay::new(when).then(|_| {
                println!("A LAZY TASK");
                ok(())
            });

            tokio::spawn(task);
             */

            let res = (info.handler)(params, info)?;

            Ok(res)

        }).then(|result| {
            match result {
                Ok(ref value) => {
                    let json_str = value.to_string();

                    Ok(Response::builder()
                       .status(StatusCode::OK)
                       .header("ContentType", "application/json")
                       .body(Body::from(json_str))?)
                }
                Err(err) => Ok(error_response!(BAD_REQUEST, err.to_string()))
            }
        });

    Box::new(resp)
}

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

    let (parts, body) = req.into_parts();

    let method = parts.method.clone();
    let path = parts.uri.path();

    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_future!(BAD_REQUEST, format!("Unsupported output format '{}'.", 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_future!(NOT_FOUND, format!("No such method '{}'.", method)),
                };

                // fixme: handle auth

                //return handle_sync_api_request(api_method, parts, body);
                return handle_async_api_request(api_method, parts, body);

            } else {
                http_error_future!(NOT_FOUND, "Path not found.");
            }
        }
    }

    Box::new(ok(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(|req| {
            // clumsy way to convert failure::Error to Response
            handle_request(req).then(|result| -> Result<Response<Body>, String> {
                match result {
                    Ok(res) => Ok(res),
                    Err(err) => Ok(error_response!(BAD_REQUEST, err.to_string())),
                }
            })
        })
    };

    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
call api method and return result 2018-11-09 12:48:57 +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};`
play around with async tasks 2018-11-10 11:06:39 +00:00			`use serde_json::{json, Value};`

			`use tokio::prelude::*;`
			`use tokio::timer::Delay;`
try to define an static api 2018-10-30 13:06:37 +00:00
call api method and return result 2018-11-09 12:48:57 +00:00			`//use hyper::body::Payload;`
use futures - first try 2018-11-09 07:22:54 +00:00			`use hyper::http::request::Parts;`
start implementing request handler 2018-11-01 10:30:49 +00:00			`use hyper::{Method, Body, Request, Response, Server, StatusCode};`
use futures - first try 2018-11-09 07:22:54 +00:00			`use hyper::rt::{Future, Stream};`
			`use hyper::service::service_fn;`

play around with async tasks 2018-11-10 11:06:39 +00:00			`use futures::future::*;`

			`use std::time::{Duration, Instant};`
use futures - first try 2018-11-09 07:22:54 +00:00
cleanup futures 2018-11-10 09:00:48 +00:00			`type BoxFut = Box<Future<Item = Response<Body>, Error = failure::Error> + Send>;`
initial version 2018-10-30 09:04:30 +00:00
cleanup futures 2018-11-10 09:00:48 +00:00			`macro_rules! error_response {`
start implementing request handler 2018-11-01 10:30:49 +00:00			`($status:ident, $msg:expr) => {{`
			`let mut resp = Response::new(Body::from($msg));`
			`*resp.status_mut() = StatusCode::$status;`
cleanup futures 2018-11-10 09:00:48 +00:00			`resp`
use futures - first try 2018-11-09 07:22:54 +00:00			`}}`
			`}`
cleanup futures 2018-11-10 09:00:48 +00:00
use futures - first try 2018-11-09 07:22:54 +00:00			`macro_rules! http_error_future {`
			`($status:ident, $msg:expr) => {{`
cleanup futures 2018-11-10 09:00:48 +00:00			`let resp = error_response!($status, $msg);`
play around with async tasks 2018-11-10 11:06:39 +00:00			`return Box::new(ok(resp));`
start implementing request handler 2018-11-01 10:30:49 +00:00			`}}`
			`}`

play around with async tasks 2018-11-10 11:06:39 +00:00			`fn get_request_parameters_async<'a>(`
call api method and return result 2018-11-09 12:48:57 +00:00			`info: &'a ApiMethod,`
			`parts: Parts,`
			`req_body: Body,`
play around with async tasks 2018-11-10 11:06:39 +00:00			`) -> Box<Future<Item = Value, Error = failure::Error> + Send + 'a>`
use futures - first try 2018-11-09 07:22:54 +00:00			`{`
cleanup futures 2018-11-10 09:00:48 +00:00			`let resp = req_body.concat2()`
			`.map_err(\|err\| format_err!("Promlems reading request body: {}", err))`
			`.and_then(move \|body\| {`
use futures - first try 2018-11-09 07:22:54 +00:00
cleanup futures 2018-11-10 09:00:48 +00:00			`let bytes = String::from_utf8(body.to_vec())?; // why copy??`
use futures - first try 2018-11-09 07:22:54 +00:00
cleanup futures 2018-11-10 09:00:48 +00:00			`println!("GOT BODY {:?}", bytes);`
use futures - first try 2018-11-09 07:22:54 +00:00
cleanup futures 2018-11-10 09:00:48 +00:00			`let mut test_required = true;`
use futures - first try 2018-11-09 07:22:54 +00:00
cleanup futures 2018-11-10 09:00:48 +00:00			`let mut params = json!({});`
call api method and return result 2018-11-09 12:48:57 +00:00
cleanup futures 2018-11-10 09:00:48 +00:00			`if bytes.len() > 0 {`
			`params = parse_query_string(&bytes, &info.parameters, true)?;`
			`test_required = false;`
			`}`
call api method and return result 2018-11-09 12:48:57 +00:00
cleanup futures 2018-11-10 09:00:48 +00:00			`if let Some(query_str) = parts.uri.query() {`
			`let query_params = parse_query_string(query_str, &info.parameters, test_required)?;`
call api method and return result 2018-11-09 12:48:57 +00:00
cleanup futures 2018-11-10 09:00:48 +00:00			`for (k, v) in query_params.as_object().unwrap() {`
			`params[k] = v.clone(); // fixme: why clone()??`
			`}`
use futures - first try 2018-11-09 07:22:54 +00:00			`}`

play around with async tasks 2018-11-10 11:06:39 +00:00			`println!("GOT PARAMS {}", params);`
			`Ok(params)`
			`});`

			`Box::new(resp)`
			`}`

			`fn handle_async_api_request<'a>(`
			`info: &'a ApiMethod,`
			`parts: Parts,`
			`req_body: Body,`
			`) -> Box<Future<Item = Response<Body>, Error = failure::Error> + Send + 'a>`
			`{`
			`let params = get_request_parameters_async(info, parts, req_body);`

			`let resp = params`
			`.and_then(move \|params\| {`

			`println!("GOT PARAMS {}", params);`

			`/*`
			`let when = Instant::now() + Duration::from_millis(3000);`
			`let task = Delay::new(when).then(\|_\| {`
			`println!("A LAZY TASK");`
			`ok(())`
			`});`

			`tokio::spawn(task);`
			`*/`

			`(info.async_handler)(params, info)`
			`});`

			`Box::new(resp)`
			`}`

			`fn handle_sync_api_request<'a>(`
			`info: &'a ApiMethod,`
			`parts: Parts,`
			`req_body: Body,`
			`) -> Box<Future<Item = Response<Body>, Error = failure::Error> + Send + 'a>`
			`{`
			`let params = get_request_parameters_async(info, parts, req_body);`

			`let resp = params`
			`.and_then(move \|params\| {`

cleanup futures 2018-11-10 09:00:48 +00:00			`println!("GOT PARAMS {}", params);`

play around with async tasks 2018-11-10 11:06:39 +00:00			`/*`
			`let when = Instant::now() + Duration::from_millis(3000);`
			`let task = Delay::new(when).then(\|_\| {`
			`println!("A LAZY TASK");`
			`ok(())`
			`});`

			`tokio::spawn(task);`
			`*/`

cleanup futures 2018-11-10 09:00:48 +00:00			`let res = (info.handler)(params, info)?;`
call api method and return result 2018-11-09 12:48:57 +00:00
cleanup futures 2018-11-10 09:00:48 +00:00			`Ok(res)`
call api method and return result 2018-11-09 12:48:57 +00:00
play around with async tasks 2018-11-10 11:06:39 +00:00			`}).then(\|result\| {`
			`match result {`
			`Ok(ref value) => {`
			`let json_str = value.to_string();`
call api method and return result 2018-11-09 12:48:57 +00:00
play around with async tasks 2018-11-10 11:06:39 +00:00			`Ok(Response::builder()`
			`.status(StatusCode::OK)`
			`.header("ContentType", "application/json")`
			`.body(Body::from(json_str))?)`
			`}`
			`Err(err) => Ok(error_response!(BAD_REQUEST, err.to_string()))`
cleanup futures 2018-11-10 09:00:48 +00:00			`}`
play around with async tasks 2018-11-10 11:06:39 +00:00			`});`
use futures - first try 2018-11-09 07:22:54 +00:00
			`Box::new(resp)`
			`}`

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

			`let (parts, body) = req.into_parts();`
start implementing request handler 2018-11-01 10:30:49 +00:00
use futures - first try 2018-11-09 07:22:54 +00:00			`let method = parts.method.clone();`
			`let path = parts.uri.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			`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" {`
use better http status codes 2018-11-10 09:32:25 +00:00			`http_error_future!(BAD_REQUEST, format!("Unsupported output format '{}'.", format))`
start implementing request handler 2018-11-01 10:30:49 +00:00			`}`

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 {`
use futures - first try 2018-11-09 07:22:54 +00:00			`Method::GET => &info.get,`
			`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,`
use better http status codes 2018-11-10 09:32:25 +00:00			`_ => http_error_future!(NOT_FOUND, format!("No such method '{}'.", method)),`
start implementing request handler 2018-11-01 10:30:49 +00:00			`};`

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
play around with async tasks 2018-11-10 11:06:39 +00:00			`//return handle_sync_api_request(api_method, parts, body);`
			`return handle_async_api_request(api_method, parts, body);`
use futures - first try 2018-11-09 07:22:54 +00:00
start implementing request handler 2018-11-01 10:30:49 +00:00			`} else {`
use better http status codes 2018-11-10 09:32:25 +00:00			`http_error_future!(NOT_FOUND, "Path not found.");`
start implementing request handler 2018-11-01 10:30:49 +00:00			`}`
			`}`
			`}`
split code into several files 2018-10-31 09:42:14 +00:00
play around with async tasks 2018-11-10 11:06:39 +00:00			`Box::new(ok(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 = \|\| {`
cleanup futures 2018-11-10 09:00:48 +00:00			`service_fn(\|req\| {`
			`// clumsy way to convert failure::Error to Response`
			`handle_request(req).then(\|result\| -> Result<Response<Body>, String> {`
			`match result {`
			`Ok(res) => Ok(res),`
use better http status codes 2018-11-10 09:32:25 +00:00			`Err(err) => Ok(error_response!(BAD_REQUEST, err.to_string())),`
cleanup futures 2018-11-10 09:00:48 +00:00			`}`
			`})`
			`})`
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			`}`