classify：什么算失败

pub trait MakeClassifier {
    type Classifier: ClassifyResponse<
        FailureClass = Self::FailureClass,
        ClassifyEos = Self::ClassifyEos,
    >;
    type FailureClass;
    type ClassifyEos: ClassifyEos<FailureClass = Self::FailureClass>;

    fn make_classifier<B>(&self, req: &Request<B>) -> Self::Classifier;
}

pub trait ClassifyResponse {
    type FailureClass;
    type ClassifyEos: ClassifyEos<FailureClass = Self::FailureClass>;

    fn classify_response<B>(
        self,
        res: &Response<B>,
    ) -> ClassifiedResponse<Self::FailureClass, Self::ClassifyEos>;

    fn classify_error<E>(self, error: &E) -> Self::FailureClass
    where
        E: fmt::Display + 'static;
    // ...
}

pub trait ClassifyEos {
    type FailureClass;

    fn classify_eos(self, trailers: Option<&HeaderMap>) -> Result<(), Self::FailureClass>;

    fn classify_error<E>(self, error: &E) -> Self::FailureClass
    where
        E: fmt::Display + 'static;
    // ...
}

pub enum ClassifiedResponse<FailureClass, ClassifyEos> {
    /// The response was able to be classified immediately.
    Ready(Result<(), FailureClass>),
    /// We have to wait until the end of a streaming response to classify it.
    RequiresEos(ClassifyEos),
}

        match classify_grpc_metadata(res.headers(), self.success_codes) {
            ParsedGrpcStatus::Success | ParsedGrpcStatus::HeaderNotGrpcCode => {
                ClassifiedResponse::Ready(Ok(()))
            }
            ParsedGrpcStatus::NonSuccess(status) => {
                ClassifiedResponse::Ready(Err(GrpcFailureClass::Status(status)))
            }
            ParsedGrpcStatus::GrpcStatusHeaderMissing => {
                ClassifiedResponse::RequiresEos(GrpcEosErrorsAsFailures {
                    success_codes: self.success_codes,
                })
            }
        }

tower-http = "=0.7.1"
http = "1"

use http::{HeaderMap, HeaderValue, Response, StatusCode};
use tower_http::classify::{
  ClassifiedResponse, ClassifyEos, ClassifyResponse, GrpcCode, GrpcErrorsAsFailures,
  ServerErrorsAsFailures, StatusInRangeAsFailures,
};

fn res(status: u16, headers: &[(&'static str, &'static str)]) -> Response<()> {
  let mut r = Response::new(());
  *r.status_mut() = StatusCode::from_u16(status).unwrap();
  for (k, v) in headers {
    r.headers_mut().insert(*k, HeaderValue::from_static(v));
  }
  r
}

fn show<C: ClassifyResponse>(name: &str, c: C, r: &Response<()>, trailers: Option<&HeaderMap>)
where
  C::FailureClass: std::fmt::Display,
{
  match c.classify_response(r) {
    ClassifiedResponse::Ready(Ok(())) => println!("{name}: Ready(Ok)"),
    ClassifiedResponse::Ready(Err(f)) => println!("{name}: Ready(Err: {f})"),
    ClassifiedResponse::RequiresEos(eos) => match eos.classify_eos(trailers) {
      Ok(()) => println!("{name}: RequiresEos -> Ok"),
      Err(f) => println!("{name}: RequiresEos -> Err: {f}"),
    },
  }
}

fn main() {
  // 纯 HTTP 状态码
  show("server 404", ServerErrorsAsFailures::new(), &res(404, &[]), None);
  show("server 503", ServerErrorsAsFailures::new(), &res(503, &[]), None);
  show("range  404", StatusInRangeAsFailures::new_for_client_and_server_errors(), &res(404, &[]), None);

  // gRPC：HTTP 状态码一律 200，结果在 grpc-status 里
  let grpc = GrpcErrorsAsFailures::new();
  show("grpc trailers-only", grpc.clone(), &res(200, &[("grpc-status", "5"), ("grpc-message", "no%20such%20user")]), None);
  let mut trailers = HeaderMap::new();
  trailers.insert("grpc-status", HeaderValue::from_static("13"));
  show("grpc streaming", grpc.clone(), &res(200, &[("content-type", "application/grpc")]), Some(&trailers));
  show("grpc streaming, no trailers", grpc.clone(), &res(200, &[]), None);
  show("grpc 500 without grpc-status", grpc.clone(), &res(500, &[]), None);
  show("grpc NotFound as success", grpc.with_success(GrpcCode::NotFound), &res(200, &[("grpc-status", "5")]), None);

  // map_failure_class：把失败类型换成自己的
  let mapped = ServerErrorsAsFailures::new().map_failure_class(|f| format!("[mapped] {f}"));
  show("mapped 502", mapped, &res(502, &[]), None);

  // 构造时校验范围端点
  std::panic::set_hook(Box::new(|_| {}));
  let r = std::panic::catch_unwind(|| StatusInRangeAsFailures::new(0..=599));
  let msg = r.err().and_then(|p| p.downcast_ref::<&str>().map(|s| s.to_string()));
  println!("new(0..=599) panicked: {msg:?}");
}

server 404: Ready(Ok)
server 503: Ready(Err: Status code: 503 Service Unavailable)
range  404: Ready(Err: Status code: 404 Not Found)
grpc trailers-only: Ready(Err: Status: NotFound: no such user)
grpc streaming: RequiresEos -> Err: Status: Internal
grpc streaming, no trailers: RequiresEos -> Ok
grpc 500 without grpc-status: RequiresEos -> Ok
grpc NotFound as success: Ready(Ok)
mapped 502: Ready(Err: [mapped] Status code: 502 Bad Gateway)
new(0..=599) panicked: Some("range start isn't a valid status code")