feat: provide support for Handler trait

Author: LeoBorai

src/http-server/src/handler/file_explorer/mod.rs

@@ -7,6 +7,7 @@ use std::fs::read_dir;
 use std::path::{Component, Path, PathBuf};
 
 use anyhow::{Context, Result};
+use async_trait::async_trait;
 use bytes::Bytes;
 use http::{HeaderValue, Method, Response, StatusCode, Uri, header::CONTENT_TYPE, request::Parts};
 use http_body_util::{BodyExt, Full};
@@ -16,6 +17,7 @@ use proto::{DirectoryEntry, DirectoryIndex, EntryType, Sort};
 use rust_embed::Embed;
 use tokio::io::AsyncWriteExt;
 
+use crate::handler::Handler;
 use crate::server::{HttpRequest, HttpResponse};
 
 use self::proto::BreadcrumbItem;
@@ -38,41 +40,6 @@ impl FileExplorer {
         }
     }
 
-    pub async fn handle(&self, req: HttpRequest) -> Result<HttpResponse> {
-        let (parts, body) = req.into_parts();
-        let body = body.collect().await.unwrap().to_bytes();
-
-        if parts.uri.path().starts_with("/api/v1") {
-            return self.handle_api(parts, body).await;
-        }
-
-        let path = parts.uri.path();
-        let path = path.strip_prefix('/').unwrap_or(path);
-
-        if let Some(file) = FileExplorerAssets::get(path) {
-            let content_type = mime_guess::from_path(path).first_or_octet_stream();
-            let content_type = HeaderValue::from_str(content_type.as_ref()).unwrap();
-            let body = Full::new(Bytes::from(file.data.to_vec()));
-            let mut response = Response::new(body);
-            let mut headers = response.headers().clone();
-
-            headers.append(CONTENT_TYPE, content_type);
-            *response.headers_mut() = headers;
-
-            return Ok(response);
-        }
-
-        let index = FileExplorerAssets::get("index.html").unwrap();
-        let body = Full::new(Bytes::from(index.data.to_vec()));
-        let mut response = Response::new(body);
-        let mut headers = response.headers().clone();
-
-        headers.append(CONTENT_TYPE, "text/html".try_into().unwrap());
-        *response.headers_mut() = headers;
-
-        Ok(response)
-    }
-
     async fn handle_api(&self, parts: Parts, body: Bytes) -> Result<HttpResponse> {
         let path = Self::parse_req_uri(parts.uri.clone()).unwrap();
 
@@ -328,3 +295,41 @@ impl FileExplorer {
         Self::index_directory(self.path.clone(), path)
     }
 }
+
+#[async_trait]
+impl Handler for FileExplorer {
+    async fn handle(&self, req: HttpRequest) -> Result<HttpResponse> {
+        let (parts, body) = req.into_parts();
+        let body = body.collect().await.unwrap().to_bytes();
+
+        if parts.uri.path().starts_with("/api/v1") {
+            return self.handle_api(parts, body).await;
+        }
+
+        let path = parts.uri.path();
+        let path = path.strip_prefix('/').unwrap_or(path);
+
+        if let Some(file) = FileExplorerAssets::get(path) {
+            let content_type = mime_guess::from_path(path).first_or_octet_stream();
+            let content_type = HeaderValue::from_str(content_type.as_ref()).unwrap();
+            let body = Full::new(Bytes::from(file.data.to_vec()));
+            let mut response = Response::new(body);
+            let mut headers = response.headers().clone();
+
+            headers.append(CONTENT_TYPE, content_type);
+            *response.headers_mut() = headers;
+
+            return Ok(response);
+        }
+
+        let index = FileExplorerAssets::get("index.html").unwrap();
+        let body = Full::new(Bytes::from(index.data.to_vec()));
+        let mut response = Response::new(body);
+        let mut headers = response.headers().clone();
+
+        headers.append(CONTENT_TYPE, "text/html".try_into().unwrap());
+        *response.headers_mut() = headers;
+
+        Ok(response)
+    }
+}

src/http-server/src/handler/file_explorer/utils.rs

@@ -33,35 +33,3 @@ pub fn decode_uri(file_path: &str) -> PathBuf {
         })
         .collect::<PathBuf>()
 }
-
-#[cfg(test)]
-mod tests {
-    use std::path::PathBuf;
-    use std::str::FromStr;
-
-    use super::{decode_uri, encode_uri};
-
-    #[test]
-    fn encodes_uri() {
-        let file_path = "/these are important files/do_not_delete/file name.txt";
-        let file_path = PathBuf::from_str(file_path).unwrap();
-        let file_path = encode_uri(&file_path);
-
-        assert_eq!(
-            file_path,
-            "/these%20are%20important%20files/do_not_delete/file%20name.txt"
-        );
-    }
-
-    #[test]
-    fn decodes_uri() {
-        let file_path = "these%20are%20important%20files/do_not_delete/file%20name.txt";
-        let file_path = decode_uri(file_path);
-        let file_path = file_path.to_str().unwrap();
-
-        assert_eq!(
-            file_path,
-            "these are important files/do_not_delete/file name.txt"
-        );
-    }
-}

