use typed header to generate canonical-link-header, use for binary source files

Author: syphar

Cargo.lock

@@ -91,7 +91,7 @@ iron = "0.6"
 router = "0.6"
 
 # axum dependencies
-axum = "0.6.1"
+axum = { version = "0.6.1", features = ["headers"]}
 axum-extra = "0.4.2"
 hyper = { version = "0.14.15", default-features = false }
 tower = "0.4.11"

Cargo.toml

@@ -0,0 +1,44 @@
+use axum::{
+    headers::{Header, HeaderName, HeaderValue},
+    http::uri::Uri,
+};
+
+/// simplified typed header for a `Link rel=canonical` header in the response.
+pub struct CanonicalUrl(pub Uri);
+
+impl Header for CanonicalUrl {
+    fn name() -> &'static HeaderName {
+        &http::header::LINK
+    }
+
+    fn decode<'i, I>(_values: &mut I) -> Result<Self, axum::headers::Error>
+    where
+        I: Iterator<Item = &'i HeaderValue>,
+    {
+        unimplemented!();
+    }
+
+    fn encode<E>(&self, values: &mut E)
+    where
+        E: Extend<HeaderValue>,
+    {
+        let value: HeaderValue = format!(r#"<{}>; rel="canonical""#, self.0).parse().unwrap();
+
+        values.extend(std::iter::once(value));
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use axum::headers::HeaderMapExt;
+    use axum::http::HeaderMap;
+
+    #[test]
+    fn test_encode_canonical() {
+        let mut map = HeaderMap::new();
+        map.typed_insert(CanonicalUrl("http://something/".parse().unwrap()));
+        assert_eq!(map["link"], "<http://something/>; rel=\"canonical\"");
+    }
+}

src/web/headers.rs

@@ -81,6 +81,7 @@ pub(crate) mod error;
 mod extensions;
 mod features;
 mod file;
+mod headers;
 mod highlight;
 mod markdown;
 pub(crate) mod metrics;

src/web/mod.rs

@@ -133,9 +133,12 @@ macro_rules! impl_axum_webpage {
                         (canonical_url)(&self)
                     };
                     if let Some(canonical_url) = canonical_url {
-                        response.headers_mut().insert(
-                            axum::http::header::LINK,
-                            format!(r#"<{}>; rel="canonical"#, canonical_url).parse().unwrap(),
+                        use axum::headers::HeaderMapExt;
+
+                        response.headers_mut().typed_insert(
+                            $crate::web::headers::CanonicalUrl(
+                                canonical_url.parse().expect("invalid URL for canonical link")
+                            ),
                         );
                     }
                 )?

src/web/page/web_page.rs

@@ -3,11 +3,15 @@ use crate::{
     db::Pool,
     impl_axum_webpage,
     utils::{get_correct_docsrs_style_file, spawn_blocking},
-    web::{cache::CachePolicy, error::AxumNope, file::File as DbFile, MatchSemver, MetaData},
+    web::{
+        cache::CachePolicy, error::AxumNope, file::File as DbFile, headers::CanonicalUrl,
+        MatchSemver, MetaData,
+    },
     Storage,
 };
-use anyhow::Result;
-use axum::{extract::Path, response::IntoResponse, Extension};
+use anyhow::{Context as _, Result};
+use axum::{extract::Path, headers::HeaderMapExt, response::IntoResponse, Extension};
+
 use postgres::Client;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
@@ -249,11 +253,20 @@ pub(crate) async fn source_browser_handler(
     })
     .await?;
 
+    let canonical_url = format!("https://docs.rs/crate/{}/latest/source/{}", name, path);
+
     let (file, file_content) = if let Some(blob) = blob {
         let is_text = blob.mime.starts_with("text") || blob.mime == "application/json";
         // serve the file with DatabaseFileHandler if file isn't text and not empty
         if !is_text && !blob.is_empty() {
-            return Ok(DbFile(blob).into_response());
+            let mut response = DbFile(blob).into_response();
+            response.headers_mut().typed_insert(CanonicalUrl(
+                canonical_url.parse().context("invalid canonical url")?,
+            ));
+            response
+                .extensions_mut()
+                .insert(CachePolicy::ForeverInCdnAndStaleInBrowser);
+            return Ok(response);
         } else if is_text && !blob.is_empty() {
             let path = blob
                 .path
@@ -299,7 +312,7 @@ pub(crate) async fn source_browser_handler(
         show_parent_link: !current_folder.is_empty(),
         file,
         file_content,
-        canonical_url: format!("https://docs.rs/crate/{}/latest/source/{}", name, path),
+        canonical_url,
         is_latest_url,
     }
     .into_response())
@@ -346,6 +359,47 @@ mod tests {
                 .get("/crate/fake/0.1.0/source/some_filename.rs")
                 .send()?;
             assert!(response.status().is_success());
+            assert_eq!(
+                response.headers().get("link").unwrap(),
+                "<https://docs.rs/crate/fake/latest/source/some_filename.rs>; rel=\"canonical\""
+            );
+            assert_cache_control(
+                &response,
+                CachePolicy::ForeverInCdnAndStaleInBrowser,
+                &env.config(),
+            );
+            assert!(response.text()?.contains("some_random_content"));
+            Ok(())
+        });
+    }
+
+    #[test_case(true)]
+    #[test_case(false)]
+    fn fetch_binary(archive_storage: bool) {
+        wrapper(|env| {
+            env.fake_release()
+                .archive_storage(archive_storage)
+                .name("fake")
+                .version("0.1.0")
+                .source_file("some_file.pdf", b"some_random_content")
+                .create()?;
+            let web = env.frontend();
+            let response = web.get("/crate/fake/0.1.0/source/some_file.pdf").send()?;
+            assert!(response.status().is_success());
+            assert_eq!(
+                response.headers().get("link").unwrap(),
+                "<https://docs.rs/crate/fake/latest/source/some_file.pdf>; rel=\"canonical\""
+            );
+            assert_eq!(
+                response
+                    .headers()
+                    .get("content-type")
+                    .unwrap()
+                    .to_str()
+                    .unwrap(),
+                "application/pdf"
+            );
+
             assert_cache_control(
                 &response,
                 CachePolicy::ForeverInCdnAndStaleInBrowser,