proxmox-backup/src/api_schema/router.rs

use failure::*;

use crate::api_schema::*;
use serde_json::{Value};
use std::collections::HashMap;
use std::sync::Arc;
use std::fmt;

use hyper::{Body, Response, StatusCode};
use hyper::rt::Future;
use hyper::http::request::Parts;

use super::api_handler::*;

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

/// Abstract Interface for API methods to interact with the environment
pub trait RpcEnvironment {

    /// Use this to pass additional result data. It is up to the environment
    /// how the data is used.
    fn set_result_attrib(&mut self, name: &str, value: Value);

    /// Query additional result data.
    fn get_result_attrib(&self, name: &str) -> Option<&Value>;

    /// The environment type
    fn env_type(&self) -> RpcEnvironmentType;

    /// Set user name
    fn set_user(&mut self, user: Option<String>);

    /// Get user name
    fn get_user(&self) -> Option<String>;
}


/// Environment Type
///
/// We use this to enumerate the different environment types. Some methods
/// needs to do different things when started from the command line interface,
/// or when executed from a privileged server running as root.
#[derive(PartialEq, Copy, Clone)]
pub enum RpcEnvironmentType {
    /// Command started from command line
    CLI,
    /// Access from public accessible server
    PUBLIC,
    /// Access from privileged server (run as root)
    PRIVILEGED,
}

#[derive(Debug, Fail)]
pub struct HttpError {
    pub code: StatusCode,
    pub message: String,
}

impl HttpError {
    pub fn new(code: StatusCode, message: String) -> Self {
        HttpError { code, message }
    }
}

impl fmt::Display for HttpError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.message)
    }
}

macro_rules! http_err {
    ($status:ident, $msg:expr) => {{
        Error::from(HttpError::new(StatusCode::$status, $msg))
    }}
}

type ApiAsyncHandlerFn = Box<
    dyn Fn(Parts, Body, Value, &ApiAsyncMethod, &mut dyn RpcEnvironment) -> Result<BoxFut, Error>
    + Send + Sync + 'static
>;

/// This struct defines synchronous API call which returns the restulkt as json `Value`
pub struct ApiMethod {
    /// The protected flag indicates that the provides function should be forwarded
    /// to the deaemon running in priviledged mode.
    pub protected: bool,
    /// This flag indicates that the provided method may change the local timezone, so the server
    /// should do a tzset afterwards
    pub reload_timezone: bool,
    /// Parameter type Schema
    pub parameters: ObjectSchema,
    /// Return type Schema
    pub returns: Arc<Schema>,
    /// Handler function
    pub handler: Option<ApiHandlerFn>,
}

impl ApiMethod {

    pub fn new<F, Args, R, MetaArgs>(func: F, parameters: ObjectSchema) -> Self
    where
        F: WrapApiHandler<Args, R, MetaArgs>,
    {
        Self {
            parameters,
            handler: Some(func.wrap()),
            returns: Arc::new(Schema::Null),
            protected: false,
            reload_timezone: false,
        }
    }

    pub fn new_dummy(parameters: ObjectSchema) -> Self {
        Self {
            parameters,
            handler: None,
            returns: Arc::new(Schema::Null),
            protected: false,
            reload_timezone: false,
        }
    }

    pub fn returns<S: Into<Arc<Schema>>>(mut self, schema: S) -> Self {

        self.returns = schema.into();

        self
    }

    pub fn protected(mut self, protected: bool) -> Self {

        self.protected = protected;

        self
    }

    pub fn reload_timezone(mut self, reload_timezone: bool) -> Self {

        self.reload_timezone = reload_timezone;

        self
    }
}

pub struct ApiAsyncMethod {
    pub parameters: ObjectSchema,
    pub returns: Arc<Schema>,
    pub handler: ApiAsyncHandlerFn,
}

impl ApiAsyncMethod {

