tyler
/
proxmox-backup
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
proxmox-backup/src/main.rs

339 lines
9.9 KiB
Rust
Raw Normal View History

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;
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};
implement static file download Fully async using futures and stream.
2018-11-11 14:54:05 +00:00
use futures::future::*;
//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};
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);
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
{
limit allowed body size
2018-11-11 12:24:14 +00:00
let resp = req_body
cleanup futures
2018-11-10 09:00:48 +00:00
.map_err(|err| format_err!("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);
ok(acc)
} else {
err(format_err!("Request body too large"))
}
})
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)
}
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 {
let response = File::open(filename)
.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())
})
.or_else(|err| {
// fixme: set content type and other headers
Ok(Response::builder()
.status(StatusCode::NOT_FOUND)
.body(format!("File access problems: {}\n", err).into())
.unwrap())
});
return Box::new(response);
}
use futures - first try
2018-11-09 07:22:54 +00:00
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
implement static file download Fully async using futures and stream.
2018-11-11 14:54:05 +00:00
// normalize path
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();
implement static file download Fully async using futures and stream.
2018-11-11 14:54:05 +00:00
let path = components.iter().fold(String::new(), |mut acc, chunk| {
acc.push('/');
acc.push_str(chunk);
acc
});
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);
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
// not Auth for accessing files!
if let Some(filename) = CACHED_DIRS.get(&path) {
println!("SERVER STATIC FILE {:?}", path);
return handle_static_file_download(filename.clone());
}
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/");
implement static file download Fully async using futures and stream.
2018-11-11 14:54:05 +00:00
//use std::io;
use std::fs;
add code to create directory name cache
2018-11-10 16:17:41 +00:00
use std::path::{Path, PathBuf};
fn add_dirs(cache: &mut HashMap<String, PathBuf>, alias: String, path: &Path) -> Result<(), Error> {
if path.is_dir() {
for direntry in fs::read_dir(path)? {
let entry = direntry?;
let entry_path = entry.path();
let file_type = entry.file_type()?;
if let Some(file_name) = entry_path.file_name() {
let newalias = alias.clone() + &String::from(file_name.to_string_lossy()); // fixme
if file_type.is_dir() {
add_dirs(cache, newalias, entry_path.as_path())?;
} else if file_type.is_file() {
cache.insert(newalias, entry_path);
}
}
}
}
Ok(())
}
fn initialize_directory_cache() -> HashMap<String, PathBuf> {
let mut basedirs = HashMap::new();
basedirs.insert("novnc", Path::new("/usr/share/novnc-pve"));
basedirs.insert("extjs", Path::new("/usr/share/javascript/extjs"));
basedirs.insert("fontawesome", Path::new("/usr/share/fonts-font-awesome"));
basedirs.insert("xtermjs", Path::new("/usr/share/pve-xtermjs"));
basedirs.insert("widgettoolkit", Path::new("/usr/share/javascript/proxmox-widget-toolkit"));
let mut cache = HashMap::new();
implement static file download Fully async using futures and stream.
2018-11-11 14:54:05 +00:00
if let Err(err) = add_dirs(&mut cache, "/pve2/ext6/".into(), basedirs["extjs"]) {
eprintln!("directory cache init error: {}", err);
}
add code to create directory name cache
2018-11-10 16:17:41 +00:00
cache
}
lazy_static!{
static ref CACHED_DIRS: HashMap<String, PathBuf> = initialize_directory_cache();
}
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");
implement static file download Fully async using futures and stream.
2018-11-11 14:54:05 +00:00
let count = CACHED_DIRS.iter().count();
add code to create directory name cache
2018-11-10 16:17:41 +00:00
println!("Dircache contains {} entries.", count);
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
}