proxmox-backup/proxmox-rest-server/src/formatter.rs

//! Helpers to format response data
use std::collections::HashMap;

use anyhow::Error;
use serde_json::{json, Value};

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

use proxmox_router::{HttpError, RpcEnvironment, SerializableReturn};
use proxmox_schema::ParameterError;

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

/// Methods to format data and errors
pub trait OutputFormatter: Send + Sync {
    /// Transform json data into a http response
    fn format_data(&self, data: Value, rpcenv: &dyn RpcEnvironment) -> Response<Body>;

    /// Transform serializable data into a streaming http response
    fn format_data_streaming(
        &self,
        data: Box<dyn SerializableReturn + Send>,
        rpcenv: &dyn RpcEnvironment,
    ) -> Result<Response<Body>, Error>;

    /// Transform errors into a http response
    fn format_error(&self, err: Error) -> Response<Body>;

    /// Transform a [Result] into a http response
    fn format_result(
        &self,
        result: Result<Value, Error>,
        rpcenv: &dyn RpcEnvironment,
    ) -> Response<Body> {
        match result {
            Ok(data) => self.format_data(data, rpcenv),
            Err(err) => self.format_error(err),
        }
    }
}

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

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_data_response_streaming(body: Body) -> Result<Response<Body>, Error> {
    let response = Response::builder()
        .header(
            header::CONTENT_TYPE,
            header::HeaderValue::from_static(JSON_CONTENT_TYPE),
        )
        .body(body)?;
    Ok(response)
}

fn add_result_attributes(result: &mut Value, rpcenv: &dyn RpcEnvironment) {
    let attributes = match rpcenv.result_attrib().as_object() {
        Some(attr) => attr,
        None => return,
    };

    for (key, value) in attributes {
        result[key] = value.clone();
    }
}

fn start_data_streaming(
    value: Value,
    data: Box<dyn SerializableReturn + Send>,
) -> tokio::sync::mpsc::Receiver<Result<Vec<u8>, Error>> {
    let (writer, reader) = tokio::sync::mpsc::channel(1);

    tokio::task::spawn_blocking(move || {
        let output = proxmox_async::blocking::SenderWriter::from_sender(writer);
        let mut output = std::io::BufWriter::new(output);
        let mut serializer = serde_json::Serializer::new(&mut output);
        let _ = data.sender_serialize(&mut serializer, value);
    });

    reader
}

struct JsonFormatter();

/// Format data as ``application/json``
///
/// The returned json object contains the following properties:
///
/// * ``data``: The result data (on success)
///
/// Any result attributes set on ``rpcenv`` are also added to the object.
///
/// Errors generates a BAD_REQUEST containing the error
/// message as string.
pub static JSON_FORMATTER: &'static dyn OutputFormatter = &JsonFormatter();

impl OutputFormatter for JsonFormatter {
    fn format_data(&self, data: Value, rpcenv: &dyn RpcEnvironment) -> Response<Body> {
        let mut result = json!({ "data": data });

        add_result_attributes(&mut result, rpcenv);

        json_data_response(result)
    }

    fn format_data_streaming(
        &self,
        data: Box<dyn SerializableReturn + Send>,
        rpcenv: &dyn RpcEnvironment,
    ) -> Result<Response<Body>, Error> {
        let mut value = json!({});

        add_result_attributes(&mut value, rpcenv);

        let reader = start_data_streaming(value, data);
        let stream = tokio_stream::wrappers::ReceiverStream::new(reader);

        json_data_response_streaming(Body::wrap_stream(stream))
    }

    fn format_error(&self, 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
    }
}

/// Format data as ExtJS compatible ``application/json``
///
/// The returned json object contains the following properties:
///
/// * ``success``: boolean attribute indicating the success.
///
/// * ``data``: The result data (on success)
///
/// * ``message``: The error message (on failure)
///
/// * ``errors``: detailed list of errors (if available)
///
/// Any result attributes set on ``rpcenv`` are also added to the object.
///
/// Please note that errors return status code OK, but setting success
/// to false.
pub static EXTJS_FORMATTER: &'static dyn OutputFormatter = &ExtJsFormatter();

