proxmox-backup/src/main.rs

extern crate apitest;

use failure::*;
use std::collections::HashMap;
//use std::io;
//use std::fs;
use std::path::{PathBuf};

//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 futures::future::{self, Either};
//use tokio::prelude::*;
//use tokio::timer::Delay;
use tokio::fs::File;
use tokio_codec;
//use bytes::{BytesMut, BufMut};

//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 hyper::header;

//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(future::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
        .map_err(|err| Error::from(ApiError::new(StatusCode::BAD_REQUEST, format!("Promlems reading request body: {}", err))))
        .fold(Vec::new(), |mut acc, chunk| {
            if acc.len() + chunk.len() < 64*1024 { //fimxe: max request body size?
                acc.extend_from_slice(&*chunk);
                Ok(acc)
            }
            else { Err(Error::from(ApiError::new(StatusCode::BAD_REQUEST, format!("Request body too large")))) }
        })
        .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(header::CONTENT_TYPE, "application/json")
                       .body(Body::from(json_str))?)
                }
                Err(err) => Ok(error_response!(BAD_REQUEST, err.to_string()))
            }
        });

    Box::new(resp)
}

fn simple_static_file_download(filename: PathBuf) ->  BoxFut {

    Box::new(File::open(filename)
        .map_err(|err| Error::from(ApiError::new(StatusCode::BAD_REQUEST, format!("File open failed: {}", err))))
        .and_then(|file| {
            let buf: Vec<u8> = Vec::new();
            tokio::io::read_to_end(file, buf)
                .map_err(|err| Error::from(ApiError::new(StatusCode::BAD_REQUEST, format!("File read failed: {}", err))))
                .and_then(|data| Ok(Response::new(data.1.into())))
        }))
}

fn chuncked_static_file_download(filename: PathBuf) ->  BoxFut {

    Box::new(File::open(filename)
        .map_err(|err| Error::from(ApiError::new(StatusCode::BAD_REQUEST, format!("File open failed: {}", err))))
        .and_then(|file| {
            let payload = tokio_codec::FramedRead::new(file, tokio_codec::BytesCodec::new()).
                map(|bytes| {
                    //sigh - howto avoid copy here? or the whole map() ??
                    hyper::Chunk::from(bytes.to_vec())
                });
            let body = Body::wrap_stream(payload);
            // fixme: set content type and other headers
            Ok(Response::builder()
               .status(StatusCode::OK)
               .body(body)
               .unwrap())
        }))
}

fn handle_static_file_download(filename: PathBuf) ->  BoxFut {

    let response = tokio::fs::metadata(filename.clone())
        .map_err(|err| Error::from(ApiError::new(StatusCode::BAD_REQUEST, format!("File access problems: {}", err))))
        .and_then(|metadata| {
            if metadata.len() < 1024*32 {
                Either::A(simple_static_file_download(filename))
            } else {
                Either::B(chuncked_static_file_download(filename))
             }
        });

    return Box::new(response);
}

fn handle_request(api: &ApiServer, req: Request<Body>) -> BoxFut {

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

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

    // normalize path
    // do not allow ".", "..", or hidden files ".XXXX"
    // also remove empty path components

    let items = path.split('/');
    let mut path = String::new();
    let mut components = vec![];

    for name in items {
        if name.is_empty() { continue; }
        if name.starts_with(".") {
            http_error_future!(BAD_REQUEST, "Path contains illegal components.\n");
        }
        path.push('/');
        path.push_str(name);
        components.push(name);
    }

    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) = api.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 {
        // not Auth for accessing files!

        let mut prefix = String::new();
        let mut filename = PathBuf::from("/var/www"); // fixme
        if comp_len >= 1 {
            prefix.push_str(components[0]);
            if let Some(subdir) = api.aliases.get(&prefix) {
                filename.push(subdir);
                for i in 1..comp_len { filename.push(components[i]) }
            }
        }
        return handle_static_file_download(filename);
    }


    http_error_future!(NOT_FOUND, "Path not found.")
    //Box::new(ok(Response::new(Body::from("RETURN WEB GUI\n"))))
}

// add default dirs which includes jquery and bootstrap
// my $base = '/usr/share/libpve-http-server-perl';
// add_dirs($self->{dirs}, '/css/' => "$base/css/");
// add_dirs($self->{dirs}, '/js/' => "$base/js/");
// add_dirs($self->{dirs}, '/fonts/' => "$base/fonts/");


