use axum::extract::ConnectInfo;
use axum::{extract::Request, response::Response};
use std::future::Future;
use std::net::SocketAddr;
use std::pin::Pin;
use std::sync::Arc;
use std::task::{Context, Poll};
use std::time::Instant;
use tower::{Layer, Service};
use wordval_utils::web::{extract_client_ip_trusted, TrustedProxies};
#[derive(Debug, Clone)]
pub struct ClientIp(pub String);
#[derive(Debug, Clone, Copy)]
pub struct RequestStart(pub Instant);
#[derive(Clone)]
pub struct ClientIdentityLayer {
pub trusted: Arc<TrustedProxies>,
}
impl<S> Layer<S> for ClientIdentityLayer {
type Service = ClientIdentityService<S>;
fn layer(&self, inner: S) -> Self::Service {
ClientIdentityService {
inner,
trusted: self.trusted.clone(),
}
}
}
#[derive(Clone)]
pub struct ClientIdentityService<S> {
inner: S,
trusted: Arc<TrustedProxies>,
}
impl<S, ReqBody> Service<Request<ReqBody>> for ClientIdentityService<S>
where
S: Service<Request<ReqBody>, Response = Response> + Clone + Send + 'static,
S::Future: Send + 'static,
ReqBody: Send + 'static,
{
type Response = S::Response;
type Error = S::Error;
type Future = Pin<Box<dyn 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, req: Request<ReqBody>) -> Self::Future {
let started = Instant::now();
let connect_ip = req
.extensions()
.get::<ConnectInfo<SocketAddr>>()
.map(|c| c.0)
.unwrap_or(SocketAddr::from(([0, 0, 0, 0], 0)));
let ip = if self.trusted.is_empty() {
connect_ip.ip().to_string()
} else {
extract_client_ip_trusted(req.headers(), &connect_ip, &self.trusted)
};
let mut req = req;
req.extensions_mut().insert(RequestStart(started));
req.extensions_mut().insert(ClientIp(ip));
let replacement = self.inner.clone();
let mut inner = std::mem::replace(&mut self.inner, replacement);
Box::pin(async move { inner.call(req).await })
}
}