    pub fn new<F>(handler: F, parameters: ObjectSchema) -> Self
    where
        F: Fn(Parts, Body, Value, &ApiAsyncMethod, &mut dyn RpcEnvironment) -> Result<BoxFut, Error>
            + Send + Sync + 'static,
    {
        Self {
            parameters,
            handler: Box::new(handler),
            returns: Arc::new(Schema::Null),
        }
    }

    pub fn returns<S: Into<Arc<Schema>>>(mut self, schema: S) -> Self {

        self.returns = schema.into();

        self
    }
}

pub enum SubRoute {
    None,
    Hash(HashMap<String, Router>),
    MatchAll { router: Box<Router>, param_name: String },
}

pub enum MethodDefinition {
    None,
    Simple(ApiMethod),
    Async(ApiAsyncMethod),
}

pub struct Router {
    pub get: MethodDefinition,
    pub put: MethodDefinition,
    pub post: MethodDefinition,
    pub delete: MethodDefinition,
    pub subroute: SubRoute,
}

impl Router {

    pub fn new() -> Self {
        Self {
            get: MethodDefinition::None,
            put: MethodDefinition::None,
            post: MethodDefinition::None,
            delete: MethodDefinition::None,
            subroute: SubRoute::None
        }
    }

    pub fn subdir<S: Into<String>>(mut self, subdir: S, router: Router) -> Self {
        if let SubRoute::None = self.subroute {
            self.subroute = SubRoute::Hash(HashMap::new());
        }
        match self.subroute {
            SubRoute::Hash(ref mut map) => {
                map.insert(subdir.into(), router);
            }
            _ => panic!("unexpected subroute type"),
        }
        self
    }

    pub fn subdirs(mut self, map: HashMap<String, Router>) -> Self {
        self.subroute = SubRoute::Hash(map);
        self
    }

    pub fn match_all<S: Into<String>>(mut self, param_name: S, router: Router) -> Self {
        if let SubRoute::None = self.subroute {
            self.subroute = SubRoute::MatchAll { router: Box::new(router), param_name: param_name.into() };
        } else {
            panic!("unexpected subroute type");
        }
        self
    }

    pub fn get(mut self, m: ApiMethod) -> Self {
        self.get = MethodDefinition::Simple(m);
        self
    }

    pub fn put(mut self, m: ApiMethod) -> Self {
        self.put = MethodDefinition::Simple(m);
        self
    }

    pub fn post(mut self, m: ApiMethod) -> Self {
        self.post = MethodDefinition::Simple(m);
        self
    }

    pub fn upload(mut self, m: ApiAsyncMethod) -> Self {
        self.post = MethodDefinition::Async(m);
        self
    }

    pub fn download(mut self, m: ApiAsyncMethod) -> Self {
        self.get = MethodDefinition::Async(m);
        self
    }

    pub fn upgrade(mut self, m: ApiAsyncMethod) -> Self {
        self.get = MethodDefinition::Async(m);
        self
    }

    pub fn delete(mut self, m: ApiMethod) -> Self {
        self.delete = MethodDefinition::Simple(m);
        self
    }

    pub fn find_route(&self, components: &[&str], uri_param: &mut HashMap<String, String>) -> Option<&Router> {

        if components.len() == 0 { return Some(self); };

        let (dir, rest) = (components[0], &components[1..]);

        match self.subroute {
            SubRoute::None => {},
            SubRoute::Hash(ref dirmap) => {
                if let Some(ref router) = dirmap.get(dir) {
                    println!("FOUND SUBDIR {}", dir);
                    return router.find_route(rest, uri_param);
                }
            }
            SubRoute::MatchAll { ref router, ref param_name } => {
                println!("URI PARAM {} = {}", param_name, dir); // fixme: store somewhere
                uri_param.insert(param_name.clone(), dir.into());
                return router.find_route(rest, uri_param);
            },
        }

        None
    }
}
add missing file 2018-11-15 16:07:55 +00:00			`use failure::*;`

improve api_schema module structure 2019-02-17 09:16:33 +00:00			`use crate::api_schema::*;`
add missing file 2018-11-15 16:07:55 +00:00			`use serde_json::{Value};`
			`use std::collections::HashMap;`
