use std::sync::Arc;
use std::task::{Context, Poll};
use axum::body::Body;
use http::{Request, Response};
use tower::{Layer, Service};
use super::context::RequestContext;
use super::error::MiddlewareError;
use super::stack::MiddlewareStack;
#[derive(Clone)]
pub struct AuthLayer {
stack: Arc<MiddlewareStack>,
}
impl AuthLayer {
pub fn new(stack: Arc<MiddlewareStack>) -> Self {
Self { stack }
}
}
impl<S> Layer<S> for AuthLayer {
type Service = AuthService<S>;
fn layer(&self, inner: S) -> Self::Service {
AuthService {
inner,
stack: self.stack.clone(),
}
}
}
#[derive(Clone)]
pub struct AuthService<S> {
inner: S,
stack: Arc<MiddlewareStack>,
}
impl<S> Service<Request<Body>> for AuthService<S>
where
S: Service<Request<Body>, Response = Response<Body>> + Clone + Send + 'static,
S::Future: Send,
{
type Response = Response<Body>;
type Error = S::Error;
type Future = std::pin::Pin<
Box<dyn std::future::Future<Output = Result<Self::Response, Self::Error>> + Send>,
>;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.inner.poll_ready(cx)
}
fn call(&mut self, mut req: Request<Body>) -> Self::Future {
let stack = self.stack.clone();
let mut inner = self.inner.clone();
Box::pin(async move {
let path = req.uri().path().to_string();
let headers = req.headers().clone();
if super::is_bypass_path(&path) || stack.is_empty() {
req.extensions_mut()
.insert(RequestContext::from_headers(headers));
return inner.call(req).await;
}
let mut ctx = RequestContext::from_headers(headers);
match stack.before_request(&mut ctx).await {
Ok(()) => {
req.extensions_mut().insert(ctx);
inner.call(req).await
}
Err(err) => {
Ok(middleware_error_to_response(&err, &path))
}
}
})
}
}
fn middleware_error_to_response(err: &MiddlewareError, path: &str) -> Response<Body> {
let status = axum::http::StatusCode::from_u16(err.http_status())
.unwrap_or(axum::http::StatusCode::INTERNAL_SERVER_ERROR);
let body = if crate::jsonrpc::is_jsonrpc_path(path) {
err.jsonrpc_body()
} else {
err.http_body()
};
let mut builder = Response::builder().status(status).header(
http::header::CONTENT_TYPE,
turul_a2a_types::wire::protocol::MEDIA_TYPE_JSON,
);
if let MiddlewareError::HttpChallenge(kind) = err
&& let Some(challenge) = kind.bearer_challenge()
{
builder = builder.header(http::header::WWW_AUTHENTICATE, challenge);
}
builder
.body(Body::from(serde_json::to_string(&body).unwrap_or_default()))
.unwrap_or_else(|_| Response::builder().status(500).body(Body::empty()).unwrap())
}