struct ExtJsFormatter();

impl OutputFormatter for ExtJsFormatter {
    fn format_data(&self, data: Value, rpcenv: &dyn RpcEnvironment) -> Response<Body> {
        let mut result = json!({
            "data": data,
            "success": true
        });

        add_result_attributes(&mut result, rpcenv);

        json_data_response(result)
    }

    fn format_data_streaming(
        &self,
        data: Box<dyn SerializableReturn + Send>,
        rpcenv: &dyn RpcEnvironment,
    ) -> Result<Response<Body>, Error> {
        let mut value = json!({
            "success": true,
        });

        add_result_attributes(&mut value, rpcenv);

        let reader = start_data_streaming(value, data);
        let stream = tokio_stream::wrappers::ReceiverStream::new(reader);

        json_data_response_streaming(Body::wrap_stream(stream))
    }

    fn format_error(&self, err: Error) -> Response<Body> {
        let mut errors = HashMap::new();

        let message: String = match err.downcast::<ParameterError>() {
            Ok(param_err) => {
                for (name, err) in param_err {
                    errors.insert(name, err.to_string());
                }
                String::from("parameter verification errors")
            }
            Err(err) => err.to_string(),
        };

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

        let mut response = json_data_response(result);

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

        response
    }
}
proxmox-rest-server: cleanup formatter, improve docs Use trait for OutputFormatter. This is functionally equivalent, but more rust-like... 2021-09-27 10:59:06 +00:00			`//! Helpers to format response data`
rest-server: use hashmap for parameter errors our ui expects a map here with 'field: "error"'. This way it can mark the relevant field as invalid and correctly shows the complete error message Signed-off-by: Dominik Csapak <d.csapak@proxmox.com> 2021-10-19 11:09:27 +00:00			`use std::collections::HashMap;`
proxmox-rest-server: cleanup formatter, improve docs Use trait for OutputFormatter. This is functionally equivalent, but more rust-like... 2021-09-27 10:59:06 +00:00
rest server: rust fmt Signed-off-by: Thomas Lamprecht <t.lamprecht@proxmox.com> 2022-04-06 14:55:39 +00:00			`use anyhow::Error;`
add output formatter 2018-12-05 11:42:25 +00:00			`use serde_json::{json, Value};`

simplify formatter code 2018-12-05 17:22:56 +00:00			`use hyper::header;`
rest server: rust fmt Signed-off-by: Thomas Lamprecht <t.lamprecht@proxmox.com> 2022-04-06 14:55:39 +00:00			`use hyper::{Body, Response, StatusCode};`
simplify formatter code 2018-12-05 17:22:56 +00:00
proxmox-rest-server: OutputFormatter: add new format_data_streaming method that takes the data in form of a `Box<dyn SerializableReturn + Send>` instead of a Value. Implement it in json and extjs formatter, by starting a thread and stream the serialized data via a `BufWriter<SenderWriter>` and use the Receiver side as a stream for the response body. Signed-off-by: Dominik Csapak <d.csapak@proxmox.com> Signed-off-by: Wolfgang Bumiller <w.bumiller@proxmox.com> 2022-04-12 14:15:08 +00:00			`use proxmox_router::{HttpError, RpcEnvironment, SerializableReturn};`
update to first proxmox crate split Signed-off-by: Wolfgang Bumiller <w.bumiller@proxmox.com> 2021-10-08 09:19:37 +00:00			`use proxmox_schema::ParameterError;`
api/compat: drop more compat imports from api_schema.rs Signed-off-by: Wolfgang Bumiller <w.bumiller@proxmox.com> 2019-11-21 13:36:28 +00:00
server/rest.rs: log full error messages 2019-02-15 08:55:12 +00:00			`/// Extension to set error message for server side logging`
proxmox-rest-server: cleanup formatter, improve docs Use trait for OutputFormatter. This is functionally equivalent, but more rust-like... 2021-09-27 10:59:06 +00:00			`pub(crate) struct ErrorMessageExtension(pub String);`

			`/// Methods to format data and errors`
			`pub trait OutputFormatter: Send + Sync {`
			`/// Transform json data into a http response`
			`fn format_data(&self, data: Value, rpcenv: &dyn RpcEnvironment) -> Response<Body>;`

