Make location of frontend index.html file constant

Author: hdoordt

.env.sample

@@ -87,14 +87,7 @@ export GH_CLIENT_SECRET=
 # export SENTRY_DSN_API=
 export SENTRY_ENV_API=local
 
-# If set the server serves the frontend `index.html` for all
-# non-API requests using the Jinja template at the given path.
-# Setting this parameter requires setting
-# INDEX_HTML_TEMPLATE_PATH as well.
-export INDEX_HTML_TEMPLATE_PATH=dist/index.html
-
 # Base URL for the service from which the OpenGraph images
-# for crates are loaded. Required if
-# INDEX_HTML_TEMPLATE_PATH is set. Make sure the URL ends
+# for crates are loaded. Make sure the URL ends
 # with a `/`.
 export OG_IMAGE_BASE_URL="http://localhost:3000/og/"

src/config/server.rs

@@ -17,7 +17,6 @@ use http::HeaderValue;
 use std::collections::{HashMap, HashSet};
 use std::convert::Infallible;
 use std::net::IpAddr;
-use std::path::PathBuf;
 use std::str::FromStr;
 use std::time::Duration;
 
@@ -73,15 +72,15 @@ pub struct Server {
     /// Should the server serve the frontend assets in the `dist` directory?
     pub serve_dist: bool,
 
-    /// If set the server serves the frontend `index.html` for all
-    /// non-API requests using the Jinja template at the given path.
+    /// Should the server serve the frontend `index.html` for all
+    /// non-API requests?
     /// Setting this parameter requires setting
     /// [`Self::og_image_base_url`] as well.
-    pub index_html_template_path: Option<PathBuf>,
+    pub serve_html: bool,
 
     /// Base URL for the service from which the OpenGraph images
     /// for crates are loaded. Required if
-    /// [`Self::index_html_template_path`] is set.
+    /// [`Self::serve_html`] is set.
     pub og_image_base_url: Option<Url>,
 
     /// Maximum number of items that the HTML render
@@ -185,14 +184,13 @@ impl Server {
             cdn_domain = storage.cdn_prefix.as_ref().map(|cdn_prefix| format!("https://{cdn_prefix}")).unwrap_or_default()
         );
 
-        let index_html_template_path = var_parsed("INDEX_HTML_TEMPLATE_PATH")?;
-        let og_image_base_url = match index_html_template_path {
-            Some(_) => Some(
+        let serve_html = var_parsed("SERVE_HTML")?.unwrap_or(true);
+        let og_image_base_url = serve_html
+            .then(|| {
                 required_var_parsed("OG_IMAGE_BASE_URL")
-                    .context("OG_IMAGE_BASE_URL must be set when using INDEX_HTML_TEMPLATE_PATH")?,
-            ),
-            None => None,
-        };
+                    .context("OG_IMAGE_BASE_URL must be set when using INDEX_HTML_TEMPLATE_PATH")
+            })
+            .transpose()?;
 
         Ok(Server {
             db: DatabasePools::full_from_environment(&base)?,
@@ -237,7 +235,7 @@ impl Server {
             cargo_compat_status_code_config: var_parsed("CARGO_COMPAT_STATUS_CODES")?
                 .unwrap_or(StatusCodeConfig::AdjustAll),
             serve_dist: true,
-            index_html_template_path,
+            serve_html: true,
             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/middleware.rs

@@ -77,10 +77,9 @@ pub fn apply_axum_middleware(state: AppState, router: Router<()>) -> Router {
         .layer(conditional_layer(config.serve_dist, || {
             from_fn(static_or_continue::serve_dist)
         }))
-        .layer(conditional_layer(
-            config.index_html_template_path.is_some(),
-            || from_fn_with_state(state.clone(), ember_html::serve_html),
-        ))
+        .layer(conditional_layer(config.serve_html, || {
+            from_fn_with_state(state.clone(), ember_html::serve_html)
+        }))
         .layer(AddExtensionLayer::new(state.clone()));
 
     router

src/middleware/ember_html.rs

@@ -9,7 +9,7 @@
 
 use std::borrow::Cow;
 use std::ops::Not;
-use std::sync::{Arc, OnceLock};
+use std::sync::{Arc, LazyLock, OnceLock};
 
 use axum::extract::Request;
 use axum::middleware::Next;
@@ -32,14 +32,12 @@ const PATH_PREFIX_CRATES: &str = "/crates/";
 type TemplateEnvFut = Shared<BoxFuture<'static, Arc<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.
-async fn init_template_env(
-    index_html_template_path: impl AsRef<Path>,
-) -> Arc<minijinja::Environment<'static>> {
-    let template_j2 = tokio::fs::read_to_string(index_html_template_path.as_ref())
+/// Initialize [`minijinja::Environment`] given the index.html file at `dist/index.html`.
+/// This should only be done once as it will load said file from persistent storage.
+async fn init_template_env() -> Arc<minijinja::Environment<'static>> {
+    let template_j2 = tokio::fs::read_to_string("dist/index.html")
         .await
-        .expect("Error loading index.html template. Is the frontend package built yet?");
+        .expect("Error loading dist/index.html template. Is the frontend package built yet?");
 
     let mut env = Environment::empty();
     env.add_template_owned(INDEX_TEMPLATE_NAME, template_j2)
@@ -55,7 +53,8 @@ fn init_html_cache(max_capacity: u64) -> TemplateCache {
 }
 
 pub async fn serve_html(state: AppState, request: Request, next: Next) -> Response {
-    static TEMPLATE_ENV: OnceLock<TemplateEnvFut> = OnceLock::new();
+    static TEMPLATE_ENV: LazyLock<TemplateEnvFut> =
+        LazyLock::new(|| init_template_env().boxed().shared());
     static RENDERED_HTML_CACHE: OnceLock<TemplateCache> = OnceLock::new();
 
     let path = &request.uri().path();
@@ -75,7 +74,7 @@ pub async fn serve_html(state: AppState, request: Request, next: Next) -> Respon
         }
 
         // `state.config.og_image_base_url` will always be `Some` as that's required
-        // if `state.config.index_html_template_path` is `Some`, and otherwise this
+        // if `state.config.serve_html` is `true`, and otherwise this
         // middleware won't be executed; see `crate::middleware::apply_axum_middleware`.
         let og_image_base_url = state.config.og_image_base_url.as_ref().unwrap();
         let og_image_url = generate_og_image_url(path, og_image_base_url);
@@ -84,16 +83,10 @@ pub async fn serve_html(state: AppState, request: Request, next: Next) -> Respon
         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.
+                // `LazyLock::deref` 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()
-                });
+                let template_env = &*TEMPLATE_ENV;
 
                 // Render the HTML given the OG image URL
                 let env = template_env.clone().await;

src/tests/util/test_app.rs

@@ -481,7 +481,7 @@ fn simple_config() -> config::Server {
 
         // The frontend code is not needed for the backend tests.
         serve_dist: false,
-        index_html_template_path: None,
+        serve_html: false,
         og_image_base_url: None,
         html_render_cache_max_capacity: 1024,
         content_security_policy: None,