use std::sync::Arc;
use std::task::{Context, Poll};
use http::{Request, Response};
use tonic::body::Body;
use tower::{Layer, Service};
use crate::middleware::context::RequestContext;
use crate::middleware::error::MiddlewareError;
use crate::middleware::stack::MiddlewareStack;
#[derive(Clone)]
pub struct GrpcAuthLayer {
stack: Arc<MiddlewareStack>,
}
impl GrpcAuthLayer {
pub fn new(stack: Arc<MiddlewareStack>) -> Self {
Self { stack }
}
}
impl<S> Layer<S> for GrpcAuthLayer {
type Service = GrpcAuthService<S>;
fn layer(&self, inner: S) -> Self::Service {
GrpcAuthService {
inner,
stack: self.stack.clone(),
}
}
}
#[derive(Clone)]
pub struct GrpcAuthService<S> {
inner: S,
stack: Arc<MiddlewareStack>,
}
impl<S> Service<Request<Body>> for GrpcAuthService<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 {
if let Err(err) = check_a2a_version(&req) {
return Ok(crate::grpc::error::a2a_to_status(err).into_http());
}
let headers = req.headers().clone();
if 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_grpc_response(&err)),
}
})
}
}
fn check_a2a_version<B>(req: &Request<B>) -> Result<(), crate::error::A2aError> {
use tonic::server::NamedService;
let service =
<turul_a2a_proto::grpc::A2aServiceServer<crate::grpc::GrpcService> as NamedService>::NAME;
let is_a2a_call = req
.uri()
.path()
.strip_prefix('/')
.and_then(|p| p.strip_prefix(service))
.is_some_and(|rest| rest.starts_with('/'));
if !is_a2a_call {
return Ok(());
}
let requested = req
.headers()
.get(turul_a2a_types::wire::protocol::VERSION_PARAM)
.map(|v| v.to_str().unwrap_or_default());
crate::middleware::transport::check_version(requested, false)
}
fn middleware_error_to_grpc_response(err: &MiddlewareError) -> Response<Body> {
use tonic::Code;
use tonic_types::{ErrorDetails, StatusExt};
let code = match err {
MiddlewareError::HttpChallenge(crate::middleware::AuthFailureKind::InsufficientScope) => {
Code::PermissionDenied
}
MiddlewareError::Unauthenticated(_) | MiddlewareError::HttpChallenge(_) => {
Code::Unauthenticated
}
MiddlewareError::Forbidden(_) => Code::PermissionDenied,
MiddlewareError::Internal(_) => Code::Internal,
};
let details = ErrorDetails::with_error_info(
err.reason(),
turul_a2a_types::wire::errors::AUTH_ERROR_DOMAIN,
[],
);
tonic::Status::with_error_details(code, err.message(), details).into_http()
}