use crate::context::token_extract::extract_token_from_headers;
use crate::error::GarrisonError;
use crate::stp::with_current_token;
use actix_web::body::{BoxBody, EitherBody};
use actix_web::dev::{forward_ready, Service, ServiceRequest, ServiceResponse, Transform};
use actix_web::ResponseError;
use std::future::{ready, Ready};
use std::pin::Pin;
use std::rc::Rc;
use super::{GarrisonMiddleware, GarrisonMiddlewareService};
impl<S, B> Transform<S, ServiceRequest> for GarrisonMiddleware
where
S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = actix_web::Error> + 'static,
S::Future: 'static,
B: 'static,
{
type Response = ServiceResponse<EitherBody<B, BoxBody>>;
type Error = actix_web::Error;
type Transform = GarrisonMiddlewareService<S>;
type InitError = ();
type Future = Ready<Result<Self::Transform, Self::InitError>>;
fn new_transform(&self, service: S) -> Self::Future {
ready(Ok(GarrisonMiddlewareService {
inner: Rc::new(service),
rules: self.rules.clone(),
interceptor: self.interceptor.clone(),
config: self.config.clone(),
}))
}
}
impl<S, B> Service<ServiceRequest> for GarrisonMiddlewareService<S>
where
S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = actix_web::Error> + 'static,
S::Future: 'static,
B: 'static,
{
type Response = ServiceResponse<EitherBody<B, BoxBody>>;
type Error = actix_web::Error;
type Future = Pin<Box<dyn std::future::Future<Output = Result<Self::Response, Self::Error>>>>;
forward_ready!(inner);
fn call(&self, req: ServiceRequest) -> Self::Future {
let interceptor = self.interceptor.clone();
let path = req.uri().path().to_string();
let headers = req.headers().clone();
let rule_annotation = self.rules.get(&path).cloned();
let token = extract_token_from_headers(&headers, &self.config)
.ok()
.flatten();
let inner = self.inner.clone();
Box::pin(async move {
let auth_check = async move {
if let Some(annotation) = rule_annotation {
interceptor.pre_handle(&path, &annotation).await?;
}
Ok::<_, GarrisonError>(())
};
let auth_result = match token {
Some(t) => with_current_token(t, auth_check).await,
None => auth_check.await,
};
match auth_result {
Ok(()) => {
let res = (*inner).call(req).await?;
Ok(res.map_into_left_body())
},
Err(e) => {
tracing::error!(error = ?e, "garrison middleware rejection");
let resp = e.error_response();
Ok(req.into_response(resp).map_into_right_body())
},
}
})
}
}