feat: Enable caching of uploaded files (#24)

Makes the `/uploads/*` routes respond with appropriate headers to allow
clients to cache the requests:

- `last-modified`
- `etag`
- `cache-control`

while additionally supporting the `if-none-match` request header.

I'm not sure if the `last-modified` and `cache-control` headers are
strictly necessary to allow the client browser to cache the requests,
but adding them doesn't hurt and I don't have time to figure it out. :)

This required adding `entity_tag` as a new dependency to the backend
crate.

Resolves #23

Author: laxsjo

Cargo.lock

@@ -8,6 +8,7 @@ default-run = "meta-tv-rs"
 chrono = "0.4.40"
 common = { path = "../common", features = ["entity"] }
 entity = { path = "../entity" }
+entity-tag = "0.1.8"
 migration = { path = "../migration" }
 openidconnect = { version = "4.0.0", features = ["timing-resistant-secret-traits"] }
 rocket = { version = "0.5.1", features = ["json", "secrets"] }

crates/backend/Cargo.toml

@@ -0,0 +1,73 @@
+use std::{fs::Metadata, io, path::Path};
+
+use chrono::{DateTime, Utc};
+use entity_tag::EntityTag;
+use rocket::{fs, http::Status, response, Request, Response};
+
+/// Wrapper around [`rocket::fs::NamedFile`] which sets appropriate headers to allow better caching.
+///
+/// It adds the following response headers:
+/// - `etag`
+/// - `last-modified`
+/// - `cache-control` with a configured max age
+///
+/// It also responds to the `if-none-match` request header.
+pub struct CachedFile<'etag> {
+    file: fs::NamedFile,
+    metadata: Metadata,
+    etag: EntityTag<'etag>,
+    max_age: chrono::Duration,
+}
+
+impl<'etag> CachedFile<'etag> {
+    pub async fn open(
+        path: impl AsRef<Path>,
+        etag: EntityTag<'etag>,
+        max_age: chrono::Duration,
+    ) -> io::Result<Self> {
+        let file = fs::NamedFile::open(path).await?;
+        let metadata = file.metadata().await?;
+
+        Ok(Self {
+            file,
+            metadata,
+            etag,
+            max_age,
+        })
+    }
+}
+
+impl<'etag, 'r> response::Responder<'r, 'r> for CachedFile<'etag> {
+    fn respond_to(self, req: &Request) -> response::Result<'r> {
+        if let Some(etag) = req
+            .headers()
+            .get("if-none-match")
+            .next()
+            .and_then(|raw_etag| EntityTag::from_str(raw_etag).ok())
+        {
+            if etag == self.etag {
+                return Response::build().status(Status::NotModified).ok();
+            }
+        }
+
+        let modification_time: DateTime<Utc> = self
+            .metadata
+            .modified()
+            .expect("modification time is available on the relevant platforms")
+            .into();
+
+        Response::build_from(self.file.respond_to(req)?)
+            .raw_header(
+                "last-modified",
+                modification_time
+                    .format("%a, %d %b %Y %H:%M:%S GMT")
+                    .to_string(),
+            )
+            .raw_header("etag", format!("{}", self.etag))
+            .raw_header(
+                "cache-control",
+                format!("max-age={}", self.max_age.num_seconds()),
+            )
+            .ok()
+    }
+}

crates/backend/src/cached_file.rs

@@ -1,16 +1,17 @@
 use std::path::{Path, PathBuf};
 
+use entity_tag::EntityTag;
 use rocket::{
     data::Capped,
     fairing::{self, Fairing, Info, Kind},
-    fs::{FileServer, TempFile},
+    fs::TempFile,
     tokio::io::AsyncReadExt,
-    Build, Rocket,
+    Build, Rocket, State,
 };
 use sha2::{Digest, Sha256};
 use std::fmt::Write;
 
-use crate::error::AppError;
+use crate::{cached_file::CachedFile, error::AppError};
 
 pub struct FilesInitializer;
 
@@ -55,19 +56,17 @@ impl Fairing for FilesInitializer {
 
         info!("upload directory is set to {:?}", upload_dir);
 
-        let file_server = FileServer::from(&upload_dir);
         let files = Files { upload_dir };
-        Ok(rocket.manage(files).mount("/uploads", file_server))
+        Ok(rocket.manage(files).mount("/uploads", routes![uploads]))
     }
 
     /// Handle using a temp dir for tests
     #[cfg(test)]
     async fn on_ignite(&self, rocket: Rocket<Build>) -> fairing::Result {
         let dir = tempfile::tempdir().unwrap();
 
-        let file_server = FileServer::from(dir.path());
         let files = Files { upload_dir: dir };
-        Ok(rocket.manage(files).mount("/uploads", file_server))
+        Ok(rocket.manage(files).mount("/uploads", routes![uploads]))
     }
 }
 
@@ -127,3 +126,14 @@ impl Files {
         self.upload_dir.path()
     }
 }
+
+#[get("/<path..>")]
+async fn uploads(path: PathBuf, files_config: &State<Files>) -> Option<CachedFile<'static>> {
+    let path = files_config.get_path().join(&path);
+    // Setting etag to filename as it is set to a hash of the contents on file upload.
+    let etag = EntityTag::with_string(false, path.file_stem()?.to_str()?.to_owned()).ok()?;
+
+    CachedFile::open(path, etag, chrono::Duration::weeks(1))
+        .await
+        .ok()
+}

crates/backend/src/files.rs

@@ -16,6 +16,7 @@ use sea_orm_rocket::Database;
 extern crate rocket;
 
 mod auth;
+mod cached_file;
 mod error;
 mod files;
 mod guards;