proxmox-rest-server: OutputFormatter: add new format_data_streaming method that takes the data in form of a `Box<dyn SerializableReturn + Send>` instead of a Value. Implement it in json and extjs formatter, by starting a thread and stream the serialized data via a `BufWriter<SenderWriter>` and use the Receiver side as a stream for the response body. Signed-off-by: Dominik Csapak <d.csapak@proxmox.com> Signed-off-by: Wolfgang Bumiller <w.bumiller@proxmox.com> 2022-04-12 14:15:08 +00:00			`/// Transform serializable data into a streaming http response`
			`fn format_data_streaming(`
			`&self,`
			`data: Box<dyn SerializableReturn + Send>,`
			`rpcenv: &dyn RpcEnvironment,`
			`) -> Result<Response<Body>, Error>;`

proxmox-rest-server: cleanup formatter, improve docs Use trait for OutputFormatter. This is functionally equivalent, but more rust-like... 2021-09-27 10:59:06 +00:00			`/// Transform errors into a http response`
			`fn format_error(&self, err: Error) -> Response<Body>;`

			`/// Transform a [Result] into a http response`
rest server: rust fmt Signed-off-by: Thomas Lamprecht <t.lamprecht@proxmox.com> 2022-04-06 14:55:39 +00:00			`fn format_result(`
			`&self,`
			`result: Result<Value, Error>,`
			`rpcenv: &dyn RpcEnvironment,`
			`) -> Response<Body> {`
proxmox-rest-server: cleanup formatter, improve docs Use trait for OutputFormatter. This is functionally equivalent, but more rust-like... 2021-09-27 10:59:06 +00:00			`match result {`
			`Ok(data) => self.format_data(data, rpcenv),`
			`Err(err) => self.format_error(err),`
			`}`
			`}`
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
proxmox-rest-server: cleanup formatter, improve docs Use trait for OutputFormatter. This is functionally equivalent, but more rust-like... 2021-09-27 10:59:06 +00:00			`fn json_data_response(data: Value) -> Response<Body> {`
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,`
rest server: rust fmt Signed-off-by: Thomas Lamprecht <t.lamprecht@proxmox.com> 2022-04-06 14:55:39 +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
proxmox-rest-server: OutputFormatter: add new format_data_streaming method that takes the data in form of a `Box<dyn SerializableReturn + Send>` instead of a Value. Implement it in json and extjs formatter, by starting a thread and stream the serialized data via a `BufWriter<SenderWriter>` and use the Receiver side as a stream for the response body. Signed-off-by: Dominik Csapak <d.csapak@proxmox.com> Signed-off-by: Wolfgang Bumiller <w.bumiller@proxmox.com> 2022-04-12 14:15:08 +00:00			`fn json_data_response_streaming(body: Body) -> Result<Response<Body>, Error> {`
			`let response = Response::builder()`
			`.header(`
			`header::CONTENT_TYPE,`
			`header::HeaderValue::from_static(JSON_CONTENT_TYPE),`
			`)`
			`.body(body)?;`
			`Ok(response)`
			`}`

rest server: rust fmt Signed-off-by: Thomas Lamprecht <t.lamprecht@proxmox.com> 2022-04-06 14:55:39 +00:00			`fn add_result_attributes(result: &mut Value, rpcenv: &dyn RpcEnvironment) {`
depend on proxmox 0.1.31 - use Value to store result metadata 2020-05-18 07:57:35 +00:00			`let attributes = match rpcenv.result_attrib().as_object() {`
			`Some(attr) => attr,`
			`None => return,`
			`};`
src/server/formatter.rs: impl. new result attribute "active" 2019-12-07 14:29:42 +00:00
depend on proxmox 0.1.31 - use Value to store result metadata 2020-05-18 07:57:35 +00:00			`for (key, value) in attributes {`
			`result[key] = value.clone();`
simplify formatter code 2018-12-05 17:22:56 +00:00			`}`
src/server/formatter.rs: impl. new result attribute "active" 2019-12-07 14:29:42 +00:00			`}`

proxmox-rest-server: OutputFormatter: add new format_data_streaming method that takes the data in form of a `Box<dyn SerializableReturn + Send>` instead of a Value. Implement it in json and extjs formatter, by starting a thread and stream the serialized data via a `BufWriter<SenderWriter>` and use the Receiver side as a stream for the response body. Signed-off-by: Dominik Csapak <d.csapak@proxmox.com> Signed-off-by: Wolfgang Bumiller <w.bumiller@proxmox.com> 2022-04-12 14:15:08 +00:00			`fn start_data_streaming(`
			`value: Value,`
			`data: Box<dyn SerializableReturn + Send>,`
			`) -> tokio::sync::mpsc::Receiver<Result<Vec<u8>, Error>> {`
			`let (writer, reader) = tokio::sync::mpsc::channel(1);`

			`tokio::task::spawn_blocking(move \|\| {`
			`let output = proxmox_async::blocking::SenderWriter::from_sender(writer);`
			`let mut output = std::io::BufWriter::new(output);`
			`let mut serializer = serde_json::Serializer::new(&mut output);`
			`let _ = data.sender_serialize(&mut serializer, value);`
			`});`

			`reader`
			`}`

proxmox-rest-server: cleanup formatter, improve docs Use trait for OutputFormatter. This is functionally equivalent, but more rust-like... 2021-09-27 10:59:06 +00:00			`struct JsonFormatter();`
src/server/formatter.rs: impl. new result attribute "active" 2019-12-07 14:29:42 +00:00
proxmox-rest-server: cleanup formatter, improve docs Use trait for OutputFormatter. This is functionally equivalent, but more rust-like... 2021-09-27 10:59:06 +00:00			/// Format data as ``application/json``
			`///`