more cleanups 2018-12-06 09:41:57 +00:00			`use std::sync::Arc;`
move http error class to router.rs 2019-01-31 12:22:30 +00:00			`use std::fmt;`
add missing file 2018-11-15 16:07:55 +00:00
move http error class to router.rs 2019-01-31 12:22:30 +00:00			`use hyper::{Body, Response, StatusCode};`
api/router.rs: allow different types of api methods Added a prototype for file/backup uploads. 2019-01-14 11:26:04 +00:00			`use hyper::rt::Future;`
api3/admin/datastore/upload_catar.rs: verify content type ("application/x-proxmox-backup-catar") 2019-01-17 11:43:29 +00:00			`use hyper::http::request::Parts;`
api/router.rs: allow different types of api methods Added a prototype for file/backup uploads. 2019-01-14 11:26:04 +00:00
api_schema: allow generic api handler functions Signed-off-by: Wolfgang Bumiller <w.bumiller@proxmox.com> 2019-04-16 08:36:04 +00:00			`use super::api_handler::*;`

api/router.rs: allow different types of api methods Added a prototype for file/backup uploads. 2019-01-14 11:26:04 +00:00			`pub type BoxFut = Box<Future<Item = Response<Body>, Error = failure::Error> + Send>;`

api_schema/router.rs: improve doc 2019-02-17 09:30:41 +00:00			`/// Abstract Interface for API methods to interact with the environment`
api: pass RpcEnvirnment to api handlers 2019-01-26 13:50:37 +00:00			`pub trait RpcEnvironment {`

api_schema/router.rs: improve doc 2019-02-17 09:30:41 +00:00			`/// Use this to pass additional result data. It is up to the environment`
			`/// how the data is used.`
api: pass RpcEnvirnment to api handlers 2019-01-26 13:50:37 +00:00			`fn set_result_attrib(&mut self, name: &str, value: Value);`

api_schema/router.rs: improve doc 2019-02-17 09:30:41 +00:00			`/// Query additional result data.`
api: pass RpcEnvirnment to api handlers 2019-01-26 13:50:37 +00:00			`fn get_result_attrib(&self, name: &str) -> Option<&Value>;`
RpcEnvironment: add environment type enum RpcEnvironmentType 2019-01-27 09:33:42 +00:00
api_schema/router.rs: improve doc 2019-02-17 09:30:41 +00:00			`/// The environment type`
RpcEnvironment: add environment type enum RpcEnvironmentType 2019-01-27 09:33:42 +00:00			`fn env_type(&self) -> RpcEnvironmentType;`
RpcEnvironment: implement set_user() and get_user() 2019-01-27 09:42:45 +00:00
api_schema/router.rs: improve doc 2019-02-17 09:30:41 +00:00			`/// Set user name`
RpcEnvironment: implement set_user() and get_user() 2019-01-27 09:42:45 +00:00			`fn set_user(&mut self, user: Option<String>);`

api_schema/router.rs: improve doc 2019-02-17 09:30:41 +00:00			`/// Get user name`
RpcEnvironment: implement set_user() and get_user() 2019-01-27 09:42:45 +00:00			`fn get_user(&self) -> Option<String>;`
RpcEnvironment: add environment type enum RpcEnvironmentType 2019-01-27 09:33:42 +00:00			`}`

src/api_schema/router.rs: add docu for RpcEnvironmentType 2019-02-17 10:59:18 +00:00
			`/// Environment Type`
			`///`
			`/// We use this to enumerate the different environment types. Some methods`
			`/// needs to do different things when started from the command line interface,`
			`/// or when executed from a privileged server running as root.`
