不起服务器测路由

impl<B> Service<Request<B>> for Router<()>
where
    B: HttpBody<Data = bytes::Bytes> + Send + 'static,
    B::Error: Into<axum_core::BoxError>,
{
    type Response = Response;
    type Error = Infallible;
    type Future = RouteFuture<Infallible>;

    #[inline]
    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
        Poll::Ready(Ok(()))
    }

    #[inline]
    fn call(&mut self, req: Request<B>) -> Self::Future {
        let req = req.map(Body::new);
        self.call_with_state(req, ())
    }
}

impl<B> Service<Request<B>> for RouterAsService<'_, B, ()>
where
    B: HttpBody<Data = bytes::Bytes> + Send + 'static,
    B::Error: Into<axum_core::BoxError>,
{
    type Response = Response;
    type Error = Infallible;
    type Future = RouteFuture<Infallible>;

    #[inline]
    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
        <Router as Service<Request<B>>>::poll_ready(self.router, cx)
    }

    #[inline]
    fn call(&mut self, req: Request<B>) -> Self::Future {
        self.router.call(req)
    }
}

axum = "=0.8.9"
tower = { version = "=0.5.3", features = ["util"] }
http-body-util = "=0.1.5"
tokio = { version = "=1.54.1", features = ["macros", "rt"] }

use std::net::SocketAddr;

use axum::body::{to_bytes, Body};
use axum::extract::connect_info::{ConnectInfo, MockConnectInfo};
use axum::extract::Request;
use axum::routing::{get, post};
use axum::Router;
use http_body_util::BodyExt;
use tower::{Service, ServiceExt};

async fn echo(body: String) -> String {
  format!("echo: {body}")
}

async fn peer(ConnectInfo(addr): ConnectInfo<SocketAddr>) -> String {
  format!("peer = {addr}")
}

fn app() -> Router {
  Router::new()
    .route("/echo", post(echo))
    .route("/peer", get(peer))
}

#[tokio::main(flavor = "current_thread")]
async fn main() {
  // 1. oneshot: consumes a clone of the Router
  let res = app()
    .oneshot(Request::post("/echo").body(Body::from("hi")).unwrap())
    .await
    .unwrap();
  let status = res.status();
  let bytes = res.into_body().collect().await.unwrap().to_bytes();
  println!("oneshot       {status} {bytes:?}");

  // 2. body type is generic: a Request<String> works too
  let res = app().oneshot(Request::post("/echo").body(String::from("from String")).unwrap()).await.unwrap();
  println!("Request<String> {}", String::from_utf8_lossy(&to_bytes(res.into_body(), 1024).await.unwrap()));

  // 3. to_bytes with a limit
  let res = app().oneshot(Request::post("/echo").body(Body::from("0123456789")).unwrap()).await.unwrap();
  match to_bytes(res.into_body(), 8).await {
    Ok(b) => println!("to_bytes(8)   {b:?}"),
    Err(e) => println!("to_bytes(8)   error: {e}"),
  }

  // 4. ready() + call() on &mut, several requests on one value
  let mut router = app();
  let mut svc = router.as_service::<Body>();
  for n in 1..=2 {
    let req = Request::post("/echo").body(Body::from(format!("#{n}"))).unwrap();
    let res = svc.ready().await.unwrap().call(req).await.unwrap();
    let bytes = res.into_body().collect().await.unwrap().to_bytes();
    println!("as_service    {bytes:?}");
  }

  // 5. ConnectInfo without and with MockConnectInfo
  let res = app().oneshot(Request::get("/peer").body(Body::empty()).unwrap()).await.unwrap();
  println!("no mock       {} {}", res.status().as_u16(), String::from_utf8_lossy(&to_bytes(res.into_body(), 1024).await.unwrap()));
  let mocked = app().layer(MockConnectInfo(SocketAddr::from(([10, 0, 0, 1], 4242))));
  let res = mocked.oneshot(Request::get("/peer").body(Body::empty()).unwrap()).await.unwrap();
  println!("mock          {} {}", res.status().as_u16(), String::from_utf8_lossy(&to_bytes(res.into_body(), 1024).await.unwrap()));
}

oneshot       200 OK b"echo: hi"
Request<String> echo: from String
to_bytes(8)   error: length limit exceeded
as_service    b"echo: #1"
as_service    b"echo: #2"
no mock       500 Missing request extension: Extension of type `axum::extract::connect_info::ConnectInfo<core::net::socket_addr::SocketAddr>` was not found. Perhaps you forgot to add it? See `axum::Extension`.
mock          200 peer = 10.0.0.1:4242

pub async fn to_bytes(body: Body, limit: usize) -> Result<Bytes, axum_core::Error> {
    Limited::new(body, limit)
        .collect()
        .await
        .map(|col| col.to_bytes())
        .map_err(axum_core::Error::new)
}

    async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
        match Extension::<Self>::from_request_parts(parts, state).await {
            Ok(Extension(connect_info)) => Ok(connect_info),
            Err(err) => match parts.extensions.get::<MockConnectInfo<T>>() {
                Some(MockConnectInfo(connect_info)) => Ok(Self(connect_info.clone())),
                None => Err(err),
            },
        }
    }

pub(crate) fn spawn_service<S>(svc: S) -> SocketAddr
where
    S: Service<Request, Response = Response, Error = Infallible> + Clone + Send + 'static,
    S::Future: Send,
{
    let std_listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
    std_listener.set_nonblocking(true).unwrap();
    let listener = TcpListener::from_std(std_listener).unwrap();

    let addr = listener.local_addr().unwrap();
    println!("Listening on {addr}");

    tokio::spawn(async move {
        serve(listener, Shared::new(svc))
            .await
            .expect("server error")
    });

    addr
}

peer = 127.0.0.1