ExtJsFormatter: use ParameterError to correctly compute 'errors' By default, 'errors' is now empty. Depend on proxmox 0.13.5. 2021-09-28 08:11:56 +00:00			`/// The returned json object contains the following properties:`
			`///`
			/// * ``data``: The result data (on success)
			`///`
			/// Any result attributes set on ``rpcenv`` are also added to the object.
			`///`
proxmox-rest-server: cleanup formatter, improve docs Use trait for OutputFormatter. This is functionally equivalent, but more rust-like... 2021-09-27 10:59:06 +00:00			`/// Errors generates a BAD_REQUEST containing the error`
			`/// message as string.`
			`pub static JSON_FORMATTER: &'static dyn OutputFormatter = &JsonFormatter();`
api: pass RpcEnvirnment to api handlers 2019-01-26 13:50:37 +00:00
rest server: rust fmt Signed-off-by: Thomas Lamprecht <t.lamprecht@proxmox.com> 2022-04-06 14:55:39 +00:00			`impl OutputFormatter for JsonFormatter {`
proxmox-rest-server: cleanup formatter, improve docs Use trait for OutputFormatter. This is functionally equivalent, but more rust-like... 2021-09-27 10:59:06 +00:00			`fn format_data(&self, data: Value, rpcenv: &dyn RpcEnvironment) -> Response<Body> {`
rest server: rust fmt Signed-off-by: Thomas Lamprecht <t.lamprecht@proxmox.com> 2022-04-06 14:55:39 +00:00			`let mut result = json!({ "data": data });`
src/server/rest.rs: improve logs for unauthorized request 2019-02-17 16:18:44 +00:00
proxmox-rest-server: cleanup formatter, improve docs Use trait for OutputFormatter. This is functionally equivalent, but more rust-like... 2021-09-27 10:59:06 +00:00			`add_result_attributes(&mut result, rpcenv);`
server/rest.rs: log full error messages 2019-02-15 08:55:12 +00:00
proxmox-rest-server: cleanup formatter, improve docs Use trait for OutputFormatter. This is functionally equivalent, but more rust-like... 2021-09-27 10:59:06 +00:00			`json_data_response(result)`
			`}`
