Fix issues, and clean up implementation

the10thWiz · the10thWiz · commit 30610e04a64b · 2024-05-10T16:32:42.000-05:00
diff --git a/core/lib/src/fs/server.rs b/core/lib/src/fs/server.rs
@@ -1,11 +1,12 @@
 use core::fmt;
+use std::any::{type_name, Any, TypeId};
 use std::path::{PathBuf, Path};
 use std::sync::Arc;
 use std::time::SystemTime;
 
 
 use crate::{Data, Request};
-use crate::http::{Method, Status, uri::{Segments, Uri}, ext::IntoOwned, HeaderMap, Header};
+use crate::http::{Method, Status, uri::{Segments, Reference}, ext::IntoOwned, HeaderMap};
 use crate::route::{Route, Handler, Outcome};
 use crate::response::{Redirect, Responder};
 use crate::outcome::IntoOutcome;
@@ -92,20 +93,22 @@ impl fmt::Debug for DebugListRewrite<'_> {
     }
 }
 
-pub trait Rewrite: Send + Sync + 'static {
-    fn name(&self) -> &'static str {
-        std::any::type_name::<Self>()
-    }
+pub trait Rewrite: Send + Sync + Any {
     /// Modify RewritablePath as needed.
     fn rewrite(&self, req: &Request<'_>, path: FileServerResponse, root: &Path) -> FileServerResponse;
+    /// Allow multiple of the same rewrite
+    fn allow_multiple(&self) -> bool { false }
+    fn name(&self) -> &'static str{ type_name::<Self>()}
 }
 
+#[derive(Debug)]
 pub enum HiddenReason {
     DotFile,
     PermissionDenied,
     Other,
 }
 
+#[derive(Debug)]
 pub enum FileServerResponse {
     /// Status: Ok
     File {
@@ -118,9 +121,9 @@ pub enum FileServerResponse {
     /// Status: NotFound (used to identify if the file does actually exist)
     Hidden { name: PathBuf, reason: HiddenReason },
     /// Status: Redirect
-    PermanentRedirect { to: Uri<'static> },
+    PermanentRedirect { to: Reference<'static> },
     /// Status: Redirect (TODO: should we allow this?)
-    TemporaryRedirect { to: Uri<'static> },
+    TemporaryRedirect { to: Reference<'static> },
 }
 
 // These might have to remain as basic options (always processed first)
@@ -142,30 +145,35 @@ impl Rewrite for DotFiles {
 
 struct Index(&'static str);
 impl Rewrite for Index {
-    fn rewrite(&self, _req: &Request<'_>, path: FileServerResponse, _root: &Path) -> FileServerResponse {
+    fn rewrite(&self, _req: &Request<'_>, path: FileServerResponse, root: &Path) -> FileServerResponse {
         // if path.file_name_path.is_dir() {
         //     path.file_name_path.push(self.0);
         //     // TODO: handle file_data_path
         // }
         match path {
-            FileServerResponse::File { name, modified, headers } if name.is_dir() => FileServerResponse::File { name: name.join(self.0), modified, headers },
+            FileServerResponse::File { name, modified, headers } if root.join(&name).is_dir() => FileServerResponse::File { name: name.join(self.0), modified, headers },
             path => path,
         }
     }
 }
-// I'm not sure this one works, since we should check it during startup
+// Actually, curiously, this already just works as-is (the only thing that prevents it is the startup check)
 struct IndexFile;
 impl Rewrite for IndexFile {
-    fn rewrite(&self, req: &Request<'_>, path: FileServerResponse, root: &Path) -> FileServerResponse {
-        todo!()
+    fn rewrite(&self, _req: &Request<'_>, path: FileServerResponse, _root: &Path) -> FileServerResponse {
+        match path {
+            // FileServerResponse::File { name, modified, headers } if _root.is_file() && name.iter().count() == 0 => {
+            //     FileServerResponse::File { name, modified, headers }
+            // }
+            path => path,
+        }
     }
 }
 
 struct NormalizeDirs;
 impl Rewrite for NormalizeDirs {
-    fn rewrite(&self, req: &Request<'_>, path: FileServerResponse, _root: &Path) -> FileServerResponse {
+    fn rewrite(&self, req: &Request<'_>, path: FileServerResponse, root: &Path) -> FileServerResponse {
         match path {
-            FileServerResponse::File { name, .. } if name.is_dir() && !req.uri().path().ends_with('/') =>
+            FileServerResponse::File { name, .. } if !req.uri().path().ends_with('/') && root.join(&name).is_dir() =>
                 FileServerResponse::PermanentRedirect {
                     to: req.uri().map_path(|p| format!("{}/", p))
                         .expect("adding a trailing slash to a known good path => valid path")
@@ -218,7 +226,9 @@ impl FileServer {
     /// ```
     #[track_caller]
     pub fn from<P: AsRef<Path>>(path: P) -> Self {
-        FileServer::new(path, Options::default())
+        FileServer::new(path, Options::None)
+            .rewrite(NormalizeDirs)
+            .rewrite(Index("index.html"))
     }
 
     /// Constructs a new `FileServer` that serves files from the file system
@@ -255,6 +265,7 @@ impl FileServer {
 
         let path = path.as_ref();
         if !options.contains(Options::Missing) {
+            #[allow(deprecated)]
             if !options.contains(Options::IndexFile) && !path.is_dir() {
                 let path = path.display();
                 error!("FileServer path '{}' is not a directory.", path.primary());
@@ -267,12 +278,34 @@ impl FileServer {
                 panic!("invalid file: refusing to continue");
             }
         }
+        let mut rewrites: Vec<Arc<dyn Rewrite>> = vec![];
+        #[allow(deprecated)]
+        if options.contains(Options::DotFiles) {
+            rewrites.push(Arc::new(DotFiles));
+        }
+        #[allow(deprecated)]
+        if options.contains(Options::NormalizeDirs) {
+            rewrites.push(Arc::new(NormalizeDirs));
+        }
+        #[allow(deprecated)]
+        if options.contains(Options::Index) {
+            rewrites.push(Arc::new(Index("index.html")));
+        }
+
+        FileServer { root: path.into(), options, rewrites, rank: Self::DEFAULT_RANK }
+    }
 
-        FileServer { root: path.into(), options, rewrites: vec![], rank: Self::DEFAULT_RANK }
+    pub fn remove_rewrites<T: Rewrite>(mut self) -> Self {
+        self.rewrites.retain(|r| r.as_ref().type_id() != TypeId::of::<T>());
+        self
     }
 
     pub fn rewrite(mut self, rewrite: impl Rewrite) -> Self {
-        self.rewrites.push(Arc::new(rewrite));
+        if rewrite.allow_multiple() || !self.rewrites.iter().any(|f| f.as_ref().type_id() == rewrite.type_id()) {
+            self.rewrites.push(Arc::new(rewrite));
+        } else {
+            error!("Attempted to insert multiple of the same rewrite `{}` on a FileServer", rewrite.name());
+        }
         self
     }
 
@@ -317,20 +350,28 @@ impl Handler for FileServer {
             Some((name, true)) => FileServerResponse::Hidden { name, reason: HiddenReason::DotFile },
             None => return Outcome::forward(data, Status::NotFound),
         };
+        println!("initial: {response:?}");
         for rewrite in &self.rewrites {
             response = rewrite.rewrite(req, response, &self.root);
+            println!("after: {} {response:?}", rewrite.name());
         }
         match response {
-            FileServerResponse::File { name, modified, headers } => NamedFile::open(self.root.join(name)).await.respond_to(req).map(|mut r| {
-                for header in headers {
-                    r.adjoin_raw_header(header.name.as_str().to_owned(), header.value);
-                }
-                if let Some(modified) = modified {
-                    // TODO: must be converted to http-data format
-                    // r.set_header(Header::new("Last-Modified", format!("{:?}", modified)));
+            FileServerResponse::File { name, modified, headers } => {
+                let path = self.root.join(name);
+                if path.is_dir() {
+                    return Outcome::Forward((data, Status::NotFound));
                 }
-                r
-            }).or_forward((data, Status::NotFound)),
+                NamedFile::open(path).await.respond_to(req).map(|mut r| {
+                    for header in headers {
+                        r.adjoin_raw_header(header.name.as_str().to_owned(), header.value);
+                    }
+                    if let Some(modified) = modified {
+                        // TODO: must be converted to http-date format
+                        // r.set_header(Header::new("Last-Modified", format!("{:?}", modified)));
+                    }
+                    r
+                }).or_forward((data, Status::NotFound))
+            },
             FileServerResponse::Hidden { .. } | FileServerResponse::NotFound { ..} => Outcome::forward(data, Status::NotFound),
             FileServerResponse::PermanentRedirect { to } => Redirect::permanent(to).respond_to(req).or_forward((data, Status::InternalServerError)),
             FileServerResponse::TemporaryRedirect { to } => Redirect::temporary(to).respond_to(req).or_forward((data, Status::InternalServerError)),
@@ -372,6 +413,7 @@ impl Options {
     /// exists. When disabled, requests to directories will always forward.
     ///
     /// **Enabled by default.**
+    #[deprecated(note = "Replaced by `.rewrite(Index(\"index.html\"))`")]
     pub const Index: Options = Options(1 << 0);
 
     /// Allow serving dotfiles.
@@ -381,6 +423,7 @@ impl Options {
     /// treated as missing.
     ///
     /// **Disabled by default.**
+    #[deprecated(note = "Replaced by `.rewrite(DotFiles)`")]
     pub const DotFiles: Options = Options(1 << 1);
 
     /// Normalizes directory requests by redirecting requests to directory paths
@@ -420,6 +463,7 @@ impl Options {
     /// redirected. `index.html` would be rendered, and the relative link to
     /// `cat.jpeg` would be resolved by the browser as `example.com/cat.jpeg`.
     /// Rocket would thus try to find `/static/cat.jpeg`, which does not exist.
+    #[deprecated(note = "Replaced by `.rewrite(NormalizeDirs)`")]
     pub const NormalizeDirs: Options = Options(1 << 2);
 
     /// Allow serving a file instead of a directory.
@@ -486,6 +530,7 @@ impl Options {
 
 /// The default set of options: `Options::Index | Options:NormalizeDirs`.
 impl Default for Options {
+    #[allow(deprecated)]
     fn default() -> Self {
         Options::Index | Options::NormalizeDirs
     }
diff --git a/core/lib/tests/file_server.rs b/core/lib/tests/file_server.rs
@@ -14,7 +14,7 @@ fn rocket() -> Rocket<Build> {
     let root = static_root();
     rocket::build()
         .mount("/default", FileServer::from(&root))
-        .mount("/no_index", FileServer::new(&root, Options::None))
+        .mount("/no_index", dbg!(FileServer::new(&root, Options::None)))
         .mount("/dots", FileServer::new(&root, Options::DotFiles))
         .mount("/index", FileServer::new(&root, Options::Index))
         .mount("/both", FileServer::new(&root, Options::DotFiles | Options::Index))
