Extractor for request remote address about axum HOT 8 CLOSED

let remote_addr = req
  .extensions()
  .get::<axum::extract::ConnectInfo<SocketAddr>>()
  .map(|ci| ci.0);

use async_trait::async_trait;
use axum::{
    extract::{FromRequest, RequestParts},
    prelude::*,
    AddExtension,
};
use futures_util::future::Ready;
use hyper::server::conn::AddrStream;
use std::{
    convert::Infallible,
    net::SocketAddr,
    task::{Context, Poll},
};
use tower::{Service, ServiceBuilder};
use tower_http::add_extension::AddExtensionLayer;

#[tokio::main]
async fn main() {
    let app = route(
        "/",
        get(|RemoteAddr(addr)| async move {
            println!("`{}` connected", addr);
        }),
    );

    hyper::Server::bind(&SocketAddr::from(([127, 0, 0, 1], 3000)))
        .serve(MakeSvc(app))
        .await
        .unwrap();
}

struct MakeSvc<T>(T);

impl<T> Service<&AddrStream> for MakeSvc<T>
where
    T: Clone,
{
    type Response = AddExtension<T, RemoteAddr>;
    type Error = Infallible;
    type Future = Ready<Result<Self::Response, Self::Error>>;

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

    fn call(&mut self, conn: &AddrStream) -> Self::Future {
        let addr = conn.remote_addr();

        let svc = ServiceBuilder::new()
            .layer(AddExtensionLayer::new(RemoteAddr(addr)))
            .service(self.0.clone());

        futures_util::future::ok(svc)
    }
}

#[derive(Clone, Copy)]
struct RemoteAddr(SocketAddr);

#[async_trait]
impl<B> FromRequest<B> for RemoteAddr
where
    B: Send,
{
    type Rejection = Infallible;

    async fn from_request(req: &mut RequestParts<B>) -> Result<Self, Self::Rejection> {
        let addr = req
            .extensions()
            .expect("extensions taken by other extractor")
            .get::<RemoteAddr>()
            .copied()
            .expect("`RemoteAddr` extension missing");

        Ok(addr)
    }
}