rest-server: cleanup unreadable code

[proxmox.git] / proxmox-rest-server / src / h2service.rs
diff --git a/proxmox-rest-server/src/h2service.rs b/proxmox-rest-server/src/h2service.rs

index f5fcdeeac97d114216ac530b553136390a25ed26..3f90c178d5954fc82a8fc7b600b8c6db25541bb1 100644 (file)
--- a/proxmox-rest-server/src/h2service.rs
+++ b/proxmox-rest-server/src/h2service.rs
@@ -1,4 +1,4 @@
-use anyhow::{Error};
+use anyhow::Error;
  
  use std::collections::HashMap;
  use std::pin::Pin;
@@ -8,11 +8,11 @@ use std::task::{Context, Poll};
  use futures::*;
  use hyper::{Body, Request, Response, StatusCode};
  
-use proxmox_router::{ApiResponseFuture, HttpError, Router, RpcEnvironment};
  use proxmox_router::http_err;
+use proxmox_router::{ApiResponseFuture, HttpError, Router, RpcEnvironment};
  
-use crate::{normalize_uri_path, WorkerTask};
  use crate::formatter::*;
+use crate::{normalize_uri_path, WorkerTask};
  
  /// Hyper Service implementation to handle stateful H2 connections.
  ///
@@ -26,24 +26,29 @@ pub struct H2Service<E> {
      debug: bool,
  }
  
-impl <E: RpcEnvironment + Clone> H2Service<E> {
-
+impl<E: RpcEnvironment + Clone> H2Service<E> {
      pub fn new(rpcenv: E, worker: Arc<WorkerTask>, router: &'static Router, debug: bool) -> Self {
-        Self { rpcenv, worker, router, debug }
+        Self {
+            rpcenv,
+            worker,
+            router,
+            debug,
+        }
      }
  
      pub fn debug<S: AsRef<str>>(&self, msg: S) {
-        if self.debug { self.worker.log_message(msg); }
+        if self.debug {
+            self.worker.log_message(msg);
+        }
      }
  
      fn handle_request(&self, req: Request<Body>) -> ApiResponseFuture {
-
          let (parts, body) = req.into_parts();
  
          let method = parts.method.clone();
  
          let (path, components) = match normalize_uri_path(parts.uri.path()) {
-            Ok((p,c)) => (p, c),
+            Ok((p, c)) => (p, c),
              Err(err) => return future::err(http_err!(BAD_REQUEST, "{}", err)).boxed(),
          };
  
@@ -58,15 +63,24 @@ impl <E: RpcEnvironment + Clone> H2Service<E> {
                  let err = http_err!(NOT_FOUND, "Path '{}' not found.", path);
                  future::ok(formatter.format_error(err)).boxed()
              }
-            Some(api_method) => {
-                crate::rest::handle_api_request(
-                    self.rpcenv.clone(), api_method, formatter, parts, body, uri_param).boxed()
-            }
+            Some(api_method) => crate::rest::handle_api_request(
+                self.rpcenv.clone(),
+                api_method,
+                formatter,
+                parts,
+                body,
+                uri_param,
+            )
+            .boxed(),
          }
      }
  
-    fn log_response(worker: Arc<WorkerTask>, method: hyper::Method, path: &str, resp: &Response<Body>) {
-
+    fn log_response(
+        worker: Arc<WorkerTask>,
+        method: hyper::Method,
+        path: &str,
+        resp: &Response<Body>,
+    ) {
          let status = resp.status();
  
          if !status.is_success() {
@@ -89,7 +103,7 @@ impl <E: RpcEnvironment + Clone> H2Service<E> {
      }
  }
  
-impl <E: RpcEnvironment + Clone> tower_service::Service<Request<Body>> for H2Service<E> {
+impl<E: RpcEnvironment + Clone> tower_service::Service<Request<Body>> for H2Service<E> {
      type Response = Response<Body>;
      type Error = Error;
      #[allow(clippy::type_complexity)]
@@ -111,15 +125,17 @@ impl <E: RpcEnvironment + Clone> tower_service::Service<Request<Body>> for H2Ser
                      Ok::<_, Error>(res)
                  }
                  Err(err) => {
-                     if let Some(apierr) = err.downcast_ref::<HttpError>() {
+                    if let Some(apierr) = err.downcast_ref::<HttpError>() {
                          let mut resp = Response::new(Body::from(apierr.message.clone()));
-                        resp.extensions_mut().insert(ErrorMessageExtension(apierr.message.clone()));
+                        resp.extensions_mut()
+                            .insert(ErrorMessageExtension(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.extensions_mut().insert(ErrorMessageExtension(err.to_string()));
+                        resp.extensions_mut()
+                            .insert(ErrorMessageExtension(err.to_string()));
                          *resp.status_mut() = StatusCode::BAD_REQUEST;
                          Self::log_response(worker, method, &path, &resp);
                          Ok(resp)