tower 互操作与可信代理

fn handle<'cx>(&'cx self, cx: &'cx Cx, body: Body) -> RouteFuture<'cx> {
    let service = self.service.clone();
    Box::pin(async move {
        // Reassemble the http request the service consumes from a copy of
        // the parts on the context; the originals stay available to outer
        // layers and error rendering.
        let request = Request::from_parts(parts(cx).clone(), body);
        match service.oneshot(request).await {
            Ok(response) => Ok(response.map(Body::new)),
            Err(error) => Err(TowerServiceError(error.into()).into()),
        }
    })
}

topcoat = { version = "=0.10.0", features = ["full"] }
tokio = { version = "=1.54.1", features = ["full"] }
axum = { version = "=0.8.9", default-features = false, features = ["tokio", "http1"] }
tower = { version = "=0.5.3", features = ["timeout", "util"] }

let legacy = axum::Router::new()
  .route("/users/{id}", axum::routing::get(|uri: axum::http::Uri| async move { format!("axum saw {uri}\n") }));
// ...
let router = module_router!()
  .route(TowerRoute::any("/legacy/{*rest}", legacy))
  .layer(StripPrefixLayer::new("/legacy"))
  .layer(TowerLayer::new(TimeoutLayer::new(Duration::from_millis(100))).at("/api"))
  .trusted_proxies(proxies)
  .build();

### curl http://127.0.0.1:38105/legacy/users/7?page=2
HTTP/1.1 200 OK
content-type: text/plain; charset=utf-8
content-length: 25

axum saw /users/7?page=2

pub fn new<L>(layer: L) -> Self
where
    L: tower::Layer<TowerNext, Service = S>,
{
    Self {
        path: None,
        service: layer.layer(TowerNext::new()),
    }
}

let mut request = Request::from_parts(parts, body);
let (relay, mut chain_calls) = relay_channel();
request.extensions_mut().insert(relay);

let mut middleware = pin!(service.oneshot(request));

// Drive the middleware until it either responds on its own or
// calls through to the wrapped chain.
let (request, respond_to) = tokio::select! {
    result = &mut middleware => return finish(result),
    called = chain_calls.recv() => match called {
        Some(call) => call,
        // The middleware dropped the request without calling the
        // chain; it produces a response on its own.
        None => return finish(middleware.await),
    },
};

### curl http://127.0.0.1:38105/api/fast
HTTP/1.1 200 OK
content-type: text/plain; charset=utf-8
content-length: 5

fast

### curl http://127.0.0.1:38105/api/slow
HTTP/1.1 500 Internal Server Error
content-type: text/plain; charset=utf-8
content-length: 21

internal server error

fn call(&mut self, request: Request<B>) -> Self::Future {
    let router = Arc::clone(&self.router);
    Box::pin(async move { Ok(router.handle(request.map(Body::new)).await) })
}

let topcoat_router = module_router!().discover().build();
let app = axum::Router::new()
  .route("/api/health", axum::routing::get(|| async { "axum: ok\n" }))
  .fallback_service(TowerService::new(topcoat_router));
let listener = tokio::net::TcpListener::bind("127.0.0.1:38106").await?;
axum::serve(listener, app).await

### GET /api/health
HTTP/1.1 200 OK
content-type: text/plain; charset=utf-8
content-length: 9

axum: ok

### GET /hello
HTTP/1.1 200 OK
content-type: text/plain; charset=utf-8
content-length: 15

topcoat: hello

### GET /nope
HTTP/1.1 404 Not Found
content-type: text/plain; charset=utf-8
content-length: 9

not found

fn walk(
    &self,
    remote: Option<IpAddr>,
    addresses: impl Iterator<Item = Option<IpAddr>>,
) -> Option<IpAddr> {
    let mut farthest = remote;
    for (hop, address) in addresses.enumerate() {
        let hop = hop + 1;
        // A hop trusted by position needs no readable address; any other
        // hop must name one to be checked against the networks.
        if hop >= self.nearest {
            let ip = address?;
            if !self.is_trusted(Some(ip), hop) {
                return Some(ip);
            }
        }
        farthest = address;
    }
    farthest
}

== TrustedProxies::new()
remote_addr=Some(127.0.0.1) client_ip=Some(127.0.0.1)
== TrustedProxies::new().networks(["127.0.0.1"])
remote_addr=Some(127.0.0.1) client_ip=Some(198.51.100.1)
== TrustedProxies::new().nearest(2)
remote_addr=Some(127.0.0.1) client_ip=Some(203.0.113.9)

// The same skip conditions as tower-http's default, with the size
// threshold configurable.
let predicate = SizeAbove::new(self.min_size)
    .and(NotForContentType::GRPC)
    .and(NotForContentType::IMAGES)
    .and(NotForContentType::SSE);

// The response is already computed; the middleware wraps a one-shot
// inner service that just yields it.
let mut response = Some(response);
let inner = service_fn(move |_: http::Request<()>| {
    let response = response.take().expect("one-shot service called once");
    ready(Ok::<_, Infallible>(response))
});
let service = tower_http::compression::Compression::new(inner)
    .gzip(self.gzip)
    .br(self.brotli)
    .quality(self.level.into_tower())
    .compress_when(predicate);

### big, gzip
HTTP/1.1 200 OK
content-type: text/plain; charset=utf-8
vary: accept-encoding
content-encoding: gzip
transfer-encoding: chunked

### big, br
HTTP/1.1 200 OK
content-type: text/plain; charset=utf-8
vary: accept-encoding
content-encoding: br
transfer-encoding: chunked