server/rest.rs: add proxy_sync_api_request() dummy 2019-01-28 16:30:39 +00:00			`#[derive(PartialEq, Copy, Clone)]`
RpcEnvironment: add environment type enum RpcEnvironmentType 2019-01-27 09:33:42 +00:00			`pub enum RpcEnvironmentType {`
src/api_schema/router.rs: add docu for RpcEnvironmentType 2019-02-17 10:59:18 +00:00			`/// Command started from command line`
RpcEnvironment: add environment type enum RpcEnvironmentType 2019-01-27 09:33:42 +00:00			`CLI,`
src/api_schema/router.rs: add docu for RpcEnvironmentType 2019-02-17 10:59:18 +00:00			`/// Access from public accessible server`
RpcEnvironment: add environment type enum RpcEnvironmentType 2019-01-27 09:33:42 +00:00			`PUBLIC,`
src/api_schema/router.rs: add docu for RpcEnvironmentType 2019-02-17 10:59:18 +00:00			`/// Access from privileged server (run as root)`
			`PRIVILEGED,`
api: pass RpcEnvirnment to api handlers 2019-01-26 13:50:37 +00:00			`}`

move http error class to router.rs 2019-01-31 12:22:30 +00:00			`#[derive(Debug, Fail)]`
			`pub struct HttpError {`
			`pub code: StatusCode,`
			`pub message: String,`
			`}`

			`impl HttpError {`
			`pub fn new(code: StatusCode, message: String) -> Self {`
			`HttpError { code, message }`
			`}`
			`}`

			`impl fmt::Display for HttpError {`
			`fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
src/server/rest.rs: improve logs for unauthorized request 2019-02-17 16:18:44 +00:00			`write!(f, "{}", self.message)`
move http error class to router.rs 2019-01-31 12:22:30 +00:00			`}`
			`}`

			`macro_rules! http_err {`
			`($status:ident, $msg:expr) => {{`
			`Error::from(HttpError::new(StatusCode::$status, $msg))`
			`}}`
			`}`

api_schema: allow generic api handler functions Signed-off-by: Wolfgang Bumiller <w.bumiller@proxmox.com> 2019-04-16 08:36:04 +00:00			`type ApiAsyncHandlerFn = Box<`
			`dyn Fn(Parts, Body, Value, &ApiAsyncMethod, &mut dyn RpcEnvironment) -> Result<BoxFut, Error>`
			`+ Send + Sync + 'static`
			`>;`
api/router.rs: allow different types of api methods Added a prototype for file/backup uploads. 2019-01-14 11:26:04 +00:00
improve ApiMethod docu 2019-02-01 09:38:07 +00:00			/// This struct defines synchronous API call which returns the restulkt as json `Value`
add missing file 2018-11-15 16:07:55 +00:00			`pub struct ApiMethod {`
implement relead_timezone flag 2019-02-01 08:54:56 +00:00			`/// The protected flag indicates that the provides function should be forwarded`
			`/// to the deaemon running in priviledged mode.`
api/router.rs: add new 'protected' flag to ApiMethod 2019-01-28 16:18:42 +00:00			`pub protected: bool,`
implement relead_timezone flag 2019-02-01 08:54:56 +00:00			`/// This flag indicates that the provided method may change the local timezone, so the server`
			`/// should do a tzset afterwards`
			`pub reload_timezone: bool,`
improve ApiMethod docu 2019-02-01 09:38:07 +00:00			`/// Parameter type Schema`
use ObjectSchema for parameters Signed-off-by: Dietmar Maurer <dietmar@proxmox.com> 2018-11-18 07:46:26 +00:00			`pub parameters: ObjectSchema,`
improve ApiMethod docu 2019-02-01 09:38:07 +00:00			`/// Return type Schema`
more cleanups 2018-12-06 09:41:57 +00:00			`pub returns: Arc<Schema>,`
improve ApiMethod docu 2019-02-01 09:38:07 +00:00			`/// Handler function`
api_schema: allow generic api handler functions Signed-off-by: Wolfgang Bumiller <w.bumiller@proxmox.com> 2019-04-16 08:36:04 +00:00			`pub handler: Option<ApiHandlerFn>,`
code cleanup 2018-12-06 09:23:45 +00:00			`}`

			`impl ApiMethod {`

