从零写一个 mini-axum

bytes = "1"
http = "1"
http-body = "1"
http-body-util = "0.1"
hyper = { version = "=1.12.0", features = ["server", "client", "http1"] }
hyper-util = { version = "=0.1.21", features = ["tokio", "service"] }
serde = { version = "1", features = ["derive"] }
serde_json = "1"
tokio = { version = "=1.54.1", features = ["rt-multi-thread", "macros", "net"] }
tower = { version = "=0.5.3", default-features = false }

pub type BoxError = Box<dyn std::error::Error + Send + Sync>;
pub type Body = UnsyncBoxBody<Bytes, BoxError>;
pub type BoxFuture<T> = Pin<Box<dyn Future<Output = T> + Send>>;

pub trait IntoResponse {
  fn into_response(self) -> Response<Body>;
}

impl<T: IntoResponse> IntoResponse for (StatusCode, T) {
  fn into_response(self) -> Response<Body> {
    let mut res = self.1.into_response();
    *res.status_mut() = self.0;
    res
  }
}

pub trait FromRequestParts<S>: Sized {
  type Rejection: IntoResponse;
  fn from_request_parts(parts: &mut Parts, state: &S) -> impl Future<Output = Result<Self, Self::Rejection>> + Send;
}

pub trait FromRequest<S, M = ViaRequest>: Sized {
  type Rejection: IntoResponse;
  fn from_request(req: Request<Body>, state: &S) -> impl Future<Output = Result<Self, Self::Rejection>> + Send;
}

pub enum ViaParts {}
pub enum ViaRequest {}

// 只看头的提取器放在最后一个参数时走这里：body 直接丢掉
impl<S: Sync, T: FromRequestParts<S>> FromRequest<S, ViaParts> for T {
  type Rejection = T::Rejection;
  async fn from_request(req: Request<Body>, state: &S) -> Result<Self, Self::Rejection> {
    let (mut parts, _body) = req.into_parts();
    T::from_request_parts(&mut parts, state).await
  }
}

pub trait Handler<T, S>: Clone + Send + Sync + 'static {
  fn call(self, req: Request<Body>, state: S) -> BoxFuture<Response<Body>>;
}

macro_rules! impl_handler {
  ([$($ty:ident),*], $last:ident) => {
    #[allow(non_snake_case, unused_mut)]
    impl<F, Fut, Res, S, M, $($ty,)* $last> Handler<(M, $($ty,)* $last,), S> for F
    where
      F: FnOnce($($ty,)* $last) -> Fut + Clone + Send + Sync + 'static,
      Fut: Future<Output = Res> + Send,
      Res: IntoResponse,
      S: Send + Sync + 'static,
      $( $ty: FromRequestParts<S> + Send, )*
      $last: FromRequest<S, M> + Send,
    {
      fn call(self, req: Request<Body>, state: S) -> BoxFuture<Response<Body>> {
        let (mut parts, body) = req.into_parts();
        Box::pin(async move {
          $(
            let $ty = match $ty::from_request_parts(&mut parts, &state).await {
              Ok(value) => value,
              Err(rejection) => return rejection.into_response(),
            };
          )*
          let req = Request::from_parts(parts, body);
          let $last = match $last::from_request(req, &state).await {
            Ok(value) => value,
            Err(rejection) => return rejection.into_response(),
          };
          self($($ty,)* $last).await.into_response()
        })
      }
    }
  };
}

impl_handler!([], T1);
impl_handler!([T1], T2);
impl_handler!([T1, T2], T3);

    // 和 mini 的唯一区别：T 里没有 M
    impl<F, Fut, Res, S, M, $($ty,)* $last> Handler<($($ty,)* $last,), S> for F

error[E0207]: the type parameter `M` is not constrained by the impl trait, self type, or predicates
  --> src/bin/no_marker.rs:14:26
   |
14 |     impl<F, Fut, Res, S, M, $($ty,)* $last> Handler<($($ty,)* $last,), S> for F
   |                          ^ unconstrained type parameter
...
44 | impl_handler!([], T1);
   | --------------------- in this macro invocation
   |
   = note: this error originates in the macro `impl_handler` (in Nightly builds, run with -Z macro-backtrace for more info)

impl<F, Fut, Res, S, T1> Handler<(T1,), S> for F
where
  // ...
  T1: FromRequestParts<S> + Send,
{
  // ...
}

impl<F, Fut, Res, S, T1> Handler<(T1,), S> for F
where
  // ...
  T1: FromRequest<S> + Send,
{
  // ...
}

error[E0119]: conflicting implementations of trait `Handler<(_,), _>`
  --> src/bin/overlap.rs:31:1
   |
11 | / impl<F, Fut, Res, S, T1> Handler<(T1,), S> for F
12 | | where
13 | |   F: FnOnce(T1) -> Fut + Clone + Send + Sync + 'static,
14 | |   Fut: Future<Output = Res> + Send,
15 | |   Res: IntoResponse,
16 | |   S: Send + Sync + 'static,
17 | |   T1: FromRequestParts<S> + Send,
   | |_________________________________- first implementation here
...
31 | / impl<F, Fut, Res, S, T1> Handler<(T1,), S> for F
32 | | where
33 | |   F: FnOnce(T1) -> Fut + Clone + Send + Sync + 'static,
34 | |   Fut: Future<Output = Res> + Send,
35 | |   Res: IntoResponse,
36 | |   S: Send + Sync + 'static,
37 | |   T1: FromRequest<S> + Send,
   | |____________________________^ conflicting implementation

