proxmox-backup/src/server/formatter.rs

use failure::*;
use serde_json::{json, Value};

use crate::api_schema::router::{HttpError, RpcEnvironment};

use hyper::{Body, Response, StatusCode};
use hyper::header;

/// Extension to set error message for server side logging
pub struct ErrorMessageExtension(pub String);

pub struct OutputFormatter {

    pub format_data: fn(data: Value, rpcenv: &RpcEnvironment) -> Response<Body>,

    pub format_error: fn(err: Error) -> Response<Body>,
}

static JSON_CONTENT_TYPE: &str = "application/json;charset=UTF-8";

pub fn json_response(result: Result<Value, Error>) -> Response<Body> {
    match result {
        Ok(data) => json_data_response(data),
        Err(err) => json_error_response(err),
    }
}

pub fn json_data_response(data: Value) -> Response<Body> {

    let json_str = data.to_string();

    let raw = json_str.into_bytes();

    let mut response = Response::new(raw.into());
    response.headers_mut().insert(
        header::CONTENT_TYPE,
        header::HeaderValue::from_static(JSON_CONTENT_TYPE));

    response
}

fn json_format_data(data: Value, rpcenv: &RpcEnvironment) -> Response<Body> {

    let mut result = json!({
        "data": data
    });

    if let Some(total) = rpcenv.get_result_attrib("total").and_then(|v| v.as_u64()) {
        result["total"] = Value::from(total);
    }

    if let Some(changes) = rpcenv.get_result_attrib("changes") {
        result["changes"] = changes.clone();
    }

    json_data_response(result)
}

pub fn json_error_response(err: Error) -> Response<Body> {

    let mut response = if let Some(apierr) = err.downcast_ref::<HttpError>() {
        let mut resp = Response::new(Body::from(apierr.message.clone()));
        *resp.status_mut() = apierr.code;
        resp
    } else {
        let mut resp = Response::new(Body::from(err.to_string()));
        *resp.status_mut() = StatusCode::BAD_REQUEST;
        resp
    };

    response.headers_mut().insert(
        header::CONTENT_TYPE,
        header::HeaderValue::from_static(JSON_CONTENT_TYPE));

    response.extensions_mut().insert(ErrorMessageExtension(err.to_string()));

    response
}

pub static JSON_FORMATTER: OutputFormatter = OutputFormatter {
    format_data: json_format_data,
    format_error: json_error_response,
};

fn extjs_format_data(data: Value, rpcenv: &RpcEnvironment) -> Response<Body> {

    let mut result = json!({
        "data": data,
        "success": true
    });

    if let Some(total) = rpcenv.get_result_attrib("total").and_then(|v| v.as_u64()) {
        result["total"] = Value::from(total);
    }

    if let Some(changes) = rpcenv.get_result_attrib("changes") {
        result["changes"] = changes.clone();
    }


    json_data_response(result)
}

fn extjs_format_error(err: Error) -> Response<Body> {

    let mut errors = vec![];

    let message = err.to_string();
    errors.push(&message);

    let result = json!({
        "message": message,
        "errors": errors,
        "success": false
    });

    let mut response = json_data_response(result);

    response.extensions_mut().insert(ErrorMessageExtension(message));

    response
}

pub static EXTJS_FORMATTER: OutputFormatter = OutputFormatter {
    format_data: extjs_format_data,
    format_error: extjs_format_error,
};
add output formatter 2018-12-05 11:42:25 +00:00			`use failure::*;`
			`use serde_json::{json, Value};`

src/server/rest.rs: improve logs for unauthorized request 2019-02-17 16:18:44 +00:00			`use crate::api_schema::router::{HttpError, RpcEnvironment};`
api: pass RpcEnvirnment to api handlers 2019-01-26 13:50:37 +00:00
simplify formatter code 2018-12-05 17:22:56 +00:00			`use hyper::{Body, Response, StatusCode};`
			`use hyper::header;`

server/rest.rs: log full error messages 2019-02-15 08:55:12 +00:00			`/// Extension to set error message for server side logging`
			`pub struct ErrorMessageExtension(pub String);`

add output formatter 2018-12-05 11:42:25 +00:00			`pub struct OutputFormatter {`

src/server/formatter.rs: rename format_result to format_data To avoid confusions with Rust Result type. 2019-05-09 11:15:15 +00:00			`pub format_data: fn(data: Value, rpcenv: &RpcEnvironment) -> Response<Body>,`
api: pass RpcEnvirnment to api handlers 2019-01-26 13:50:37 +00:00
			`pub format_error: fn(err: Error) -> Response<Body>,`