api_schema: allow generic api handler functions Signed-off-by: Wolfgang Bumiller <w.bumiller@proxmox.com> 2019-04-16 08:36:04 +00:00			`pub fn new<F, Args, R, MetaArgs>(func: F, parameters: ObjectSchema) -> Self`
			`where`
			`F: WrapApiHandler<Args, R, MetaArgs>,`
			`{`
			`Self {`
			`parameters,`
			`handler: Some(func.wrap()),`
			`returns: Arc::new(Schema::Null),`
			`protected: false,`
			`reload_timezone: false,`
			`}`
			`}`

			`pub fn new_dummy(parameters: ObjectSchema) -> Self {`
code cleanup 2018-12-06 09:23:45 +00:00			`Self {`
			`parameters,`
api_schema: allow generic api handler functions Signed-off-by: Wolfgang Bumiller <w.bumiller@proxmox.com> 2019-04-16 08:36:04 +00:00			`handler: None,`
more cleanups 2018-12-06 09:41:57 +00:00			`returns: Arc::new(Schema::Null),`
api/router.rs: add new 'protected' flag to ApiMethod 2019-01-28 16:18:42 +00:00			`protected: false,`
implement relead_timezone flag 2019-02-01 08:54:56 +00:00			`reload_timezone: false,`
code cleanup 2018-12-06 09:23:45 +00:00			`}`
			`}`

more cleanups 2018-12-06 09:41:57 +00:00			`pub fn returns<S: Into<Arc<Schema>>>(mut self, schema: S) -> Self {`

			`self.returns = schema.into();`

			`self`
			`}`
api/router.rs: add new 'protected' flag to ApiMethod 2019-01-28 16:18:42 +00:00
			`pub fn protected(mut self, protected: bool) -> Self {`

			`self.protected = protected;`

			`self`
			`}`
implement relead_timezone flag 2019-02-01 08:54:56 +00:00
			`pub fn reload_timezone(mut self, reload_timezone: bool) -> Self {`

			`self.reload_timezone = reload_timezone;`

			`self`
			`}`
api/router.rs: allow different types of api methods Added a prototype for file/backup uploads. 2019-01-14 11:26:04 +00:00			`}`

api/router.rs: rename ApiUploadMethod to ApiAsyncMethod We can use this for uploads and downloads ... 2019-01-19 15:42:43 +00:00			`pub struct ApiAsyncMethod {`
api/router.rs: allow different types of api methods Added a prototype for file/backup uploads. 2019-01-14 11:26:04 +00:00			`pub parameters: ObjectSchema,`
			`pub returns: Arc<Schema>,`
api/router.rs: rename ApiUploadMethod to ApiAsyncMethod We can use this for uploads and downloads ... 2019-01-19 15:42:43 +00:00			`pub handler: ApiAsyncHandlerFn,`
api/router.rs: allow different types of api methods Added a prototype for file/backup uploads. 2019-01-14 11:26:04 +00:00			`}`

api/router.rs: rename ApiUploadMethod to ApiAsyncMethod We can use this for uploads and downloads ... 2019-01-19 15:42:43 +00:00			`impl ApiAsyncMethod {`
api/router.rs: allow different types of api methods Added a prototype for file/backup uploads. 2019-01-14 11:26:04 +00:00
api_schema: allow generic api handler functions Signed-off-by: Wolfgang Bumiller <w.bumiller@proxmox.com> 2019-04-16 08:36:04 +00:00			`pub fn new<F>(handler: F, parameters: ObjectSchema) -> Self`
			`where`
			`F: Fn(Parts, Body, Value, &ApiAsyncMethod, &mut dyn RpcEnvironment) -> Result<BoxFut, Error>`
			`+ Send + Sync + 'static,`
			`{`
api/router.rs: allow different types of api methods Added a prototype for file/backup uploads. 2019-01-14 11:26:04 +00:00			`Self {`
			`parameters,`
