factors: Refactor OutboundHttpFactor SelfRequestOrigin

Signed-off-by: Lann Martin <[email protected]>

Author: lann

crates/factor-outbound-http/src/lib.rs

@@ -69,6 +69,7 @@ impl Factor for OutboundHttpFactor {
             wasi_http_ctx: WasiHttpCtx::new(),
             allowed_hosts,
             component_tls_configs,
+            self_request_origin: None,
             request_interceptor: None,
         })
     }
@@ -78,10 +79,19 @@ pub struct InstanceState {
     wasi_http_ctx: WasiHttpCtx,
     allowed_hosts: OutboundAllowedHosts,
     component_tls_configs: ComponentTlsConfigs,
+    self_request_origin: Option<SelfRequestOrigin>,
     request_interceptor: Option<Box<dyn OutboundHttpInterceptor>>,
 }
 
 impl InstanceState {
+    /// Sets the [`SelfRequestOrigin`] for this instance.
+    ///
+    /// This is used to handle outbound requests to relative URLs. If unset,
+    /// those requests will fail.
+    pub fn set_self_request_origin(&mut self, origin: SelfRequestOrigin) {
+        self.self_request_origin = Some(origin);
+    }
+
     /// Sets a [`OutboundHttpInterceptor`] for this instance.
     ///
     /// Returns an error if it has already been called for this instance.

crates/factor-outbound-http/src/wasi.rs

@@ -106,6 +106,7 @@ impl<'a> WasiHttpView for WasiHttpImplInner<'a> {
                     request,
                     config,
                     self.state.allowed_hosts.clone(),
+                    self.state.self_request_origin.clone(),
                     tls_client_config,
                 )
                 .in_current_span(),
@@ -118,6 +119,7 @@ async fn send_request_impl(
     mut request: Request<wasmtime_wasi_http::body::HyperOutgoingBody>,
     mut config: wasmtime_wasi_http::types::OutgoingRequestConfig,
     outbound_allowed_hosts: OutboundAllowedHosts,
+    self_request_origin: Option<SelfRequestOrigin>,
     tls_client_config: Arc<ClientConfig>,
 ) -> anyhow::Result<Result<IncomingResponse, ErrorCode>> {
     if request.uri().authority().is_some() {
@@ -137,10 +139,7 @@ async fn send_request_impl(
             return Ok(Err(ErrorCode::HttpRequestDenied));
         }
 
-        let origin = request
-            .extensions()
-            .get::<SelfRequestOrigin>()
-            .cloned()
+        let origin = self_request_origin
             .context("cannot send relative outbound request; no 'origin' set by host")?;
 
         config.use_tls = origin.use_tls();

crates/factor-outbound-http/tests/factor_test.rs

@@ -40,12 +40,11 @@ async fn allowed_host_is_allowed() -> anyhow::Result<()> {
 #[tokio::test]
 async fn self_request_smoke_test() -> anyhow::Result<()> {
     let mut state = test_instance_state("http://self").await?;
-    let mut wasi_http = OutboundHttpFactor::get_wasi_http_impl(&mut state).unwrap();
+    let origin = SelfRequestOrigin::from_uri(&Uri::from_static("http://[100::1]"))?;
+    state.http.set_self_request_origin(origin);
 
-    let mut req = Request::get("/self-request").body(Default::default())?;
-    let origin = Uri::from_static("http://[100::1]");
-    req.extensions_mut()
-        .insert(SelfRequestOrigin::from_uri(&origin).unwrap());
+    let mut wasi_http = OutboundHttpFactor::get_wasi_http_impl(&mut state).unwrap();
+    let req = Request::get("/self-request").body(Default::default())?;
     let mut future_resp = wasi_http.send_request(req, test_request_config())?;
     future_resp.ready().await;
 

crates/trigger-http2/src/outbound_http.rs

@@ -5,7 +5,7 @@ use std::{
 
 use http::uri::Scheme;
 use spin_factor_outbound_http::{
-    HostFutureIncomingResponse, InterceptOutcome, OutgoingRequestConfig, Request, SelfRequestOrigin,
+    HostFutureIncomingResponse, InterceptOutcome, OutgoingRequestConfig, Request,
 };
 use spin_http::routes::RouteMatch;
 use spin_outbound_networking::parse_service_chaining_target;
@@ -16,12 +16,11 @@ use crate::HttpServer;
 /// An outbound HTTP interceptor that handles service chaining requests.
 pub struct OutboundHttpInterceptor {
     server: Arc<HttpServer>,
-    origin: SelfRequestOrigin,
 }
 
 impl OutboundHttpInterceptor {
-    pub fn new(server: Arc<HttpServer>, origin: SelfRequestOrigin) -> Self {
-        Self { server, origin }
+    pub fn new(server: Arc<HttpServer>) -> Self {
+        Self { server }
     }
 }
 
@@ -58,7 +57,6 @@ impl spin_factor_outbound_http::OutboundHttpInterceptor for OutboundHttpIntercep
             let resp = HostFutureIncomingResponse::pending(wasmtime_wasi::runtime::spawn(resp_fut));
             InterceptOutcome::Complete(Ok(resp))
         } else {
-            request.extensions_mut().insert(self.origin.clone());
             InterceptOutcome::Continue
         }
     }

crates/trigger-http2/src/server.rs

@@ -188,11 +188,10 @@ impl HttpServer {
         let mut instance_builder = self.trigger_app.prepare(component_id)?;
 
         // Set up outbound HTTP request origin and service chaining
+        let outbound_http = instance_builder.factor_builders().outbound_http();
         let origin = SelfRequestOrigin::create(server_scheme, &self.listen_addr)?;
-        instance_builder
-            .factor_builders()
-            .outbound_http()
-            .set_request_interceptor(OutboundHttpInterceptor::new(self.clone(), origin))?;
+        outbound_http.set_self_request_origin(origin);
+        outbound_http.set_request_interceptor(OutboundHttpInterceptor::new(self.clone()))?;
 
         // Prepare HTTP executor
         let trigger_config = self.component_trigger_configs.get(component_id).unwrap();