use crate::{
body::{boxed, BoxBody},
server::NamedService,
};
use http::{Request, Response};
use hyper::Body;
use pin_project::pin_project;
use std::{
convert::Infallible,
fmt,
future::Future,
pin::Pin,
task::{ready, Context, Poll},
};
use tower::ServiceExt;
use tower_service::Service;
#[derive(Debug, Default, Clone)]
pub struct Routes {
router: axum::Router,
}
#[derive(Debug, Default, Clone)]
pub struct RoutesBuilder {
routes: Option<Routes>,
}
impl RoutesBuilder {
pub fn add_service<S>(&mut self, svc: S) -> &mut Self
where
S: Service<Request<Body>, Response = Response<BoxBody>, Error = Infallible>
+ NamedService
+ Clone
+ Send
+ 'static,
S::Future: Send + 'static,
S::Error: Into<crate::Error> + Send,
{
let routes = self.routes.take().unwrap_or_default();
self.routes.replace(routes.add_service(svc));
self
}
pub fn routes(self) -> Routes {
self.routes.unwrap_or_default()
}
}
impl Routes {
pub fn new<S>(svc: S) -> Self
where
S: Service<Request<Body>, Response = Response<BoxBody>, Error = Infallible>
+ NamedService
+ Clone
+ Send
+ 'static,
S::Future: Send + 'static,
S::Error: Into<crate::Error> + Send,
{
let router = axum::Router::new().fallback(unimplemented);
Self { router }.add_service(svc)
}
pub fn add_service<S>(mut self, svc: S) -> Self
where
S: Service<Request<Body>, Response = Response<BoxBody>, Error = Infallible>
+ NamedService
+ Clone
+ Send
+ 'static,
S::Future: Send + 'static,
S::Error: Into<crate::Error> + Send,
{
let svc = svc.map_response(|res| res.map(axum::body::boxed));
self.router = self
.router
.route_service(&format!("/{}/*rest", S::NAME), svc);
self
}
pub(crate) fn prepare(self) -> Self {
Self {
router: self.router.with_state(()),
}
}
pub fn into_router(self) -> axum::Router {
self.router
}
}
async fn unimplemented() -> impl axum::response::IntoResponse {
let status = http::StatusCode::OK;
let headers = [("grpc-status", "12"), ("content-type", "application/grpc")];
(status, headers)
}
impl Service<Request<Body>> for Routes {
type Response = Response<BoxBody>;
type Error = crate::Error;
type Future = RoutesFuture;
#[inline]
fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(()))
}
fn call(&mut self, req: Request<Body>) -> Self::Future {
RoutesFuture(self.router.call(req))
}
}
#[pin_project]
pub struct RoutesFuture(#[pin] axum::routing::future::RouteFuture<Body, Infallible>);
impl fmt::Debug for RoutesFuture {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_tuple("RoutesFuture").finish()
}
}
impl Future for RoutesFuture {
type Output = Result<Response<BoxBody>, crate::Error>;
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
match ready!(self.project().0.poll(cx)) {
Ok(res) => Ok(res.map(boxed)).into(),
Err(err) => match err {},
}
}
}