api_schema: allow generic api handler functions Signed-off-by: Wolfgang Bumiller <w.bumiller@proxmox.com> 2019-04-16 08:36:04 +00:00			`handler: Box::new(handler),`
api/router.rs: allow different types of api methods Added a prototype for file/backup uploads. 2019-01-14 11:26:04 +00:00			`returns: Arc::new(Schema::Null),`
			`}`
			`}`

			`pub fn returns<S: Into<Arc<Schema>>>(mut self, schema: S) -> Self {`
more cleanups 2018-12-06 09:41:57 +00:00
api/router.rs: allow different types of api methods Added a prototype for file/backup uploads. 2019-01-14 11:26:04 +00:00			`self.returns = schema.into();`

			`self`
			`}`
add missing file 2018-11-15 16:07:55 +00:00			`}`

			`pub enum SubRoute {`
			`None,`
			`Hash(HashMap<String, Router>),`
			`MatchAll { router: Box<Router>, param_name: String },`
			`}`

api/router.rs: allow different types of api methods Added a prototype for file/backup uploads. 2019-01-14 11:26:04 +00:00			`pub enum MethodDefinition {`
			`None,`
			`Simple(ApiMethod),`
api/router.rs: rename ApiUploadMethod to ApiAsyncMethod We can use this for uploads and downloads ... 2019-01-19 15:42:43 +00:00			`Async(ApiAsyncMethod),`
api/router.rs: allow different types of api methods Added a prototype for file/backup uploads. 2019-01-14 11:26:04 +00:00			`}`

add missing file 2018-11-15 16:07:55 +00:00			`pub struct Router {`
api/router.rs: allow different types of api methods Added a prototype for file/backup uploads. 2019-01-14 11:26:04 +00:00			`pub get: MethodDefinition,`
			`pub put: MethodDefinition,`
			`pub post: MethodDefinition,`
			`pub delete: MethodDefinition,`
add missing file 2018-11-15 16:07:55 +00:00			`pub subroute: SubRoute,`
			`}`

			`impl Router {`

			`pub fn new() -> Self {`
			`Self {`
api/router.rs: allow different types of api methods Added a prototype for file/backup uploads. 2019-01-14 11:26:04 +00:00			`get: MethodDefinition::None,`
			`put: MethodDefinition::None,`
			`post: MethodDefinition::None,`
			`delete: MethodDefinition::None,`
add missing file 2018-11-15 16:07:55 +00:00			`subroute: SubRoute::None`
			`}`
			`}`

code cleanup 2018-12-06 09:23:45 +00:00			`pub fn subdir<S: Into<String>>(mut self, subdir: S, router: Router) -> Self {`
			`if let SubRoute::None = self.subroute {`
			`self.subroute = SubRoute::Hash(HashMap::new());`
			`}`
			`match self.subroute {`
			`SubRoute::Hash(ref mut map) => {`
			`map.insert(subdir.into(), router);`
			`}`
			`_ => panic!("unexpected subroute type"),`
			`}`
			`self`
			`}`

add missing file 2018-11-15 16:07:55 +00:00			`pub fn subdirs(mut self, map: HashMap<String, Router>) -> Self {`
			`self.subroute = SubRoute::Hash(map);`
			`self`
			`}`

code cleanup 2018-12-06 09:23:45 +00:00			`pub fn match_all<S: Into<String>>(mut self, param_name: S, router: Router) -> Self {`
			`if let SubRoute::None = self.subroute {`
			`self.subroute = SubRoute::MatchAll { router: Box::new(router), param_name: param_name.into() };`
			`} else {`
			`panic!("unexpected subroute type");`
			`}`
add missing file 2018-11-15 16:07:55 +00:00			`self`
			`}`

			`pub fn get(mut self, m: ApiMethod) -> Self {`
api/router.rs: allow different types of api methods Added a prototype for file/backup uploads. 2019-01-14 11:26:04 +00:00			`self.get = MethodDefinition::Simple(m);`
add missing file 2018-11-15 16:07:55 +00:00			`self`
			`}`
