feat: added support for static aliases in the warp integration

None of this has been tested yet, so there will likely be bugs.
We now depend on my fork of Warp until [this](seanmonstar/warp#924) is merged.

Author: arctic-hen7

packages/perseus-warp/Cargo.toml

@@ -16,11 +16,13 @@ categories = ["wasm", "web-programming::http-server", "development-tools", "asyn
 [dependencies]
 perseus = { path = "../perseus", version = "0.3.0-beta.18" }
 tokio = { version = "1", features = [ "full" ] } # TODO Select only some features on Tokio
-warp = "0.3"
+warp = { version = "0.3", git = "https://github.com/arctic-hen7/warp", branch = "master" } # Temporary until Warp #171 is resolved
 urlencoding = "2.1"
 serde = "1"
 serde_json = "1"
 thiserror = "1"
 fmterr = "0.1"
 futures = "0.3"
 sycamore = { version = "0.6", features = ["ssr"] }
+async-stream = "0.3"
+bytes = "1"

packages/perseus-warp/src/perseus_routes.rs

@@ -1,7 +1,9 @@
 use crate::initial_load::initial_load_handler;
 use crate::page_data::page_handler;
 use crate::{
-    conv_req::get_http_req, page_data::PageDataReq, static_content::static_aliases_filter,
+    conv_req::get_http_req,
+    page_data::PageDataReq,
+    static_content::{serve_file, static_aliases_filter},
     translations::translations_handler,
 };
 use perseus::internal::serve::{get_render_cfg, ServerOptions};
@@ -51,7 +53,9 @@ pub async fn perseus_routes<M: MutableStore + 'static, T: TranslationsManager +
         .untuple_one() // We need this to avoid a ((), File) (which makes the return type fail)
         .and(warp::fs::dir(opts.static_dir.clone().unwrap()));
     // Handle static aliases
-    let static_aliases = warp::any().and(static_aliases_filter(opts.static_aliases.clone()));
+    let static_aliases = warp::any()
+        .and(static_aliases_filter(opts.static_aliases.clone()))
+        .and_then(serve_file);
 
     // Define some filters to handle all the data we want to pass through
     let opts = Arc::new(opts);

packages/perseus-warp/src/static_content.rs

@@ -1,5 +1,6 @@
 use std::collections::HashMap;
-
+use std::sync::Arc;
+use warp::fs::{file_reply, ArcPath, Conditionals, File};
 use warp::{path::FullPath, Filter, Rejection};
 
 /// A filter for static aliases that determines which file to serve.
@@ -23,9 +24,67 @@ pub fn static_aliases_filter(
                 if file_to_serve.is_empty() {
                     Err(warp::reject::not_found())
                 } else {
-                    // TODO Return the actual file (see Warp internals for this)
                     Ok(file_to_serve)
                 }
             },
         )
 }
+
+/// Serves the file provided through the filter.
+pub async fn serve_file(path: String) -> Result<File, Rejection> {
+    let arc_path = ArcPath(Arc::new(path.into()));
+    let conds = Conditionals::default();
+    file_reply(arc_path, conds).await
+}
+
+// /// Serves the file provided through the filter. This returns an error because we assume that the file is supposed to exist at this point (this is used for static
+// /// aliases).
+// pub async fn serve_file(path: String) -> Result<Response, Rejection> {
+//     match TkFile::open(path).await {
+//         Ok(file) => {
+//             let metadata = file.metadata().await.map_err(|e| warp::reject::not_found())?;
+//             let stream = file_stream(file, metadata);
+//             let res = Response::new(Body::wrap_stream(stream));
+
+//             Ok(res)
+//         },
+//         // If a static alias can't be found, we'll act as if it doesn't exist and proceed to the next handler
+//         Err(_) => Err(warp::reject::not_found())
+//     }
+// }
+
+// // The default chunk size for streaming a file (taken from Warp's internals)
+// const DFLT_BUF_SIZE: usize = 8_192;
+// #[cfg(unix)]
+// fn get_buf_size(metadata: Metadata) -> usize {
+//     use std::os::unix::prelude::MetadataExt;
+
+//     std::cmp::max(metadata.blksize() as usize, DFLT_BUF_SIZE)
+// }
+// #[cfg(not(unix))]
+// fn get_buf_size(_metadata: Metadata) -> usize {
+//     DFLT_BUF_SIZE // On Windows, we don't have a blocksize function based on the metadata
+// }
+
+// /// Reserves more space in a buffer if needed
+// fn reserve_if_needed(buf: &mut BytesMut, cap: usize) {
+//     if buf.capacity() - buf.len() < cap {
+//         buf.reserve(cap);
+//     }
+// }
+
+// fn file_stream(mut file: TkFile, metadata: Metadata) -> impl Stream<Item = Result<Bytes, std::io::Error>> + Send {
+//     let buf_size = get_buf_size(metadata);
+//     let stream = file.seek(SeekFrom::Start(0));
+
+//     let mut buf = BytesMut::new();
+//     reserve_if_needed(&mut buf, buf_size);
+
+//     try_stream! {
+//         for i in 0u8..3 {
+//             reserve_if_needed(&mut buf, buf_size);
+//             let n = file.read(&mut buf).await?;
+//             yield Bytes::from(buf[..n]);
+//         }
+//     }
+// }