add output formatter 2018-12-05 11:42:25 +00:00			`}`

move rpc environment implementation to separate files 2019-01-26 14:08:02 +00:00			`static JSON_CONTENT_TYPE: &str = "application/json;charset=UTF-8";`
api: pass RpcEnvirnment to api handlers 2019-01-26 13:50:37 +00:00
src/server/formatter.rs: further cleanups and renaming ... 2019-05-09 11:28:26 +00:00			`pub fn json_response(result: Result<Value, Error>) -> Response<Body> {`
			`match result {`
			`Ok(data) => json_data_response(data),`
			`Err(err) => json_error_response(err),`
			`}`
			`}`
api: pass RpcEnvirnment to api handlers 2019-01-26 13:50:37 +00:00
src/server/formatter.rs: further cleanups and renaming ... 2019-05-09 11:28:26 +00:00			`pub fn json_data_response(data: Value) -> Response<Body> {`
api: pass RpcEnvirnment to api handlers 2019-01-26 13:50:37 +00:00
src/server/formatter.rs: further cleanups and renaming ... 2019-05-09 11:28:26 +00:00			`let json_str = data.to_string();`
api: pass RpcEnvirnment to api handlers 2019-01-26 13:50:37 +00:00
			`let raw = json_str.into_bytes();`
add output formatter 2018-12-05 11:42:25 +00:00
api: pass RpcEnvirnment to api handlers 2019-01-26 13:50:37 +00:00			`let mut response = Response::new(raw.into());`
			`response.headers_mut().insert(`
			`header::CONTENT_TYPE,`
move rpc environment implementation to separate files 2019-01-26 14:08:02 +00:00			`header::HeaderValue::from_static(JSON_CONTENT_TYPE));`
add output formatter 2018-12-05 11:42:25 +00:00
api: pass RpcEnvirnment to api handlers 2019-01-26 13:50:37 +00:00			`response`
			`}`
simplify formatter code 2018-12-05 17:22:56 +00:00
src/server/formatter.rs: rename format_result to format_data To avoid confusions with Rust Result type. 2019-05-09 11:15:15 +00:00			`fn json_format_data(data: Value, rpcenv: &RpcEnvironment) -> Response<Body> {`
simplify formatter code 2018-12-05 17:22:56 +00:00
api: pass RpcEnvirnment to api handlers 2019-01-26 13:50:37 +00:00			`let mut result = json!({`
			`"data": data`
			`});`
simplify formatter code 2018-12-05 17:22:56 +00:00
api: pass RpcEnvirnment to api handlers 2019-01-26 13:50:37 +00:00			`if let Some(total) = rpcenv.get_result_attrib("total").and_then(\|v\| v.as_u64()) {`
			`result["total"] = Value::from(total);`
			`}`
simplify formatter code 2018-12-05 17:22:56 +00:00
api: pass RpcEnvirnment to api handlers 2019-01-26 13:50:37 +00:00			`if let Some(changes) = rpcenv.get_result_attrib("changes") {`
			`result["changes"] = changes.clone();`
simplify formatter code 2018-12-05 17:22:56 +00:00			`}`
api: pass RpcEnvirnment to api handlers 2019-01-26 13:50:37 +00:00
src/server/formatter.rs: further cleanups and renaming ... 2019-05-09 11:28:26 +00:00			`json_data_response(result)`
api: pass RpcEnvirnment to api handlers 2019-01-26 13:50:37 +00:00			`}`

src/server/formatter.rs: further cleanups and renaming ... 2019-05-09 11:28:26 +00:00			`pub fn json_error_response(err: Error) -> Response<Body> {`
api: pass RpcEnvirnment to api handlers 2019-01-26 13:50:37 +00:00
src/server/rest.rs: improve logs for unauthorized request 2019-02-17 16:18:44 +00:00			`let mut response = if let Some(apierr) = err.downcast_ref::<HttpError>() {`
			`let mut resp = Response::new(Body::from(apierr.message.clone()));`
			`*resp.status_mut() = apierr.code;`
			`resp`
			`} else {`
			`let mut resp = Response::new(Body::from(err.to_string()));`
			`*resp.status_mut() = StatusCode::BAD_REQUEST;`
			`resp`
			`};`