add output formatter 2018-12-05 11:42:25 +00:00
proxmox-rest-server: OutputFormatter: add new format_data_streaming method that takes the data in form of a `Box<dyn SerializableReturn + Send>` instead of a Value. Implement it in json and extjs formatter, by starting a thread and stream the serialized data via a `BufWriter<SenderWriter>` and use the Receiver side as a stream for the response body. Signed-off-by: Dominik Csapak <d.csapak@proxmox.com> Signed-off-by: Wolfgang Bumiller <w.bumiller@proxmox.com> 2022-04-12 14:15:08 +00:00			`fn format_data_streaming(`
			`&self,`
			`data: Box<dyn SerializableReturn + Send>,`
			`rpcenv: &dyn RpcEnvironment,`
			`) -> Result<Response<Body>, Error> {`
			`let mut value = json!({});`

			`add_result_attributes(&mut value, rpcenv);`

			`let reader = start_data_streaming(value, data);`
			`let stream = tokio_stream::wrappers::ReceiverStream::new(reader);`

			`json_data_response_streaming(Body::wrap_stream(stream))`
			`}`

proxmox-rest-server: cleanup formatter, improve docs Use trait for OutputFormatter. This is functionally equivalent, but more rust-like... 2021-09-27 10:59:06 +00:00			`fn format_error(&self, 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`
			`};`
add output formatter 2018-12-05 11:42:25 +00:00
proxmox-rest-server: cleanup formatter, improve docs Use trait for OutputFormatter. This is functionally equivalent, but more rust-like... 2021-09-27 10:59:06 +00:00			`response.headers_mut().insert(`
			`header::CONTENT_TYPE,`
rest server: rust fmt Signed-off-by: Thomas Lamprecht <t.lamprecht@proxmox.com> 2022-04-06 14:55:39 +00:00			`header::HeaderValue::from_static(JSON_CONTENT_TYPE),`
			`);`
add output formatter 2018-12-05 11:42:25 +00:00
rest server: rust fmt Signed-off-by: Thomas Lamprecht <t.lamprecht@proxmox.com> 2022-04-06 14:55:39 +00:00			`response`
			`.extensions_mut()`
			`.insert(ErrorMessageExtension(err.to_string()));`
simplify formatter code 2018-12-05 17:22:56 +00:00
proxmox-rest-server: cleanup formatter, improve docs Use trait for OutputFormatter. This is functionally equivalent, but more rust-like... 2021-09-27 10:59:06 +00:00			`response`
			`}`
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
proxmox-rest-server: cleanup formatter, improve docs Use trait for OutputFormatter. This is functionally equivalent, but more rust-like... 2021-09-27 10:59:06 +00:00			/// Format data as ExtJS compatible ``application/json``
			`///`
			`/// The returned json object contains the following properties:`
			`///`
			/// * ``success``: boolean attribute indicating the success.
			`///`
			/// * ``data``: The result data (on success)
			`///`
			/// * ``message``: The error message (on failure)
			`///`
			/// * ``errors``: detailed list of errors (if available)
			`///`
			/// Any result attributes set on ``rpcenv`` are also added to the object.
			`///`
			`/// Please note that errors return status code OK, but setting success`
			`/// to false.`
			`pub static EXTJS_FORMATTER: &'static dyn OutputFormatter = &ExtJsFormatter();`

			`struct ExtJsFormatter();`

rest server: rust fmt Signed-off-by: Thomas Lamprecht <t.lamprecht@proxmox.com> 2022-04-06 14:55:39 +00:00			`impl OutputFormatter for ExtJsFormatter {`
proxmox-rest-server: cleanup formatter, improve docs Use trait for OutputFormatter. This is functionally equivalent, but more rust-like... 2021-09-27 10:59:06 +00:00			`fn format_data(&self, data: Value, rpcenv: &dyn RpcEnvironment) -> Response<Body> {`
			`let mut result = json!({`
			`"data": data,`
			`"success": true`
			`});`

			`add_result_attributes(&mut result, rpcenv);`

			`json_data_response(result)`
			`}`