code cleanup 2018-12-06 09:23:45 +00:00
Router: implement missing builder methods 2018-11-16 07:24:10 +00:00			`pub fn put(mut self, m: ApiMethod) -> Self {`
api/router.rs: allow different types of api methods Added a prototype for file/backup uploads. 2019-01-14 11:26:04 +00:00			`self.put = MethodDefinition::Simple(m);`
Router: implement missing builder methods 2018-11-16 07:24:10 +00:00			`self`
			`}`
code cleanup 2018-12-06 09:23:45 +00:00
Router: implement missing builder methods 2018-11-16 07:24:10 +00:00			`pub fn post(mut self, m: ApiMethod) -> Self {`
api/router.rs: allow different types of api methods Added a prototype for file/backup uploads. 2019-01-14 11:26:04 +00:00			`self.post = MethodDefinition::Simple(m);`
			`self`
			`}`

api/router.rs: rename ApiUploadMethod to ApiAsyncMethod We can use this for uploads and downloads ... 2019-01-19 15:42:43 +00:00			`pub fn upload(mut self, m: ApiAsyncMethod) -> Self {`
			`self.post = MethodDefinition::Async(m);`
Router: implement missing builder methods 2018-11-16 07:24:10 +00:00			`self`
			`}`
code cleanup 2018-12-06 09:23:45 +00:00
api/router.rs: rename ApiUploadMethod to ApiAsyncMethod We can use this for uploads and downloads ... 2019-01-19 15:42:43 +00:00			`pub fn download(mut self, m: ApiAsyncMethod) -> Self {`
			`self.get = MethodDefinition::Async(m);`
			`self`
			`}`

router: add upgrade method This is just an Async GET method, but semantically different, so it gets its own router method. Signed-off-by: Wolfgang Bumiller <w.bumiller@proxmox.com> 2019-03-06 09:18:06 +00:00			`pub fn upgrade(mut self, m: ApiAsyncMethod) -> Self {`
			`self.get = MethodDefinition::Async(m);`
			`self`
			`}`
api/router.rs: rename ApiUploadMethod to ApiAsyncMethod We can use this for uploads and downloads ... 2019-01-19 15:42:43 +00:00
Router: implement missing builder methods 2018-11-16 07:24:10 +00:00			`pub fn delete(mut self, m: ApiMethod) -> Self {`
api/router.rs: allow different types of api methods Added a prototype for file/backup uploads. 2019-01-14 11:26:04 +00:00			`self.delete = MethodDefinition::Simple(m);`
Router: implement missing builder methods 2018-11-16 07:24:10 +00:00			`self`
			`}`
add missing file 2018-11-15 16:07:55 +00:00
handle uri parameters correctly 2018-11-16 08:15:33 +00:00			`pub fn find_route(&self, components: &[&str], uri_param: &mut HashMap<String, String>) -> Option<&Router> {`
add missing file 2018-11-15 16:07:55 +00:00
			`if components.len() == 0 { return Some(self); };`

			`let (dir, rest) = (components[0], &components[1..]);`

			`match self.subroute {`
			`SubRoute::None => {},`
			`SubRoute::Hash(ref dirmap) => {`
			`if let Some(ref router) = dirmap.get(dir) {`
			`println!("FOUND SUBDIR {}", dir);`
handle uri parameters correctly 2018-11-16 08:15:33 +00:00			`return router.find_route(rest, uri_param);`
add missing file 2018-11-15 16:07:55 +00:00			`}`
			`}`
			`SubRoute::MatchAll { ref router, ref param_name } => {`
			`println!("URI PARAM {} = {}", param_name, dir); // fixme: store somewhere`
handle uri parameters correctly 2018-11-16 08:15:33 +00:00			`uri_param.insert(param_name.clone(), dir.into());`
			`return router.find_route(rest, uri_param);`
add missing file 2018-11-15 16:07:55 +00:00			`},`
			`}`

			`None`
			`}`
			`}`