api: pass RpcEnvirnment to api handlers 2019-01-26 13:50:37 +00:00			`response.headers_mut().insert(`
			`header::CONTENT_TYPE,`
move rpc environment implementation to separate files 2019-01-26 14:08:02 +00:00			`header::HeaderValue::from_static(JSON_CONTENT_TYPE));`
api: pass RpcEnvirnment to api handlers 2019-01-26 13:50:37 +00:00
server/rest.rs: log full error messages 2019-02-15 08:55:12 +00:00			`response.extensions_mut().insert(ErrorMessageExtension(err.to_string()));`

api: pass RpcEnvirnment to api handlers 2019-01-26 13:50:37 +00:00			`response`
add output formatter 2018-12-05 11:42:25 +00:00			`}`

			`pub static JSON_FORMATTER: OutputFormatter = OutputFormatter {`
src/server/formatter.rs: rename format_result to format_data To avoid confusions with Rust Result type. 2019-05-09 11:15:15 +00:00			`format_data: json_format_data,`
src/server/formatter.rs: further cleanups and renaming ... 2019-05-09 11:28:26 +00:00			`format_error: json_error_response,`
add output formatter 2018-12-05 11:42:25 +00:00			`};`

src/server/formatter.rs: rename format_result to format_data To avoid confusions with Rust Result type. 2019-05-09 11:15:15 +00:00			`fn extjs_format_data(data: Value, rpcenv: &RpcEnvironment) -> Response<Body> {`
add output formatter 2018-12-05 11:42:25 +00:00
api: pass RpcEnvirnment to api handlers 2019-01-26 13:50:37 +00:00			`let mut result = json!({`
			`"data": data,`
			`"success": true`
			`});`
add output formatter 2018-12-05 11:42:25 +00:00
api: pass RpcEnvirnment to api handlers 2019-01-26 13:50:37 +00:00			`if let Some(total) = rpcenv.get_result_attrib("total").and_then(\|v\| v.as_u64()) {`
			`result["total"] = Value::from(total);`
			`}`
simplify formatter code 2018-12-05 17:22:56 +00:00
api: pass RpcEnvirnment to api handlers 2019-01-26 13:50:37 +00:00			`if let Some(changes) = rpcenv.get_result_attrib("changes") {`
			`result["changes"] = changes.clone();`
			`}`
simplify formatter code 2018-12-05 17:22:56 +00:00

src/server/formatter.rs: further cleanups and renaming ... 2019-05-09 11:28:26 +00:00			`json_data_response(result)`
api: pass RpcEnvirnment to api handlers 2019-01-26 13:50:37 +00:00			`}`
add output formatter 2018-12-05 11:42:25 +00:00
api: pass RpcEnvirnment to api handlers 2019-01-26 13:50:37 +00:00			`fn extjs_format_error(err: Error) -> Response<Body> {`
add output formatter 2018-12-05 11:42:25 +00:00
api: pass RpcEnvirnment to api handlers 2019-01-26 13:50:37 +00:00			`let mut errors = vec![];`
server/formatter.rs: fix extjs error format 2019-01-28 12:44:48 +00:00
			`let message = err.to_string();`
			`errors.push(&message);`
add output formatter 2018-12-05 11:42:25 +00:00
api: pass RpcEnvirnment to api handlers 2019-01-26 13:50:37 +00:00			`let result = json!({`
server/formatter.rs: fix extjs error format 2019-01-28 12:44:48 +00:00			`"message": message,`
api: pass RpcEnvirnment to api handlers 2019-01-26 13:50:37 +00:00			`"errors": errors,`
			`"success": false`
			`});`
add output formatter 2018-12-05 11:42:25 +00:00
src/server/formatter.rs: further cleanups and renaming ... 2019-05-09 11:28:26 +00:00			`let mut response = json_data_response(result);`
server/rest.rs: log full error messages 2019-02-15 08:55:12 +00:00
			`response.extensions_mut().insert(ErrorMessageExtension(message));`

			`response`
add output formatter 2018-12-05 11:42:25 +00:00			`}`

			`pub static EXTJS_FORMATTER: OutputFormatter = OutputFormatter {`
src/server/formatter.rs: rename format_result to format_data To avoid confusions with Rust Result type. 2019-05-09 11:15:15 +00:00			`format_data: extjs_format_data,`
api: pass RpcEnvirnment to api handlers 2019-01-26 13:50:37 +00:00			`format_error: extjs_format_error,`
add output formatter 2018-12-05 11:42:25 +00:00			`};`