Allow serving the sparse index directly from the database

Only used for local development and test environments.

Author: arlosi

src/controllers/krate/metadata.rs

@@ -7,6 +7,8 @@
 use std::cmp::Reverse;
 use std::str::FromStr;
 
+use conduit::{Body, Response};
+
 use crate::controllers::frontend_prelude::*;
 use crate::controllers::helpers::pagination::PaginationOptions;
 
@@ -15,6 +17,7 @@ use crate::models::{
     TopVersions, User, Version, VersionOwnerAction,
 };
 use crate::schema::*;
+use crate::util::errors::not_found;
 use crate::views::{
     EncodableCategory, EncodableCrate, EncodableDependency, EncodableKeyword, EncodableVersion,
 };
@@ -396,3 +399,60 @@ pub fn reverse_dependencies(req: &mut dyn RequestExt) -> EndpointResult {
         "meta": { "total": total },
     })))
 }
+
+/// Generate the sparse registry config.json file
+pub fn config_json(req: &mut dyn RequestExt) -> EndpointResult {
+    let headers = req.headers();
+    let proto = headers
+        .get("X-Forwarded-Proto")
+        .and_then(|v| v.to_str().ok())
+        .unwrap_or_else(|| {
+            if req.app().config.env() == crate::Env::Development {
+                "http"
+            } else {
+                "https"
+            }
+        });
+    let domain_name = headers
+        .get("X-Forwarded-Host")
+        .or_else(|| headers.get(http::header::HOST))
+        .and_then(|v| v.to_str().ok())
+        .unwrap_or_else(|| &req.app().config.domain_name);
+
+    let dl = format!("{proto}://{domain_name}/api/v1/crates");
+    let api = format!("{proto}://{domain_name}/");
+
+    #[derive(Serialize)]
+    struct R {
+        dl: String,
+        api: String,
+    }
+    Ok(req.json(&R { dl, api }))
+}
+
+/// Generate a sparse registry index file
+pub fn versions_registry(req: &mut dyn RequestExt) -> EndpointResult {
+    let crate_name = &req.params()["crate_id"];
+
+    let x1 = req.params()["x1"].as_str();
+    let x2 = req.params().find("x2");
+    if (x1, x2)
+        != match crate_name.len() {
+            1 => ("1", None),
+            2 => ("2", None),
+            3 => ("3", Some(&crate_name[0..1])),
+            _ => (&crate_name[0..2], Some(&crate_name[2..4])),
+        }
+    {
+        return Err(not_found());
+    }
+
+    let conn = req.db_read()?;
+    let krate: Crate = Crate::by_name(crate_name).first(&*conn)?;
+    let body = krate.index_metadata(&*conn)?;
+
+    Ok(Response::builder()
+        .header(header::CONTENT_TYPE, "text/plain; charset=utf-8")
+        .body(Body::from_vec(body))
+        .unwrap()) // Header values are well formed, so should not panic
+}

src/router.rs

@@ -167,6 +167,22 @@ pub fn build_router(app: &App) -> RouteBuilder {
         router.post("/git/index/*path", R(s));
     }
 
+    if app.config.env() != Env::Production {
+        // Serve the sparse index. In production this is served from S3.
+        router.get(
+            "/api/private/index/:x1/:x2/:crate_id",
+            C(krate::metadata::versions_registry),
+        );
+        router.get(
+            "/api/private/index/:x1/:crate_id",
+            C(krate::metadata::versions_registry),
+        );
+        router.get(
+            "/api/private/index/config.json",
+            C(krate::metadata::config_json),
+        );
+    }
+
     router
 }