serve: try the upstream ab-cdn before the JIT build lanes (#22)

Author: dalkia

crate/src/abcdn/config.rs

@@ -24,6 +24,8 @@ pub struct Config {
     pub jit_content_digest: bool,
 
     pub upstream_ab_cdn: Option<String>,
+
+    pub upstream_ab_registry: Option<String>,
 }
 
 impl Config {
@@ -40,6 +42,11 @@ impl Config {
                 "http://127.0.0.1:5141/content".to_string()
             });
 
+        let upstream_ab_cdn = env::var("ABGEN_UPSTREAM_AB_CDN")
+            .ok()
+            .map(|s| s.trim().trim_end_matches('/').to_string())
+            .filter(|s| !s.is_empty());
+
         // A loopback content server is a dev preview server (sdk-commands): its
         // declared hashes are path-based and never change on edit, so content
         // revalidation defaults to ON there. Explicit env always wins.
@@ -77,13 +84,32 @@ impl Config {
                 .filter(|s| !s.is_empty()),
             content_database_url: content_connection_string(),
             jit_content_digest,
-            upstream_ab_cdn: env::var("ABGEN_UPSTREAM_AB_CDN")
+            upstream_ab_cdn: upstream_ab_cdn.clone(),
+            upstream_ab_registry: match env::var("ABGEN_UPSTREAM_AB_REGISTRY")
                 .ok()
                 .map(|s| s.trim().trim_end_matches('/').to_string())
-                .filter(|s| !s.is_empty()),
+            {
+                Some(s) if s.eq_ignore_ascii_case("off") => None,
+                Some(s) if !s.is_empty() => Some(s),
+                // Registry answers must name the versions the CDN actually
+                // serves, so the default pairs with the upstream CDN.
+                _ => upstream_ab_cdn.as_deref().and_then(registry_for_ab_cdn),
+            },
         })
     }
 }
+
+fn registry_for_ab_cdn(cdn: &str) -> Option<String> {
+    match cdn {
+        "https://ab-cdn.decentraland.org" => {
+            Some("https://asset-bundle-registry.decentraland.org".to_string())
+        }
+        "https://ab-cdn.decentraland.zone" => {
+            Some("https://asset-bundle-registry.decentraland.zone".to_string())
+        }
+        _ => None,
+    }
+}
 fn content_connection_string() -> Option<String> {
     if let Ok(url) = env::var("CONTENT_PG_CONNECTION_STRING") {
         if !url.trim().is_empty() {

crate/src/abcdn/handlers/dispatch.rs

@@ -8,11 +8,7 @@ pub async fn dispatch(
 ) -> Response {
     let path = uri.path().trim_start_matches('/').to_string();
     revalidate_if_stale(&state, &path).await;
-    let resp = dispatch_with_fallbacks(&state, &path, &method, &headers).await;
-    if resp.status() == StatusCode::NOT_FOUND && state.upstream_ab_cdn.is_some() {
-        return upstream_fallback(&state, &path, &method, &headers, resp).await;
-    }
-    resp
+    dispatch_with_fallbacks(&state, &path, &method, &headers).await
 }
 
 async fn dispatch_with_fallbacks(
@@ -22,30 +18,48 @@ async fn dispatch_with_fallbacks(
     headers: &HeaderMap,
 ) -> Response {
     let local = dispatch_local(state, path, method, headers).await;
+    if local.status() != StatusCode::NOT_FOUND {
+        return local;
+    }
 
-    if local.status() == StatusCode::NOT_FOUND {
-        if let Some(target) = resolver::shader_target(path) {
-            return shader_fallback(state, path, &target, method, headers, local).await;
-        }
-        if let Some(proxy) = state.live_proxy.clone() {
-            if let Some(target) = jit_target(path) {
-                return bundle_fallback(state, proxy, path, &target, method, headers, local).await;
-            }
-            if br_bundle_target(path) {
-                return with_reason(local, "br-not-built");
-            }
-        }
-        if path.split('/').next() == Some("LOD") {
-            return lod_fallback(state, path, method, headers, local).await;
+    if let Some(target) = resolver::shader_target(path) {
+        return shader_fallback(state, path, &target, method, headers, local).await;
+    }
+
+    // Upstream before any build lane: when a production ab-cdn is configured,
+    // entities it already serves (wearables, emotes, remote scenes) should
+    // stream from it rather than be probed with a local JIT build — against a
+    // preview content server that build can only fail its entity resolve and
+    // log a write-back warning per entity. Local-corpus ids (b64-) and
+    // upstream misses fall through to the build lanes as before.
+    let local = if state.upstream_ab_cdn.is_some() {
+        let up = upstream_fallback(state, path, method, headers, local).await;
+        if up.status() != StatusCode::NOT_FOUND {
+            return up;
         }
-        let segs: Vec<&str> = path.split('/').collect();
-        if segs.len() == 3 && segs[0] == "lods-unity" && segs[1] == "manifests" {
-            return iss_fallback(state, path, method, headers, local).await;
+        up
+    } else {
+        local
+    };
+
+    if let Some(proxy) = state.live_proxy.clone() {
+        if let Some(target) = jit_target(path) {
+            return bundle_fallback(state, proxy, path, &target, method, headers, local).await;
         }
-        if let Some((bare, platform)) = flat_target(path) {
-            return flat_fallback(state, path, &bare, &platform, method, headers, local).await;
+        if br_bundle_target(path) {
+            return with_reason(local, "br-not-built");
         }
     }
+    if path.split('/').next() == Some("LOD") {
+        return lod_fallback(state, path, method, headers, local).await;
+    }
+    let segs: Vec<&str> = path.split('/').collect();
+    if segs.len() == 3 && segs[0] == "lods-unity" && segs[1] == "manifests" {
+        return iss_fallback(state, path, method, headers, local).await;
+    }
+    if let Some((bare, platform)) = flat_target(path) {
+        return flat_fallback(state, path, &bare, &platform, method, headers, local).await;
+    }
     local
 }