Use moka to cache rendered html in middleware::ember_html::serve_html

Author: hdoordt

Cargo.lock

@@ -94,6 +94,7 @@ krata-tokio-tar = "=0.4.2"
 lettre = { version = "=0.11.11", default-features = false, features = ["file-transport", "smtp-transport", "hostname", "builder", "tokio1", "tokio1-native-tls"] }
 minijinja = { version = "=2.6.0", features = ["loader"] }
 mockall = "=0.13.1"
+moka = { version = "=0.12.10", default-features = false, features = ["future"] }
 native-tls = "=0.2.13"
 oauth2 = "=5.0.0"
 object_store = { version = "=0.11.2", features = ["aws"] }

Cargo.toml

@@ -84,6 +84,11 @@ pub struct Server {
     /// [`Self::index_html_template_path`] is set.
     pub og_image_base_url: Option<Url>,
 
+    /// Maximum number of items that the HTML render
+    /// cache in [`crate::middleware::ember_html::serve_html`]
+    /// can hold. Defaults to 1024.
+    pub html_render_cache_max_capacity: u64,
+
     pub content_security_policy: Option<HeaderValue>,
 }
 
@@ -234,6 +239,7 @@ impl Server {
             serve_dist: true,
             index_html_template_path,
             og_image_base_url,
+            html_render_cache_max_capacity: var_parsed("HTML_RENDER_CACHE_CAP")?.unwrap_or(1024),
             content_security_policy: Some(content_security_policy.parse()?),
         })
     }

src/config/server.rs

@@ -26,6 +26,7 @@ const INDEX_TEMPLATE_NAME: &str = "index_html";
 const PATH_PREFIX_CRATES: &str = "/crates/";
 
 type TemplateEnvFut = Shared<BoxFuture<'static, minijinja::Environment<'static>>>;
+type TemplateCache = moka::future::Cache<Cow<'static, str>, String>;
 
 /// Initialize [`minijinja::Environment`] given the path to the index.html file. This should
 /// only be done once as it will load said file from persistent storage.
@@ -42,8 +43,16 @@ async fn init_template_env(
     env
 }
 
+/// Initialize the [`moka::future::Cache`] used to cache the rendered HTML.
+fn init_html_cache(max_capacity: u64) -> TemplateCache {
+    moka::future::CacheBuilder::new(max_capacity)
+        .name("rendered_index_html")
+        .build()
+}
+
 pub async fn serve_html(state: AppState, request: Request, next: Next) -> Response {
     static TEMPLATE_ENV: OnceLock<TemplateEnvFut> = OnceLock::new();
+    static RENDERED_HTML_CACHE: OnceLock<TemplateCache> = OnceLock::new();
 
     let path = &request.uri().path();
     // The "/git/" prefix is only used in development (when within a docker container)
@@ -64,8 +73,7 @@ pub async fn serve_html(state: AppState, request: Request, next: Next) -> Respon
         // Come up with an Open Graph image URL. In case a crate page is requested,
         // we use the crate's name and the OG image base URL from config to
         // generate one, otherwise we use the fallback image.
-
-        let og_image_url: Cow<'_, _> = 'og: {
+        let og_image_url = 'og: {
             if let Some(suffix) = path.strip_prefix(PATH_PREFIX_CRATES) {
                 let len = suffix.find('/').unwrap_or(suffix.len());
                 let krate = &suffix[..len];
@@ -81,26 +89,32 @@ pub async fn serve_html(state: AppState, request: Request, next: Next) -> Respon
             OG_IMAGE_FALLBACK_URL.into()
         };
 
-        // `OnceLock::get_or_init` blocks as long as its intializer is running in another thread.
-        // Note that this won't take long, as the constructed Futures are not awaited
-        // during initialization.
-        let template_env = TEMPLATE_ENV.get_or_init(|| {
-            // At this point we can safely assume `state.config.index_html_template_path` is `Some`,
-            // as this middleware won't be executed otherwise; see `crate::middleware::apply_axum_middleware`.
-            init_template_env(state.config.index_html_template_path.clone().unwrap())
-                .boxed()
-                .shared()
-        });
-
-        // TODO use moka caching here with og_image_url as key and the rendered html as value
-
-        // Render the HTML given the OG image URL
-        let env = template_env.clone().await;
-        let html = env
-            .get_template(INDEX_TEMPLATE_NAME)
-            .unwrap()
-            .render(context! { og_image_url})
-            .expect("Error rendering index");
+        // Fetch the HTML from cache given `og_image_url` as key or render it
+        let html = RENDERED_HTML_CACHE
+            .get_or_init(|| init_html_cache(state.config.html_render_cache_max_capacity))
+            .get_with_by_ref(&og_image_url, async {
+                // `OnceLock::get_or_init` blocks as long as its intializer is running in another thread.
+                // Note that this won't take long, as the constructed Futures are not awaited
+                // during initialization.
+                let template_env = TEMPLATE_ENV.get_or_init(|| {
+                    // At this point we can safely assume `state.config.index_html_template_path` is `Some`,
+                    // as this middleware won't be executed otherwise; see `crate::middleware::apply_axum_middleware`.
+                    init_template_env(state.config.index_html_template_path.clone().unwrap())
+                        .boxed()
+                        .shared()
+                });
+
+                // Render the HTML given the OG image URL
+                let env = template_env.clone().await;
+                let html = env
+                    .get_template(INDEX_TEMPLATE_NAME)
+                    .unwrap()
+                    .render(context! { og_image_url})
+                    .expect("Error rendering index");
+
+                html
+            })
+            .await;
 
         // Serve static Ember page to bootstrap the frontend
         Response::builder()

src/middleware/ember_html.rs

@@ -483,6 +483,7 @@ fn simple_config() -> config::Server {
         serve_dist: false,
         index_html_template_path: None,
         og_image_base_url: None,
+        html_render_cache_max_capacity: 1024,
         content_security_policy: None,
     }
 }