add output formatter 2018-12-05 11:42:25 +00:00
proxmox-rest-server: OutputFormatter: add new format_data_streaming method that takes the data in form of a `Box<dyn SerializableReturn + Send>` instead of a Value. Implement it in json and extjs formatter, by starting a thread and stream the serialized data via a `BufWriter<SenderWriter>` and use the Receiver side as a stream for the response body. Signed-off-by: Dominik Csapak <d.csapak@proxmox.com> Signed-off-by: Wolfgang Bumiller <w.bumiller@proxmox.com> 2022-04-12 14:15:08 +00:00			`fn format_data_streaming(`
			`&self,`
			`data: Box<dyn SerializableReturn + Send>,`
			`rpcenv: &dyn RpcEnvironment,`
			`) -> Result<Response<Body>, Error> {`
			`let mut value = json!({`
			`"success": true,`
			`});`

			`add_result_attributes(&mut value, rpcenv);`

			`let reader = start_data_streaming(value, data);`
			`let stream = tokio_stream::wrappers::ReceiverStream::new(reader);`

			`json_data_response_streaming(Body::wrap_stream(stream))`
			`}`

proxmox-rest-server: cleanup formatter, improve docs Use trait for OutputFormatter. This is functionally equivalent, but more rust-like... 2021-09-27 10:59:06 +00:00			`fn format_error(&self, err: Error) -> Response<Body> {`
rest-server: use hashmap for parameter errors our ui expects a map here with 'field: "error"'. This way it can mark the relevant field as invalid and correctly shows the complete error message Signed-off-by: Dominik Csapak <d.csapak@proxmox.com> 2021-10-19 11:09:27 +00:00			`let mut errors = HashMap::new();`
add output formatter 2018-12-05 11:42:25 +00:00
tree wide: some stylistic clippy fixes Signed-off-by: Thomas Lamprecht <t.lamprecht@proxmox.com> 2022-04-10 16:33:32 +00:00			`let message: String = match err.downcast::<ParameterError>() {`
rest-server: bump schema to 1.2 and use convenience methods Signed-off-by: Wolfgang Bumiller <w.bumiller@proxmox.com> 2022-02-11 13:09:45 +00:00			`Ok(param_err) => {`
			`for (name, err) in param_err {`
			`errors.insert(name, err.to_string());`
			`}`
tree wide: some stylistic clippy fixes Signed-off-by: Thomas Lamprecht <t.lamprecht@proxmox.com> 2022-04-10 16:33:32 +00:00			`String::from("parameter verification errors")`
rest-server: use hashmap for parameter errors our ui expects a map here with 'field: "error"'. This way it can mark the relevant field as invalid and correctly shows the complete error message Signed-off-by: Dominik Csapak <d.csapak@proxmox.com> 2021-10-19 11:09:27 +00:00			`}`
tree wide: some stylistic clippy fixes Signed-off-by: Thomas Lamprecht <t.lamprecht@proxmox.com> 2022-04-10 16:33:32 +00:00			`Err(err) => err.to_string(),`
			`};`
add output formatter 2018-12-05 11:42:25 +00:00
proxmox-rest-server: cleanup formatter, improve docs Use trait for OutputFormatter. This is functionally equivalent, but more rust-like... 2021-09-27 10:59:06 +00:00			`let result = json!({`
			`"message": message,`
			`"errors": errors,`
			`"success": false`
			`});`
server/rest.rs: log full error messages 2019-02-15 08:55:12 +00:00
proxmox-rest-server: cleanup formatter, improve docs Use trait for OutputFormatter. This is functionally equivalent, but more rust-like... 2021-09-27 10:59:06 +00:00			`let mut response = json_data_response(result);`
server/rest.rs: log full error messages 2019-02-15 08:55:12 +00:00
rest server: rust fmt Signed-off-by: Thomas Lamprecht <t.lamprecht@proxmox.com> 2022-04-06 14:55:39 +00:00			`response`
			`.extensions_mut()`
			`.insert(ErrorMessageExtension(message));`
add output formatter 2018-12-05 11:42:25 +00:00
proxmox-rest-server: cleanup formatter, improve docs Use trait for OutputFormatter. This is functionally equivalent, but more rust-like... 2021-09-27 10:59:06 +00:00			`response`
			`}`
			`}`