diff --git a/src/api2/admin/datastore/backup.rs b/src/api2/admin/datastore/backup.rs index 8965b7c7..e2339571 100644 --- a/src/api2/admin/datastore/backup.rs +++ b/src/api2/admin/datastore/backup.rs @@ -1,12 +1,10 @@ use failure::*; -use lazy_static::lazy_static; -use std::collections::HashMap; use std::sync::Arc; use futures::*; use hyper::header::{HeaderValue, UPGRADE}; -use hyper::{Body, Request, Response, StatusCode}; +use hyper::{Body, Response, StatusCode}; use hyper::http::request::Parts; use chrono::{Local, TimeZone}; @@ -15,12 +13,14 @@ use serde_json::Value; use crate::tools; use crate::api_schema::router::*; use crate::api_schema::*; -use crate::server::formatter::*; use crate::server::WorkerTask; mod environment; use environment::*; +mod service; +use service::*; + pub fn api_method_upgrade_backup() -> ApiAsyncMethod { ApiAsyncMethod::new( upgrade_to_backup_protocol, @@ -32,109 +32,6 @@ pub fn api_method_upgrade_backup() -> ApiAsyncMethod { ) } -static PROXMOX_BACKUP_PROTOCOL_ID: &str = "proxmox-backup-protocol-h2"; - - -lazy_static!{ - static ref BACKUP_ROUTER: Router = backup_api(); -} - - -pub struct BackupService { - rpcenv: BackupEnvironment, - worker: Arc, -} - -impl BackupService { - - fn new(rpcenv: BackupEnvironment, worker: Arc) -> Self { - Self { rpcenv, worker } - } - - fn handle_request(&self, req: Request) -> BoxFut { - - let (parts, body) = req.into_parts(); - - let method = parts.method.clone(); - - let (path, components) = match tools::normalize_uri_path(parts.uri.path()) { - Ok((p,c)) => (p, c), - Err(err) => return Box::new(future::err(http_err!(BAD_REQUEST, err.to_string()))), - }; - - let formatter = &JSON_FORMATTER; - - self.worker.log(format!("H2 REQUEST {} {}", method, path)); - self.worker.log(format!("H2 COMPO {:?}", components)); - - let mut uri_param = HashMap::new(); - - match BACKUP_ROUTER.find_method(&components, method, &mut uri_param) { - MethodDefinition::None => { - let err = http_err!(NOT_FOUND, "Path not found.".to_string()); - return Box::new(future::ok((formatter.format_error)(err))); - } - MethodDefinition::Simple(api_method) => { - return crate::server::rest::handle_sync_api_request(self.rpcenv.clone(), api_method, formatter, parts, body, uri_param); - } - MethodDefinition::Async(async_method) => { - return crate::server::rest::handle_async_api_request(self.rpcenv.clone(), async_method, formatter, parts, body, uri_param); - } - } - } - - fn log_response(worker: Arc, method: hyper::Method, path: &str, resp: &Response) { - - let status = resp.status(); - - if !status.is_success() { - let reason = status.canonical_reason().unwrap_or("unknown reason"); - - let mut message = "request failed"; - if let Some(data) = resp.extensions().get::() { - message = &data.0; - } - - worker.log(format!("{} {}: {} {}: {}", method.as_str(), path, status.as_str(), reason, message)); - } - } -} - -impl hyper::service::Service for BackupService { - type ReqBody = Body; - type ResBody = Body; - type Error = hyper::Error; - type Future = Box, Error = Self::Error> + Send>; - - fn call(&mut self, req: Request) -> Self::Future { - let path = req.uri().path().to_owned(); - let method = req.method().clone(); - let worker = self.worker.clone(); - - Box::new(self.handle_request(req).then(move |result| { - match result { - Ok(res) => { - Self::log_response(worker, method, &path, &res); - Ok::<_, hyper::Error>(res) - } - Err(err) => { - if let Some(apierr) = err.downcast_ref::() { - let mut resp = Response::new(Body::from(apierr.message.clone())); - *resp.status_mut() = apierr.code; - Self::log_response(worker, method, &path, &resp); - Ok(resp) - } else { - let mut resp = Response::new(Body::from(err.to_string())); - *resp.status_mut() = StatusCode::BAD_REQUEST; - Self::log_response(worker, method, &path, &resp); - Ok(resp) - } - } - } - })) - } -} - fn upgrade_to_backup_protocol( parts: Parts, req_body: Body, @@ -143,6 +40,8 @@ fn upgrade_to_backup_protocol( rpcenv: &mut RpcEnvironment, ) -> Result { + static PROXMOX_BACKUP_PROTOCOL_ID: &str = "proxmox-backup-protocol-h2"; + let store = tools::required_string_param(¶m, "store")?; let backup_type = tools::required_string_param(¶m, "backup-type")?; let backup_id = tools::required_string_param(¶m, "backup-id")?; diff --git a/src/api2/admin/datastore/backup/service.rs b/src/api2/admin/datastore/backup/service.rs new file mode 100644 index 00000000..6ddcb3d4 --- /dev/null +++ b/src/api2/admin/datastore/backup/service.rs @@ -0,0 +1,115 @@ +use failure::*; +use lazy_static::lazy_static; + +use std::collections::HashMap; +use std::sync::Arc; + +use futures::*; +use hyper::{Body, Request, Response, StatusCode}; + +use crate::tools; +use crate::api_schema::router::*; +use crate::server::formatter::*; +use crate::server::WorkerTask; + +use super::environment::*; + +lazy_static!{ + static ref BACKUP_ROUTER: Router = super::backup_api(); +} + + +pub struct BackupService { + rpcenv: BackupEnvironment, + worker: Arc, +} + +impl BackupService { + + pub fn new(rpcenv: BackupEnvironment, worker: Arc) -> Self { + Self { rpcenv, worker } + } + + fn handle_request(&self, req: Request) -> BoxFut { + + let (parts, body) = req.into_parts(); + + let method = parts.method.clone(); + + let (path, components) = match tools::normalize_uri_path(parts.uri.path()) { + Ok((p,c)) => (p, c), + Err(err) => return Box::new(future::err(http_err!(BAD_REQUEST, err.to_string()))), + }; + + let formatter = &JSON_FORMATTER; + + self.worker.log(format!("H2 REQUEST {} {}", method, path)); + self.worker.log(format!("H2 COMPO {:?}", components)); + + let mut uri_param = HashMap::new(); + + match BACKUP_ROUTER.find_method(&components, method, &mut uri_param) { + MethodDefinition::None => { + let err = http_err!(NOT_FOUND, "Path not found.".to_string()); + return Box::new(future::ok((formatter.format_error)(err))); + } + MethodDefinition::Simple(api_method) => { + return crate::server::rest::handle_sync_api_request(self.rpcenv.clone(), api_method, formatter, parts, body, uri_param); + } + MethodDefinition::Async(async_method) => { + return crate::server::rest::handle_async_api_request(self.rpcenv.clone(), async_method, formatter, parts, body, uri_param); + } + } + } + + fn log_response(worker: Arc, method: hyper::Method, path: &str, resp: &Response) { + + let status = resp.status(); + + if !status.is_success() { + let reason = status.canonical_reason().unwrap_or("unknown reason"); + + let mut message = "request failed"; + if let Some(data) = resp.extensions().get::() { + message = &data.0; + } + + worker.log(format!("{} {}: {} {}: {}", method.as_str(), path, status.as_str(), reason, message)); + } + } +} + +impl hyper::service::Service for BackupService { + type ReqBody = Body; + type ResBody = Body; + type Error = hyper::Error; + type Future = Box, Error = Self::Error> + Send>; + + fn call(&mut self, req: Request) -> Self::Future { + let path = req.uri().path().to_owned(); + let method = req.method().clone(); + let worker = self.worker.clone(); + + Box::new(self.handle_request(req).then(move |result| { + match result { + Ok(res) => { + Self::log_response(worker, method, &path, &res); + Ok::<_, hyper::Error>(res) + } + Err(err) => { + if let Some(apierr) = err.downcast_ref::() { + let mut resp = Response::new(Body::from(apierr.message.clone())); + *resp.status_mut() = apierr.code; + Self::log_response(worker, method, &path, &resp); + Ok(resp) + } else { + let mut resp = Response::new(Body::from(err.to_string())); + *resp.status_mut() = StatusCode::BAD_REQUEST; + Self::log_response(worker, method, &path, &resp); + Ok(resp) + } + } + } + })) + } +}