(WIP) rustdoc redirect caching in the CDN

src/config.rs

@@ -46,8 +46,17 @@ pub struct Config {
     // `500` for a ratio of 7249 over 54k crates.
     // For unit-tests the number has to be higher.
     pub(crate) random_crate_search_view_size: u32,
-    // CDN / caching settings
-    pub(crate) cache_rustdoc_redirects: u32,
+
+    // Time to cache crate-level redirects in rustdoc, in seconds.
+    // This is for redirects where the destination
+    // can change after the release of a new version
+    // of a crate.
+    pub(crate) cache_rustdoc_redirects_crate: u32,
+
+    // Time to cache release-level redirects in rustdoc, in seconds.
+    // Here the destination can only change after
+    // rebuilds or yanks, so very infrequently.
+    pub(crate) cache_rustdoc_redirects_version: u32,
 
     // Build params
     pub(crate) build_attempts: u16,
@@ -96,7 +105,11 @@ impl Config {
             registry_gc_interval: env("DOCSRS_REGISTRY_GC_INTERVAL", 60 * 60)?,
 
             random_crate_search_view_size: env("DOCSRS_RANDOM_CRATE_SEARCH_VIEW_SIZE", 500)?,
-            cache_rustdoc_redirects: env("DOCSRS_CACHE_RUSTDOC_REDIRECTS", 30 * 60)?,
+            cache_rustdoc_redirects_crate: env("DOCSRS_CACHE_RUSTDOC_REDIRECTS_CRATE", 15 * 60)?, // 15 minutes
+            cache_rustdoc_redirects_version: env(
+                "DOCSRS_CACHE_RUSTDOC_REDIRECTS_RELEASE",
+                7 * 24 * 60 * 60, // 7 days
+            )?,
 
             rustwide_workspace: env("CRATESFYI_RUSTWIDE_WORKSPACE", PathBuf::from(".workspace"))?,
             inside_docker: env("DOCS_RS_DOCKER", false)?,

src/web/mod.rs

@@ -496,7 +496,7 @@ fn redirect(url: Url) -> Response {
     resp
 }
 
-/// creates a redirect-response which is cached on the CDN level for
+/// Creates a redirect-response which is cached on the CDN level for
 /// the given amount of seconds. Browser-Local caching is deactivated.
 /// The used s-maxage is respected by CloudFront (which we can invalidate
 /// if we need to), and perhaps by other proxies in between.

src/web/rustdoc.rs

@@ -40,7 +40,7 @@ impl iron::Handler for RustLangRedirector {
         let config = extension!(req, Config);
         Ok(super::cached_redirect(
             self.url.clone(),
-            config.cache_rustdoc_redirects,
+            config.cache_rustdoc_redirects_crate,
         ))
     }
 }
@@ -54,6 +54,7 @@ pub fn rustdoc_redirector_handler(req: &mut Request) -> IronResult<Response> {
         vers: &str,
         target: Option<&str>,
         target_name: &str,
+        cache_seconds: u32,
     ) -> IronResult<Response> {
         let mut url_str = if let Some(target) = target {
             format!(
@@ -72,21 +73,25 @@ pub fn rustdoc_redirector_handler(req: &mut Request) -> IronResult<Response> {
             url_str.push_str(query);
         }
         let url = ctry!(req, Url::parse(&url_str));
-        let config = extension!(req, Config);
 
-        Ok(super::cached_redirect(url, config.cache_rustdoc_redirects))
+        Ok(super::cached_redirect(url, cache_seconds))
     }
 
-    fn redirect_to_crate(req: &Request, name: &str, vers: &str) -> IronResult<Response> {
+    fn redirect_to_crate(
+        req: &Request,
+        name: &str,
+        vers: &str,
+        cache_seconds: u32,
+    ) -> IronResult<Response> {
         let url = ctry!(
             req,
             Url::parse(&format!("{}/crate/{}/{}", redirect_base(req), name, vers)),
         );
 
-        let config = extension!(req, Config);
-        Ok(super::cached_redirect(url, config.cache_rustdoc_redirects))
+        Ok(super::cached_redirect(url, cache_seconds))
     }
 
+    let config = extension!(req, Config);
     let metrics = extension!(req, Metrics).clone();
     let mut rendering_time = RenderingTimesRecorder::new(&metrics.rustdoc_redirect_rendering_times);
 
@@ -145,6 +150,13 @@ pub fn rustdoc_redirector_handler(req: &mut Request) -> IronResult<Response> {
     let req_version = router.find("version");
     let mut target = router.find("target");
 
+    // redirects with an existing version in the URL can be cached for longer.
+    let cache_redirect_for = if let Some(_) = req_version {
+        config.cache_rustdoc_redirects_version
+    } else {
+        config.cache_rustdoc_redirects_crate
+    };
+
     // it doesn't matter if the version that was given was exact or not, since we're redirecting
     // anyway
     rendering_time.step("match version");
@@ -179,10 +191,17 @@ pub fn rustdoc_redirector_handler(req: &mut Request) -> IronResult<Response> {
 
     if has_docs {
         rendering_time.step("redirect to doc");
-        redirect_to_doc(req, &crate_name, &version, target, &target_name)
+        redirect_to_doc(
+            req,
+            &crate_name,
+            &version,
+            target,
+            &target_name,
+            cache_redirect_for,
+        )
     } else {
         rendering_time.step("redirect to crate");
-        redirect_to_crate(req, &crate_name, &version)
+        redirect_to_crate(req, &crate_name, &version, cache_redirect_for)
     }
 }
 
@@ -282,7 +301,10 @@ pub fn rustdoc_html_server_handler(req: &mut Request) -> IronResult<Response> {
         );
         let url = ctry!(req, Url::parse(&redirect_path));
 
-        Ok(super::cached_redirect(url, config.cache_rustdoc_redirects))
+        Ok(super::cached_redirect(
+            url,
+            config.cache_rustdoc_redirects_version,
+        ))
     };
 
     rendering_time.step("match version");
@@ -551,7 +573,10 @@ pub fn target_redirect_handler(req: &mut Request) -> IronResult<Response> {
     );
 
     let url = ctry!(req, Url::parse(&url));
-    Ok(super::cached_redirect(url, config.cache_rustdoc_redirects))
+    Ok(super::cached_redirect(
+        url,
+        config.cache_rustdoc_redirects_version,
+    ))
 }
 
 pub fn badge_handler(req: &mut Request) -> IronResult<Response> {