use std::future::Future;
use std::pin::Pin;
use std::sync::Arc;
use tonic::Code;
use tonic::service::interceptor::InterceptedService;
use tonic::transport::Channel;
use uuid::Uuid;
use crate::AxiamError;
use crate::grpc::r#gen::authorization_service_client::AuthorizationServiceClient;
use crate::grpc::r#gen::{
BatchCheckAccessRequest as WireBatchCheckAccessRequest,
CheckAccessRequest as WireCheckAccessRequest, CheckAccessResponse as WireCheckAccessResponse,
};
use crate::grpc::interceptor::AuthInterceptor;
use crate::token::TokenManager;
use crate::token::refresh_guard::RefreshedTokens;
#[derive(Debug, Clone)]
pub struct CheckAccessRequest {
pub tenant_id: Uuid,
pub subject_id: Uuid,
pub action: String,
pub resource_id: Uuid,
pub scope: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct AccessDecision {
pub allowed: bool,
pub reason: Option<String>,
pub reason_code: Option<String>,
}
impl From<WireCheckAccessResponse> for AccessDecision {
fn from(wire: WireCheckAccessResponse) -> Self {
let reason = {
#[allow(deprecated)]
let legacy = wire.deny_reason;
wire.reason
.or(Some(legacy))
.filter(|reason| !reason.is_empty())
};
AccessDecision {
allowed: wire.allowed,
reason,
reason_code: if wire.reason_code.is_empty() {
None
} else {
Some(wire.reason_code)
},
}
}
}
impl From<&CheckAccessRequest> for WireCheckAccessRequest {
fn from(req: &CheckAccessRequest) -> Self {
WireCheckAccessRequest {
tenant_id: req.tenant_id.to_string(),
subject_id: req.subject_id.to_string(),
action: req.action.clone(),
resource_id: req.resource_id.to_string(),
scope: req.scope.clone(),
}
}
}
type InnerClient = AuthorizationServiceClient<InterceptedService<Channel, AuthInterceptor>>;
pub type RefreshFn = Arc<
dyn Fn(String) -> Pin<Box<dyn Future<Output = Result<RefreshedTokens, AxiamError>> + Send>>
+ Send
+ Sync,
>;
#[derive(Clone)]
pub struct AuthzGrpcClient {
inner: InnerClient,
token_manager: Arc<TokenManager>,
tenant_id: Uuid,
refresh_fn: RefreshFn,
}
impl AuthzGrpcClient {
pub fn new(
channel: Channel,
token_manager: Arc<TokenManager>,
tenant_id: Uuid,
refresh_fn: RefreshFn,
) -> Self {
let interceptor = AuthInterceptor::new(Arc::clone(&token_manager), tenant_id);
let inner = AuthorizationServiceClient::with_interceptor(channel, interceptor);
Self {
inner,
token_manager,
tenant_id,
refresh_fn,
}
}
pub fn tenant_id(&self) -> Uuid {
self.tenant_id
}
pub async fn check_access(
&self,
request: CheckAccessRequest,
) -> Result<AccessDecision, AxiamError> {
let wire_request = WireCheckAccessRequest::from(&request);
match self.try_check_access(wire_request.clone()).await {
Ok(resp) => Ok(resp.into()),
Err(status) if status.code() == Code::Unauthenticated => self
.refresh_and_retry(status, || self.try_check_access(wire_request.clone()))
.await
.map(Into::into),
Err(status) => Err(status_to_axiam_error(status)),
}
}
pub async fn batch_check(
&self,
requests: Vec<CheckAccessRequest>,
) -> Result<Vec<AccessDecision>, AxiamError> {
let wire_requests: Vec<WireCheckAccessRequest> =
requests.iter().map(WireCheckAccessRequest::from).collect();
let wire_request = WireBatchCheckAccessRequest {
requests: wire_requests,
};
match self.try_batch_check(wire_request.clone()).await {
Ok(results) => Ok(results.into_iter().map(Into::into).collect()),
Err(status) if status.code() == Code::Unauthenticated => self
.refresh_and_retry(status, || self.try_batch_check(wire_request.clone()))
.await
.map(|results| results.into_iter().map(Into::into).collect()),
Err(status) => Err(status_to_axiam_error(status)),
}
}
async fn try_check_access(
&self,
wire_request: WireCheckAccessRequest,
) -> Result<WireCheckAccessResponse, tonic::Status> {
let mut client = self.inner.clone();
client
.check_access(wire_request)
.await
.map(|resp| resp.into_inner())
}
async fn try_batch_check(
&self,
wire_request: WireBatchCheckAccessRequest,
) -> Result<Vec<WireCheckAccessResponse>, tonic::Status> {
let mut client = self.inner.clone();
client
.batch_check_access(wire_request)
.await
.map(|resp| resp.into_inner().results)
}
async fn refresh_and_retry<T, F, Fut>(
&self,
original: tonic::Status,
attempt: F,
) -> Result<T, AxiamError>
where
F: Fn() -> Fut,
Fut: Future<Output = Result<T, tonic::Status>>,
{
if !self.token_manager.has_refresh_token().await {
return Err(status_to_axiam_error(original));
}
let observed = self
.token_manager
.cached_access_token()
.map(|t| t.expose().clone())
.unwrap_or_default();
let refresh_fn = Arc::clone(&self.refresh_fn);
self.token_manager
.refresh_if_needed(&observed, move |refresh_token| refresh_fn(refresh_token))
.await?;
attempt().await.map_err(status_to_axiam_error)
}
}
pub(crate) fn status_to_axiam_error(status: tonic::Status) -> AxiamError {
AxiamError::from_grpc_code(status.code() as i32, status.message().to_string())
}