src/http-server/src/handler/file_server/mod.rs

@@ -2,13 +2,16 @@ mod service;
 mod utils;
 
 use anyhow::Result;
+use async_trait::async_trait;
 use bytes::Bytes;
 use http::{Method, Response, StatusCode};
 use http_body_util::Full;
 
-use crate::handler::file_server::service::FileServerConfig;
+use crate::handler::Handler;
 use crate::server::{HttpRequest, HttpResponse};
 
+pub use crate::handler::file_server::service::FileServerConfig;
+
 use self::service::FileServer as FileServerService;
 
 pub struct FileServer {
@@ -21,8 +24,11 @@ impl FileServer {
             file_service: FileServerService::new(config),
         }
     }
+}
 
-    pub async fn handle(&self, req: HttpRequest) -> Result<HttpResponse> {
+#[async_trait]
+impl Handler for FileServer {
+    async fn handle(&self, req: HttpRequest) -> Result<HttpResponse> {
         let (parts, _) = req.into_parts();
 
         if parts.uri.path().starts_with("/api/v1") {

src/http-server/src/handler/file_server/service/file.rs

@@ -1,19 +1,10 @@
 use std::fs::Metadata;
-use std::mem::MaybeUninit;
 use std::path::PathBuf;
-use std::pin::Pin;
-use std::task::{self, Poll};
 
 use anyhow::{Context, Result};
 use chrono::{DateTime, Local};
-use futures::Stream;
-use hyper::body::Bytes;
 use mime_guess::{Mime, from_path};
-use tokio::io::{AsyncRead, ReadBuf};
-
-pub const FILE_BUFFER_SIZE: usize = 8 * 1024;
-
-pub type FileBuffer = Box<[MaybeUninit<u8>; FILE_BUFFER_SIZE]>;
+use tokio::io::AsyncReadExt;
 
 /// Wrapper around `tokio::fs::File` built from a OS ScopedFileSystem file
 /// providing `std::fs::Metadata` and the path to such file
@@ -51,57 +42,9 @@ impl File {
         Ok(modified)
     }
 
-    #[allow(dead_code)]
-    pub fn bytes(self) -> Vec<u8> {
-        let byte_stream = ByteStream {
-            file: self.file,
-            buffer: Box::new([MaybeUninit::uninit(); FILE_BUFFER_SIZE]),
-        };
-
-        byte_stream
-            .buffer
-            .iter()
-            .map(|muint| unsafe { muint.assume_init() })
-            .collect::<Vec<u8>>()
-    }
-}
-
-pub struct ByteStream {
-    file: tokio::fs::File,
-    buffer: FileBuffer,
-}
-
-impl From<File> for ByteStream {
-    fn from(file: File) -> Self {
-        ByteStream {
-            file: file.file,
-            buffer: Box::new([MaybeUninit::uninit(); FILE_BUFFER_SIZE]),
-        }
-    }
-}
-
-impl Stream for ByteStream {
-    type Item = Result<Bytes>;
-
-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Option<Self::Item>> {
-        let ByteStream {
-            ref mut file,
-            ref mut buffer,
-        } = *self;
-        let mut read_buffer = ReadBuf::uninit(&mut buffer[..]);
-
-        match Pin::new(file).poll_read(cx, &mut read_buffer) {
-            Poll::Ready(Ok(())) => {
-                let filled = read_buffer.filled();
-
-                if filled.is_empty() {
-                    Poll::Ready(None)
-                } else {
-                    Poll::Ready(Some(Ok(Bytes::copy_from_slice(filled))))
-                }
-            }
-            Poll::Ready(Err(error)) => Poll::Ready(Some(Err(error.into()))),
-            Poll::Pending => Poll::Pending,
-        }
+    pub async fn bytes(&mut self) -> Result<Vec<u8>> {
+        let mut buf = Vec::with_capacity(self.size() as usize);
+        self.file.read_to_end(&mut buf).await?;
+        Ok(buf)
     }
 }

src/http-server/src/handler/file_server/service/http_utils.rs

@@ -1,28 +1,19 @@
-use std::mem::MaybeUninit;
-use std::pin::Pin;
-use std::task::{self, Poll};
+use std::fmt::Display;
 
 use anyhow::{Context, Result};
 use chrono::{DateTime, Local, Utc};
-use futures::Stream;
 use http::response::Builder as HttpResponseBuilder;
 use http_body_util::Full;
 use hyper::body::Bytes;
-use tokio::io::{AsyncRead, ReadBuf};
 
 use crate::server::HttpResponse;
 
 use super::file::File;
 
-const FILE_BUFFER_SIZE: usize = 8 * 1024;
-
-pub type FileBuffer = Box<[MaybeUninit<u8>; FILE_BUFFER_SIZE]>;
-
 /// HTTP Response `Cache-Control` directive
 ///
 /// Allow dead code until we have support for cache control configuration
 #[allow(dead_code)]
-
 pub enum CacheControlDirective {
     /// Cache-Control: must-revalidate
     MustRevalidate,
@@ -44,25 +35,25 @@ pub enum CacheControlDirective {
     SMaxAge(u64),
 }
 
-impl ToString for CacheControlDirective {
-    fn to_string(&self) -> String {
+impl Display for CacheControlDirective {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match &self {
-            Self::MustRevalidate => String::from("must-revalidate"),
-            Self::NoCache => String::from("no-cache"),
-            Self::NoStore => String::from("no-store"),
-            Self::NoTransform => String::from("no-transform"),
-            Self::Public => String::from("public"),
-            Self::Private => String::from("private"),
-            Self::ProxyRavalidate => String::from("proxy-revalidate"),
-            Self::MaxAge(age) => format!("max-age={}", age),
-            Self::SMaxAge(age) => format!("s-maxage={}", age),
+            Self::MustRevalidate => write!(f, "must-revalidate"),
+            Self::NoCache => write!(f, "no-cache"),
+            Self::NoStore => write!(f, "no-store"),
+            Self::NoTransform => write!(f, "no-transform"),
+            Self::Public => write!(f, "public"),
+            Self::Private => write!(f, "private"),
+            Self::ProxyRavalidate => write!(f, "proxy-revalidate"),
+            Self::MaxAge(age) => write!(f, "max-age={}", age),
+            Self::SMaxAge(age) => write!(f, "s-maxage={}", age),
         }
     }
 }
 
+#[derive(Debug)]
 pub struct ResponseHeaders {
     cache_control: String,
-    content_length: u64,
     content_type: String,
     etag: String,
     last_modified: String,
@@ -77,17 +68,12 @@ impl ResponseHeaders {
 
         Ok(ResponseHeaders {
             cache_control: cache_control_directive.to_string(),
-            content_length: ResponseHeaders::content_length(file),
             content_type: ResponseHeaders::content_type(file),
             etag: ResponseHeaders::etag(file, &last_modified),
             last_modified: ResponseHeaders::last_modified(&last_modified),
         })
     }
 
-    fn content_length(file: &File) -> u64 {
-        file.size()
-    }
-
     fn content_type(file: &File) -> String {
         file.mime().to_string()
     }
@@ -112,52 +98,20 @@ impl ResponseHeaders {
 }
 
 pub async fn make_http_file_response(
-    file: File,
+    mut file: File,
     cache_control_directive: CacheControlDirective,
 ) -> Result<HttpResponse> {
     let headers = ResponseHeaders::new(&file, cache_control_directive)?;
     let builder = HttpResponseBuilder::new()
-        .header(http::header::CONTENT_LENGTH, headers.content_length)
         .header(http::header::CACHE_CONTROL, headers.cache_control)
         .header(http::header::CONTENT_TYPE, headers.content_type)
         .header(http::header::ETAG, headers.etag)
         .header(http::header::LAST_MODIFIED, headers.last_modified);
 
-    let body = Full::new(Bytes::from(file.bytes()));
+    let body = Full::new(Bytes::from(file.bytes().await?));
     let response = builder
         .body(body)
         .context("Failed to build HTTP File Response")?;
 
     Ok(response)
 }
-
-pub struct ByteStream {
-    file: tokio::fs::File,
-    buffer: FileBuffer,
-}
-
-impl Stream for ByteStream {
-    type Item = Result<Bytes>;
-
-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Option<Self::Item>> {
-        let ByteStream {
-            ref mut file,
-            ref mut buffer,
-        } = *self;
-        let mut read_buffer = ReadBuf::uninit(&mut buffer[..]);
-
-        match Pin::new(file).poll_read(cx, &mut read_buffer) {
-            Poll::Ready(Ok(())) => {
-                let filled = read_buffer.filled();
-
-                if filled.is_empty() {
-                    Poll::Ready(None)
-                } else {
-                    Poll::Ready(Some(Ok(Bytes::copy_from_slice(filled))))
-                }
-            }
-            Poll::Ready(Err(error)) => Poll::Ready(Some(Err(error.into()))),
-            Poll::Pending => Poll::Pending,
-        }
-    }
-}