fn initialize_directory_aliases() -> HashMap<String, PathBuf> {

    let mut basedirs:  HashMap<String, PathBuf> = HashMap::new();

    let mut add_directory_alias = |name, path| {
        basedirs.insert(String::from(name), PathBuf::from(path));
    };

    add_directory_alias("novnc", "/usr/share/novnc-pve");
    add_directory_alias("extjs", "/usr/share/javascript/extjs");
    add_directory_alias("fontawesome", "/usr/share/fonts-font-awesome");
    add_directory_alias("xtermjs", "/usr/share/pve-xtermjs");
    add_directory_alias("widgettoolkit", "/usr/share/javascript/proxmox-widget-toolkit");

    basedirs
}

struct ApiServer {
    basedir: PathBuf,
    router: &'static MethodInfo,
    aliases: &'static HashMap<String, PathBuf>,
}

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

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

    let new_svc = || {
        service_fn(|req| {

            lazy_static!{
                static ref ALIASES: HashMap<String, PathBuf> = initialize_directory_aliases();
                static ref ROUTER: MethodInfo = apitest::api3::router();
            }

            let api_server = ApiServer {
                basedir: "/var/www". into(),
                router: &ROUTER,
                aliases: &ALIASES,
            };

            handle_request(&api_server, req).then(|result| {
                match result {
                    Ok(res) => Ok::<_,String>(res),
                    Err(err) => {
                        if let Some(apierr) = err.downcast_ref::<ApiError>() {
                            let mut resp = Response::new(Body::from(apierr.message.clone()));
                            *resp.status_mut() = apierr.code;
                            Ok(resp)
                        } else {
                            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::*;`
add code to create directory name cache 2018-11-10 16:17:41 +00:00			`use std::collections::HashMap;`
remove static directory cache 2018-11-12 13:11:04 +00:00			`//use std::io;`
improve error handling, use a Service 2018-11-13 11:36:56 +00:00			`//use std::fs;`
			`use std::path::{PathBuf};`
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};`

improve error handling, use a Service 2018-11-13 11:36:56 +00:00			`use futures::future::{self, Either};`
implement static file download Fully async using futures and stream. 2018-11-11 14:54:05 +00:00			`//use tokio::prelude::*;`
			`//use tokio::timer::Delay;`
			`use tokio::fs::File;`
			`use tokio_codec;`
			`//use bytes::{BytesMut, BufMut};`
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};`
remove service implementation, use service_fn again 2018-11-13 13:47:03 +00:00			`use hyper::service::service_fn;`
use header::CONTENT_TYPE 2018-11-11 11:55:30 +00:00			`use hyper::header;`
use futures - first try 2018-11-09 07:22:54 +00:00
implement static file download Fully async using futures and stream. 2018-11-11 14:54:05 +00:00			`//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);`
improve error handling, use a Service 2018-11-13 11:36:56 +00:00			`return Box::new(future::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			`{`
limit allowed body size 2018-11-11 12:24:14 +00:00			`let resp = req_body`
improve error handling, use a Service 2018-11-13 11:36:56 +00:00			`.map_err(\|err\| Error::from(ApiError::new(StatusCode::BAD_REQUEST, format!("Promlems reading request body: {}", err))))`
limit allowed body size 2018-11-11 12:24:14 +00:00			`.fold(Vec::new(), \|mut acc, chunk\| {`
			`if acc.len() + chunk.len() < 64*1024 { //fimxe: max request body size?`
			`acc.extend_from_slice(&*chunk);`
simplify code 2018-11-14 10:38:26 +00:00			`Ok(acc)`
limit allowed body size 2018-11-11 12:24:14 +00:00			`}`
simplify code 2018-11-14 10:38:26 +00:00			`else { Err(Error::from(ApiError::new(StatusCode::BAD_REQUEST, format!("Request body too large")))) }`
limit allowed body size 2018-11-11 12:24:14 +00:00			`})`
cleanup futures 2018-11-10 09:00:48 +00:00			`.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)`
use header::CONTENT_TYPE 2018-11-11 11:55:30 +00:00			`.header(header::CONTENT_TYPE, "application/json")`
play around with async tasks 2018-11-10 11:06:39 +00:00			`.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)`
			`}`

code cleanup 2018-11-11 16:19:24 +00:00			`fn simple_static_file_download(filename: PathBuf) -> BoxFut {`

			`Box::new(File::open(filename)`
improve error handling, use a Service 2018-11-13 11:36:56 +00:00			`.map_err(\|err\| Error::from(ApiError::new(StatusCode::BAD_REQUEST, format!("File open failed: {}", err))))`
code cleanup 2018-11-11 16:19:24 +00:00			`.and_then(\|file\| {`
			`let buf: Vec<u8> = Vec::new();`
			`tokio::io::read_to_end(file, buf)`
improve error handling, use a Service 2018-11-13 11:36:56 +00:00			`.map_err(\|err\| Error::from(ApiError::new(StatusCode::BAD_REQUEST, format!("File read failed: {}", err))))`
code cleanup 2018-11-11 16:19:24 +00:00			`.and_then(\|data\| Ok(Response::new(data.1.into())))`
			`}))`
			`}`

			`fn chuncked_static_file_download(filename: PathBuf) -> BoxFut {`

			`Box::new(File::open(filename)`
improve error handling, use a Service 2018-11-13 11:36:56 +00:00			`.map_err(\|err\| Error::from(ApiError::new(StatusCode::BAD_REQUEST, format!("File open failed: {}", err))))`
code cleanup 2018-11-11 16:19:24 +00:00			`.and_then(\|file\| {`
			`let payload = tokio_codec::FramedRead::new(file, tokio_codec::BytesCodec::new()).`
			`map(\|bytes\| {`
			`//sigh - howto avoid copy here? or the whole map() ??`
			`hyper::Chunk::from(bytes.to_vec())`
			`});`
			`let body = Body::wrap_stream(payload);`
			`// fixme: set content type and other headers`
			`Ok(Response::builder()`
			`.status(StatusCode::OK)`
			`.body(body)`
			`.unwrap())`
			`}))`
			`}`

implement static file download Fully async using futures and stream. 2018-11-11 14:54:05 +00:00			`fn handle_static_file_download(filename: PathBuf) -> BoxFut {`

handle_static_file_download: optimize small files Avoid chuncked transfer for small files. 2018-11-11 16:10:42 +00:00			`let response = tokio::fs::metadata(filename.clone())`
improve error handling, use a Service 2018-11-13 11:36:56 +00:00			`.map_err(\|err\| Error::from(ApiError::new(StatusCode::BAD_REQUEST, format!("File access problems: {}", err))))`
handle_static_file_download: optimize small files Avoid chuncked transfer for small files. 2018-11-11 16:10:42 +00:00			`.and_then(\|metadata\| {`
code cleanup 2018-11-11 16:19:24 +00:00			`if metadata.len() < 1024*32 {`
			`Either::A(simple_static_file_download(filename))`
handle_static_file_download: optimize small files Avoid chuncked transfer for small files. 2018-11-11 16:10:42 +00:00			`} else {`
code cleanup 2018-11-11 16:19:24 +00:00			`Either::B(chuncked_static_file_download(filename))`
			`}`
implement static file download Fully async using futures and stream. 2018-11-11 14:54:05 +00:00			`});`

			`return Box::new(response);`
			`}`

remove service implementation, use service_fn again 2018-11-13 13:47:03 +00:00			`fn handle_request(api: &ApiServer, req: Request<Body>) -> BoxFut {`
use futures - first try 2018-11-09 07:22:54 +00:00
			`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
implement static file download Fully async using futures and stream. 2018-11-11 14:54:05 +00:00			`// normalize path`
santtize paths in handle_request 2018-11-12 12:19:53 +00:00			`// do not allow ".", "..", or hidden files ".XXXX"`
			`// also remove empty path components`

			`let items = path.split('/');`
			`let mut path = String::new();`
			`let mut components = vec![];`

			`for name in items {`
			`if name.is_empty() { continue; }`
			`if name.starts_with(".") {`
			`http_error_future!(BAD_REQUEST, "Path contains illegal components.\n");`
			`}`
			`path.push('/');`
			`path.push_str(name);`
			`components.push(name);`
			`}`

start implementing request handler 2018-11-01 10:30:49 +00:00			`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			`}`

remove service implementation, use service_fn again 2018-11-13 13:47:03 +00:00			`if let Some(info) = api.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);`
start implementing request handler 2018-11-01 10:30:49 +00:00			`}`
			`}`
remove static directory cache 2018-11-12 13:11:04 +00:00			`} else {`
			`// not Auth for accessing files!`

			`let mut prefix = String::new();`
			`let mut filename = PathBuf::from("/var/www"); // fixme`
			`if comp_len >= 1 {`
			`prefix.push_str(components[0]);`
remove service implementation, use service_fn again 2018-11-13 13:47:03 +00:00			`if let Some(subdir) = api.aliases.get(&prefix) {`
remove static directory cache 2018-11-12 13:11:04 +00:00			`filename.push(subdir);`
			`for i in 1..comp_len { filename.push(components[i]) }`
			`}`
			`}`
			`return handle_static_file_download(filename);`
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
implement static file download Fully async using futures and stream. 2018-11-11 14:54:05 +00:00
			`http_error_future!(NOT_FOUND, "Path not found.")`
			`//Box::new(ok(Response::new(Body::from("RETURN WEB GUI\n"))))`
split code into several files 2018-10-31 09:42:14 +00:00			`}`

add code to create directory name cache 2018-11-10 16:17:41 +00:00			`// add default dirs which includes jquery and bootstrap`
			`// my $base = '/usr/share/libpve-http-server-perl';`
			`// add_dirs($self->{dirs}, '/css/' => "$base/css/");`
			`// add_dirs($self->{dirs}, '/js/' => "$base/js/");`
			`// add_dirs($self->{dirs}, '/fonts/' => "$base/fonts/");`


remove static directory cache 2018-11-12 13:11:04 +00:00			`fn initialize_directory_aliases() -> HashMap<String, PathBuf> {`
add code to create directory name cache 2018-11-10 16:17:41 +00:00
remove static directory cache 2018-11-12 13:11:04 +00:00			`let mut basedirs: HashMap<String, PathBuf> = HashMap::new();`
add code to create directory name cache 2018-11-10 16:17:41 +00:00
remove static directory cache 2018-11-12 13:11:04 +00:00			`let mut add_directory_alias = \|name, path\| {`
			`basedirs.insert(String::from(name), PathBuf::from(path));`
			`};`
add code to create directory name cache 2018-11-10 16:17:41 +00:00
remove static directory cache 2018-11-12 13:11:04 +00:00			`add_directory_alias("novnc", "/usr/share/novnc-pve");`
			`add_directory_alias("extjs", "/usr/share/javascript/extjs");`
			`add_directory_alias("fontawesome", "/usr/share/fonts-font-awesome");`
			`add_directory_alias("xtermjs", "/usr/share/pve-xtermjs");`
			`add_directory_alias("widgettoolkit", "/usr/share/javascript/proxmox-widget-toolkit");`
add code to create directory name cache 2018-11-10 16:17:41 +00:00
remove static directory cache 2018-11-12 13:11:04 +00:00			`basedirs`
add code to create directory name cache 2018-11-10 16:17:41 +00:00			`}`

improve error handling, use a Service 2018-11-13 11:36:56 +00:00			`struct ApiServer {`
			`basedir: PathBuf,`
remove service implementation, use service_fn again 2018-11-13 13:47:03 +00:00			`router: &'static MethodInfo,`
			`aliases: &'static HashMap<String, PathBuf>,`
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 = \|\| {`
remove service implementation, use service_fn again 2018-11-13 13:47:03 +00:00			`service_fn(\|req\| {`

			`lazy_static!{`
			`static ref ALIASES: HashMap<String, PathBuf> = initialize_directory_aliases();`
			`static ref ROUTER: MethodInfo = apitest::api3::router();`
			`}`

			`let api_server = ApiServer {`
			`basedir: "/var/www". into(),`
			`router: &ROUTER,`
			`aliases: &ALIASES,`
			`};`

			`handle_request(&api_server, req).then(\|result\| {`
			`match result {`
			`Ok(res) => Ok::<_,String>(res),`
			`Err(err) => {`
			`if let Some(apierr) = err.downcast_ref::<ApiError>() {`
			`let mut resp = Response::new(Body::from(apierr.message.clone()));`
			`*resp.status_mut() = apierr.code;`
			`Ok(resp)`
			`} else {`
			`Ok(error_response!(BAD_REQUEST, err.to_string()))`
			`}`
			`}`
			`}`
			`})`
			`})`
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			`}`