spin_trigger_http/
outbound_http.rs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
use std::{
    net::{IpAddr, Ipv4Addr, SocketAddr},
    sync::Arc,
};

use http::uri::Scheme;
use spin_core::async_trait;
use spin_factor_outbound_http::intercept::{self, InterceptOutcome, InterceptRequest};
use spin_factor_outbound_networking::parse_service_chaining_target;
use spin_factors::RuntimeFactors;
use spin_http::routes::RouteMatch;
use wasmtime_wasi_http::{HttpError, HttpResult};

use crate::HttpServer;

/// An outbound HTTP interceptor that handles service chaining requests.
pub struct OutboundHttpInterceptor<F: RuntimeFactors> {
    server: Arc<HttpServer<F>>,
}

impl<F: RuntimeFactors> OutboundHttpInterceptor<F> {
    pub fn new(server: Arc<HttpServer<F>>) -> Self {
        Self { server }
    }
}

const CHAINED_CLIENT_ADDR: SocketAddr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)), 0);

#[async_trait]
impl<F: RuntimeFactors> intercept::OutboundHttpInterceptor for OutboundHttpInterceptor<F> {
    async fn intercept(&self, request: InterceptRequest) -> HttpResult<InterceptOutcome> {
        // Handle service chaining requests
        if let Some(component_id) = parse_service_chaining_target(request.uri()) {
            let req = request.into_hyper_request();
            let route_match = RouteMatch::synthetic(&component_id, req.uri().path());
            let resp = self
                .server
                .handle_trigger_route(req, route_match, Scheme::HTTP, CHAINED_CLIENT_ADDR)
                .await
                .map_err(HttpError::trap)?;
            Ok(InterceptOutcome::Complete(resp))
        } else {
            Ok(InterceptOutcome::Continue(request))
        }
    }
}