Add PlatformHttpClient and PlatformBackend traits (EdgeZero PR6)

crates/trusted-server-adapter-fastly/src/main.rs

@@ -161,16 +161,20 @@ async fn route_request(
         }
 
         // tsjs endpoints
-        (Method::GET, "/first-party/proxy") => handle_first_party_proxy(settings, req).await,
-        (Method::GET, "/first-party/click") => handle_first_party_click(settings, req).await,
+        (Method::GET, "/first-party/proxy") => {
+            handle_first_party_proxy(settings, runtime_services, req).await
+        }
+        (Method::GET, "/first-party/click") => {
+            handle_first_party_click(settings, runtime_services, req).await
+        }
         (Method::GET, "/first-party/sign") | (Method::POST, "/first-party/sign") => {
-            handle_first_party_proxy_sign(settings, req).await
+            handle_first_party_proxy_sign(settings, runtime_services, req).await
         }
         (Method::POST, "/first-party/proxy-rebuild") => {
-            handle_first_party_proxy_rebuild(settings, req).await
+            handle_first_party_proxy_rebuild(settings, runtime_services, req).await
         }
         (m, path) if integration_registry.has_route(&m, path) => integration_registry
-            .handle_proxy(&m, path, settings, req)
+            .handle_proxy(&m, path, settings, runtime_services, req)
             .await
             .unwrap_or_else(|| {
                 Err(Report::new(TrustedServerError::BadRequest {

crates/trusted-server-adapter-fastly/src/platform.rs

@@ -187,45 +187,147 @@ impl PlatformBackend for FastlyPlatformBackend {
 }
 
 // ---------------------------------------------------------------------------
-// FastlyPlatformHttpClient
+// FastlyPlatformHttpClient — helpers
 // ---------------------------------------------------------------------------
 
-/// Placeholder Fastly implementation of [`PlatformHttpClient`].
+/// Convert a platform-neutral [`edgezero_core::http::Request`] to a [`fastly::Request`].
+///
+/// Only buffered `Body::Once` bodies are supported on this path.
 ///
-/// The Fastly-backed `send` / `send_async` / `select` behavior lands in a
-/// follow-up PR once the orchestrator migration is complete. Until then all
-/// methods return [`PlatformError::Unsupported`].
+/// # Errors
 ///
-/// Implementation lands in #487 (PR 6: Backend + HTTP client traits).
+/// Returns [`PlatformError::HttpClient`] when the request body is streaming.
+fn edge_request_to_fastly(
+    request: edgezero_core::http::Request,
+) -> Result<fastly::Request, Report<PlatformError>> {
+    let (parts, body) = request.into_parts();
+    let mut fastly_req = fastly::Request::new(parts.method, parts.uri.to_string());
+    for (name, value) in parts.headers.iter() {
+        fastly_req.append_header(name.as_str(), value.as_bytes());
+    }
+    match body {
+        edgezero_core::body::Body::Once(bytes) => {
+            if !bytes.is_empty() {
+                fastly_req.set_body(bytes.to_vec());
+            }
+        }
+        edgezero_core::body::Body::Stream(_) => {
+            return Err(Report::new(PlatformError::HttpClient)
+                .attach("streaming request body is not supported by Fastly request conversion"));
+        }
+    }
+    Ok(fastly_req)
+}
+
+/// Convert a [`fastly::Response`] to a [`PlatformResponse`] with the given backend name.
+fn fastly_response_to_platform(
+    mut resp: fastly::Response,
+    backend_name: impl Into<String>,
+) -> Result<PlatformResponse, Report<PlatformError>> {
+    let status = resp.get_status();
+    let mut builder = edgezero_core::http::response_builder().status(status);
+    for (name, value) in resp.get_headers() {
+        builder = builder.header(name.as_str(), value.as_bytes());
+    }
+    let body_bytes = resp.take_body_bytes();
+    let edge_response = builder
+        .body(edgezero_core::body::Body::from(body_bytes))
+        .change_context(PlatformError::HttpClient)?;
+    Ok(PlatformResponse::new(edge_response).with_backend_name(backend_name))
+}
+
+// ---------------------------------------------------------------------------
+// FastlyPlatformHttpClient
+// ---------------------------------------------------------------------------
+
+/// Fastly implementation of [`PlatformHttpClient`].
+///
+/// - [`send`](PlatformHttpClient::send) — converts the platform request to a
+///   `fastly::Request`, calls `.send()`, and wraps the response.
+/// - [`send_async`](PlatformHttpClient::send_async) — same conversion but
+///   calls `.send_async()` and wraps the `fastly::PendingRequest`.
+/// - [`select`](PlatformHttpClient::select) — downcasts each
+///   [`PlatformPendingRequest`] back to `fastly::PendingRequest` and calls
+///   `fastly::http::request::select()`.
 pub struct FastlyPlatformHttpClient;
 
 #[async_trait::async_trait(?Send)]
 impl PlatformHttpClient for FastlyPlatformHttpClient {
     async fn send(
         &self,
-        _request: PlatformHttpRequest,
+        request: PlatformHttpRequest,
     ) -> Result<PlatformResponse, Report<PlatformError>> {
-        log::warn!("FastlyPlatformHttpClient::send called before #487 lands");
-        Err(Report::new(PlatformError::Unsupported)
-            .attach("FastlyPlatformHttpClient::send is not yet implemented"))
+        let backend_name = request.backend_name.clone();
+        let fastly_req = edge_request_to_fastly(request.request)?;
+        let fastly_resp = fastly_req
+            .send(&backend_name)
+            .change_context(PlatformError::HttpClient)?;
+        fastly_response_to_platform(fastly_resp, backend_name)
     }
 
     async fn send_async(
         &self,
-        _request: PlatformHttpRequest,
+        request: PlatformHttpRequest,
     ) -> Result<PlatformPendingRequest, Report<PlatformError>> {
-        log::warn!("FastlyPlatformHttpClient::send_async called before #487 lands");
-        Err(Report::new(PlatformError::Unsupported)
-            .attach("FastlyPlatformHttpClient::send_async is not yet implemented"))
+        let backend_name = request.backend_name.clone();
+        let fastly_req = edge_request_to_fastly(request.request)?;
+        let pending = fastly_req
+            .send_async(&backend_name)
+            .change_context(PlatformError::HttpClient)?;
+        Ok(PlatformPendingRequest::new(pending).with_backend_name(backend_name))
     }
 
     async fn select(
         &self,
-        _pending_requests: Vec<PlatformPendingRequest>,
+        pending_requests: Vec<PlatformPendingRequest>,
     ) -> Result<PlatformSelectResult, Report<PlatformError>> {
-        log::warn!("FastlyPlatformHttpClient::select called before #487 lands");
-        Err(Report::new(PlatformError::Unsupported)
-            .attach("FastlyPlatformHttpClient::select is not yet implemented"))
+        use fastly::http::request::{select, PendingRequest};
+
+        if pending_requests.is_empty() {
+            return Err(Report::new(PlatformError::HttpClient)
+                .attach("select called with an empty pending_requests list"));
+        }
+
+        let mut fastly_pending: Vec<PendingRequest> = Vec::with_capacity(pending_requests.len());
+
+        for platform_req in pending_requests {
+            let inner = platform_req.downcast::<PendingRequest>().map_err(|platform_req| {
+                let backend_name = platform_req.backend_name().unwrap_or("<unknown>");
+                Report::new(PlatformError::HttpClient).attach(format!(
+                    "PlatformPendingRequest inner type is not fastly::PendingRequest for backend '{backend_name}'"
+                ))
+            })?;
+            fastly_pending.push(inner);
+        }
+
+        let (result, remaining_fastly) = select(fastly_pending);
+
+        // Fastly's select() does not preserve input order for remaining requests,
+        // so positional backend-name re-association is unreliable. Backend names
+        // are re-derived from get_backend_name() when each remaining request completes.
+        let remaining: Vec<PlatformPendingRequest> = remaining_fastly
+            .into_iter()
+            .map(PlatformPendingRequest::new)
+            .collect();
+
+        let ready = match result {
+            Ok(fastly_resp) => {
+                let backend_name = fastly_resp
+                    .get_backend_name()
+                    .unwrap_or_else(|| {
+                        log::warn!("select: response has no backend name, correlation will fail");
+                        ""
+                    })
+                    .to_string();
+                fastly_response_to_platform(fastly_resp, backend_name)
+            }
+            Err(e) => {
+                Err(Report::new(PlatformError::HttpClient)
+                    .attach(format!("fastly select error: {e}")))
+            }
+        };
+
+        Ok(PlatformSelectResult { ready, remaining })
     }
 }
 
@@ -296,9 +398,12 @@ pub fn open_kv_store(store_name: &str) -> Result<Arc<dyn PlatformKvStore>, KvErr
 
 #[cfg(test)]
 mod tests {
+    use std::io;
     use std::sync::Arc;
     use std::time::Duration;
 
+    use edgezero_core::body::Body;
+    use edgezero_core::http::request_builder;
     use edgezero_core::key_value_store::NoopKvStore;
 
     use super::*;
@@ -417,4 +522,132 @@ mod tests {
             "should preserve client_ip through clone"
         );
     }
+
+    // --- FastlyPlatformHttpClient -------------------------------------------
+
+    #[test]
+    fn fastly_platform_http_client_send_returns_error_for_unregistered_backend() {
+        let client = FastlyPlatformHttpClient;
+        let request = request_builder()
+            .method("GET")
+            .uri("https://example.com/")
+            .body(Body::empty())
+            .expect("should build test request");
+        let err = futures::executor::block_on(
+            client.send(PlatformHttpRequest::new(request, "nonexistent-backend")),
+        )
+        .expect_err("should return error for unregistered backend");
+
+        assert!(
+            matches!(err.current_context(), &PlatformError::HttpClient),
+            "should be HttpClient error, got: {:?}",
+            err.current_context()
+        );
+    }
+
+    #[test]
+    fn fastly_platform_http_client_send_async_returns_error_for_unregistered_backend() {
+        let client = FastlyPlatformHttpClient;
+        let request = request_builder()
+            .method("GET")
+            .uri("https://example.com/")
+            .body(Body::empty())
+            .expect("should build test request");
+        let err = futures::executor::block_on(
+            client.send_async(PlatformHttpRequest::new(request, "nonexistent-backend")),
+        )
+        .expect_err("should return error for unregistered backend");
+
+        assert!(
+            matches!(err.current_context(), &PlatformError::HttpClient),
+            "should be HttpClient error, got: {:?}",
+            err.current_context()
+        );
+    }
+
+    #[test]
+    fn fastly_platform_http_client_select_returns_error_for_empty_list() {
+        let client = FastlyPlatformHttpClient;
+        let err = futures::executor::block_on(client.select(vec![]))
+            .expect_err("should return error for empty pending list");
+
+        assert!(
+            matches!(err.current_context(), &PlatformError::HttpClient),
+            "should be HttpClient error, got: {:?}",
+            err.current_context()
+        );
+    }
+
+    #[test]
+    fn fastly_platform_http_client_select_returns_error_for_wrong_inner_type() {
+        let client = FastlyPlatformHttpClient;
+        // Wrap a non-PendingRequest type to trigger the downcast failure.
+        let wrong = PlatformPendingRequest::new(42u32).with_backend_name("origin-a");
+        let err = futures::executor::block_on(client.select(vec![wrong]))
+            .expect_err("should return error for wrong inner type");
+
+        assert!(
+            matches!(err.current_context(), &PlatformError::HttpClient),
+            "should be HttpClient error, got: {:?}",
+            err.current_context()
+        );
+        assert!(
+            format!("{err:?}").contains("origin-a"),
+            "should include backend name in error report: {err:?}"
+        );
+    }
+
+    #[test]
+    fn fastly_platform_http_client_send_returns_error_for_streaming_body() {
+        let client = FastlyPlatformHttpClient;
+        let request = request_builder()
+            .method("POST")
+            .uri("https://example.com/")
+            .body(Body::from_stream(futures::stream::empty::<
+                Result<_, io::Error>,
+            >()))
+            .expect("should build streaming test request");
+
+        let err = futures::executor::block_on(
+            client.send(PlatformHttpRequest::new(request, "nonexistent-backend")),
+        )
+        .expect_err("should reject streaming request bodies before sending");
+
+        assert!(
+            matches!(err.current_context(), &PlatformError::HttpClient),
+            "should be HttpClient error, got: {:?}",
+            err.current_context()
+        );
+        assert!(
+            format!("{err:?}").contains("streaming request body"),
+            "should describe the unsupported streaming body: {err:?}"
+        );
+    }
+
+    #[test]
+    fn fastly_platform_http_client_send_async_returns_error_for_streaming_body() {
+        let client = FastlyPlatformHttpClient;
+        let request = request_builder()
+            .method("POST")
+            .uri("https://example.com/")
+            .body(Body::from_stream(futures::stream::empty::<
+                Result<_, io::Error>,
+            >()))
+            .expect("should build streaming test request");
+
+        let err = futures::executor::block_on(
+            client.send_async(PlatformHttpRequest::new(request, "nonexistent-backend")),
+        )
+        .expect_err("should reject streaming request bodies before launching async send");
+
+        assert!(
+            matches!(err.current_context(), &PlatformError::HttpClient),
+            "should be HttpClient error, got: {:?}",
+            err.current_context()
+        );
+        assert!(
+            format!("{err:?}").contains("streaming request body"),
+            "should describe the unsupported streaming body: {err:?}"
+        );
+    }
 }

crates/trusted-server-core/src/auction/endpoints.rs

@@ -85,7 +85,7 @@ pub async fn handle_auction(
 
     // Run the auction
     let result = orchestrator
-        .run_auction(&auction_request, &context)
+        .run_auction(&auction_request, &context, runtime_services)
         .await
         .change_context(TrustedServerError::Auction {
             message: "Auction orchestration failed".to_string(),