type ErasedHandler<S> = Arc<dyn Fn(Request<Body>, S) -> BoxFuture<Response<Body>> + Send + Sync>;

struct Endpoint<S> {
  method: Method,
  path: String,
  handler: ErasedHandler<S>,
}

pub struct Router<S> {
  endpoints: Arc<Vec<Endpoint<S>>>,
  state: S,
}

impl<S: Clone + Send + Sync + 'static> Router<S> {
  pub fn new(state: S) -> Self {
    Router { endpoints: Arc::new(Vec::new()), state }
  }

  pub fn route<H, T>(mut self, method: Method, path: &str, handler: H) -> Self
  where
    H: Handler<T, S>,
  {
    // 擦掉 H 和 T：从这里起，所有 handler 是同一种类型
    let handler: ErasedHandler<S> = Arc::new(move |req, state| handler.clone().call(req, state));
    Arc::make_mut(&mut self.endpoints).push(Endpoint { method, path: path.to_owned(), handler });
    self
  }

  fn dispatch(&self, req: Request<Body>) -> BoxFuture<Response<Body>> {
    let found = self
      .endpoints
      .iter()
      .find(|e| e.method == req.method() && e.path == req.uri().path());
    match found {
      Some(e) => (e.handler)(req, self.state.clone()),
      None => Box::pin(async { StatusCode::NOT_FOUND.into_response() }),
    }
  }
}

impl<S, B> tower::Service<Request<B>> for Router<S>
where
  S: Clone + Send + Sync + 'static,
  B: http_body::Body<Data = Bytes> + Send + 'static,
  B::Error: Into<BoxError>,
{
  type Response = Response<Body>;
  type Error = Infallible;
  type Future = BoxFuture<Result<Response<Body>, Infallible>>;

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

  fn call(&mut self, req: Request<B>) -> Self::Future {
    let req = req.map(|b| b.map_err(Into::into).boxed_unsync());
    let fut = self.dispatch(req);
    Box::pin(async move { Ok(fut.await) })
  }
}

#[derive(Clone, Default)]
struct AppState {
  next_id: Arc<AtomicU64>,
}

async fn root() -> &'static str {
  "hello from mini\n"
}

// 最后一个参数是只看头的提取器：走 ViaParts
async fn whoami(method: Method, headers: HeaderMap) -> String {
  let ua = headers.get("user-agent").and_then(|v| v.to_str().ok()).unwrap_or("-");
  format!("{method} from {ua}\n")
}

async fn echo(method: Method, body: String) -> String {
  format!("{method} echoed {} bytes: {body}\n", body.len())
}

async fn create_user(State(state): State<AppState>, Json(new): Json<NewUser>) -> (StatusCode, Json<User>) {
  let id = state.next_id.fetch_add(1, Ordering::Relaxed) + 1;
  (StatusCode::CREATED, Json(User { id, name: new.name }))
}

async fn count(State(state): State<AppState>) -> String {
  format!("{} users\n", state.next_id.load(Ordering::Relaxed))
}

// main 里：
let app = Router::new(AppState::default())
  .route(Method::GET, "/", root)
  .route(Method::GET, "/whoami", whoami)
  .route(Method::POST, "/echo", echo)
  .route(Method::POST, "/users", create_user)
  .route(Method::GET, "/users/count", count);

let listener = TcpListener::bind("127.0.0.1:0").await?;
let addr = listener.local_addr()?;
tokio::spawn(async move {
  loop {
    let Ok((stream, _)) = listener.accept().await else { break };
    let svc = TowerToHyperService::new(app.clone());
    tokio::spawn(async move {
      if let Err(e) = hyper::server::conn::http1::Builder::new().serve_connection(TokioIo::new(stream), svc).await {
        eprintln!("[srv] {e}");
      }
    });
  }
});

GET / -> 200 OK [text/plain; charset=utf-8] b"hello from mini\n"
GET /whoami -> 200 OK [text/plain; charset=utf-8] b"GET from mini-client\n"
POST /echo -> 200 OK [text/plain; charset=utf-8] b"POST echoed 4 bytes: ping\n"
POST /users -> 201 Created [application/json] b"{\"id\":1,\"name\":\"ferris\"}"
POST /users -> 201 Created [application/json] b"{\"id\":2,\"name\":\"corro\"}"
POST /users -> 415 Unsupported Media Type [text/plain; charset=utf-8] b"expected application/json"
POST /users -> 400 Bad Request [text/plain; charset=utf-8] b"invalid JSON: missing field `name` at line 1 column 11"
GET /users/count -> 200 OK [text/plain; charset=utf-8] b"2 users\n"
DELETE / -> 404 Not Found [-] b""
GET /nope -> 404 Not Found [-] b""

mini GET / -> 200 OK ["content-type: text/plain; charset=utf-8"] b"hello\n"
axum GET / -> 200 OK ["content-length: 6", "content-type: text/plain; charset=utf-8"] b"hello\n"
mini HEAD / -> 404 Not Found [] b""
axum HEAD / -> 200 OK ["content-length: 6", "content-type: text/plain; charset=utf-8"] b""
mini DELETE / -> 404 Not Found [] b""
axum DELETE / -> 405 Method Not Allowed ["allow: GET,HEAD", "content-length: 0"] b""
mini GET /nope -> 404 Not Found [] b""
axum GET /nope -> 404 Not Found [] b""