src/api2/backup/service.rs

   1 use failure::*;
   2 use lazy_static::lazy_static;
   3
   4 use std::collections::HashMap;
   5 use std::sync::Arc;
   6
   7 use futures::*;
   8 use hyper::{Body, Request, Response, StatusCode};
   9
  10 use crate::tools;
  11 use crate::api_schema::router::*;
  12 use crate::server::formatter::*;
  13 use crate::server::WorkerTask;
  14
  15 use super::environment::*;
  16
  17 lazy_static!{
  18     static ref BACKUP_ROUTER: Router = super::backup_api();
  19 }
  20
  21 pub struct BackupService {
  22     rpcenv: BackupEnvironment,
  23     worker: Arc<WorkerTask>,
  24     debug: bool,
  25 }
  26
  27 impl BackupService {
  28
  29     pub fn new(rpcenv: BackupEnvironment, worker: Arc<WorkerTask>, debug: bool) -> Self {
  30         Self { rpcenv, worker, debug }
  31     }
  32
  33     pub fn debug<S: AsRef<str>>(&self, msg: S) {
  34         if self.debug { self.worker.log(msg); }
  35     }
  36
  37     fn handle_request(&self, req: Request<Body>) -> BoxFut {
  38
  39         let (parts, body) = req.into_parts();
  40
  41         let method = parts.method.clone();
  42
  43         let (path, components) = match tools::normalize_uri_path(parts.uri.path()) {
  44             Ok((p,c)) => (p, c),
  45             Err(err) => return Box::new(future::err(http_err!(BAD_REQUEST, err.to_string()))),
  46         };
  47
  48         self.debug(format!("{} {}", method, path));
  49
  50         let mut uri_param = HashMap::new();
  51
  52         match BACKUP_ROUTER.find_method(&components, method, &mut uri_param) {
  53             MethodDefinition::None => {
  54                 let err = http_err!(NOT_FOUND, "Path not found.".to_string());
  55                 return Box::new(future::ok((self.rpcenv.formatter.format_error)(err)));
  56             }
  57             MethodDefinition::Simple(api_method) => {
  58                 return crate::server::rest::handle_sync_api_request(
  59                     self.rpcenv.clone(), api_method, self.rpcenv.formatter, parts, body, uri_param);
  60             }
  61             MethodDefinition::Async(async_method) => {
  62                 return crate::server::rest::handle_async_api_request(
  63                     self.rpcenv.clone(), async_method, self.rpcenv.formatter, parts, body, uri_param);
  64             }
  65         }
  66     }
  67
  68     fn log_response(worker: Arc<WorkerTask>, method: hyper::Method, path: &str, resp: &Response<Body>) {
  69
  70         let status = resp.status();
  71
  72         if !status.is_success() {
  73             let reason = status.canonical_reason().unwrap_or("unknown reason");
  74
  75             let mut message = "request failed";
  76             if let Some(data) = resp.extensions().get::<ErrorMessageExtension>() {
  77                 message = &data.0;
  78             }
  79
  80             worker.log(format!("{} {}: {} {}: {}", method.as_str(), path, status.as_str(), reason, message));
  81         }
  82     }
  83 }
  84
  85 impl hyper::service::Service for BackupService {
  86     type ReqBody = Body;
  87     type ResBody = Body;
  88     type Error = Error;
  89     type Future = Box<dyn Future<Item = Response<Body>, Error = Self::Error> + Send>;
  90
  91     fn call(&mut self, req: Request<Self::ReqBody>) -> Self::Future {
  92         let path = req.uri().path().to_owned();
  93         let method = req.method().clone();
  94         let worker = self.worker.clone();
  95
  96         Box::new(self.handle_request(req).then(move |result| {
  97             match result {
  98                 Ok(res) => {
  99                     Self::log_response(worker, method, &path, &res);
 100                     Ok::<_, Error>(res)
 101                 }
 102                 Err(err) => {
 103                      if let Some(apierr) = err.downcast_ref::<HttpError>() {
 104                         let mut resp = Response::new(Body::from(apierr.message.clone()));
 105                         resp.extensions_mut().insert(ErrorMessageExtension(apierr.message.clone()));
 106                         *resp.status_mut() = apierr.code;
 107                         Self::log_response(worker, method, &path, &resp);
 108                         Ok(resp)
 109                     } else {
 110                         let mut resp = Response::new(Body::from(err.to_string()));
 111                         resp.extensions_mut().insert(ErrorMessageExtension(err.to_string()));
 112                         *resp.status_mut() = StatusCode::BAD_REQUEST;
 113                         Self::log_response(worker, method, &path, &resp);
 114                         Ok(resp)
 115                     }
 116                 }
 117             }
 118         }))
 119     }
 120 }