use serde::{Deserialize, Serialize};
use uuid::Uuid;
use crate::AxiamError;
use crate::client::AxiamClient;
use crate::memo::MemoKey;
use crate::rest::auth::{CsrfHeaderExt, TenantHeadersExt};
use crate::retry::{Attempt, RetryRunner, ThreadRngJitter, TokioSleeper, parse_retry_after};
use crate::telemetry::{Outcome, TelemetryEvent};
const CHECK_PATH: &str = "/api/v1/authz/check";
const BATCH_CHECK_PATH: &str = "/api/v1/authz/check/batch";
#[derive(Debug, Clone, Serialize)]
pub struct AccessCheckRequest {
pub action: String,
pub resource_id: Uuid,
#[serde(skip_serializing_if = "Option::is_none")]
pub scope: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub subject_id: Option<Uuid>,
}
impl AccessCheckRequest {
pub fn new(action: impl Into<String>, resource_id: Uuid) -> Self {
Self {
action: action.into(),
resource_id,
scope: None,
subject_id: None,
}
}
pub fn with_scope(mut self, scope: impl Into<String>) -> Self {
self.scope = Some(scope.into());
self
}
pub fn with_subject(mut self, subject_id: Uuid) -> Self {
self.subject_id = Some(subject_id);
self
}
}
#[derive(Debug, Clone, Deserialize)]
pub struct AccessDecision {
pub allowed: bool,
#[serde(default)]
pub reason: Option<String>,
#[serde(default)]
pub reason_code: Option<String>,
}
pub mod reason_code {
pub const ALLOWED: &str = "allowed";
pub const NO_GRANT: &str = "no_grant";
pub const DENIED_BY_RULE: &str = "denied_by_rule";
}
#[derive(Debug, Serialize)]
struct BatchCheckRequestBody {
checks: Vec<AccessCheckRequest>,
}
#[derive(Debug, Deserialize)]
struct BatchCheckResponseWire {
results: Vec<AccessDecision>,
}
impl AxiamClient {
pub async fn check_access(
&self,
action: &str,
resource_id: Uuid,
scope: Option<&str>,
) -> Result<AccessDecision, AxiamError> {
let request = AccessCheckRequest {
action: action.to_string(),
resource_id,
scope: scope.map(str::to_string),
subject_id: None,
};
self.check_access_request(&request).await
}
pub async fn check_access_as(
&self,
subject_id: Uuid,
action: &str,
resource_id: Uuid,
scope: Option<&str>,
) -> Result<AccessDecision, AxiamError> {
let request = AccessCheckRequest {
action: action.to_string(),
resource_id,
scope: scope.map(str::to_string),
subject_id: Some(subject_id),
};
self.check_access_request(&request).await
}
pub async fn can(
&self,
action: &str,
resource_id: Uuid,
scope: Option<&str>,
) -> Result<bool, AxiamError> {
self.check_access(action, resource_id, scope)
.await
.map(|decision| decision.allowed)
}
pub async fn batch_check(
&self,
requests: Vec<AccessCheckRequest>,
) -> Result<Vec<AccessDecision>, AxiamError> {
self.ensure_open()?;
let body = BatchCheckRequestBody { checks: requests };
let client = self.clone();
let wire: BatchCheckResponseWire = self
.runner("batch_check")
.run(|attempt| {
let client = client.clone();
let body_ref = &body;
async move {
client
.send_authz_post("batch_check", BATCH_CHECK_PATH, body_ref, attempt)
.await
}
})
.await?;
Ok(wire.results)
}
async fn check_access_request(
&self,
request: &AccessCheckRequest,
) -> Result<AccessDecision, AxiamError> {
self.ensure_open()?;
let memo = self.decision_memo();
let key = MemoKey::new(
request.subject_id,
request.resource_id,
&request.action,
request.scope.as_deref(),
)
.in_acting_tenant(self.acting_tenant_id());
if let Some(hit) = memo.get_at(&key, crate::time::Instant::now()) {
return Ok(hit);
}
let client = self.clone();
let decision = self
.runner("check_access")
.run(|attempt| {
let client = client.clone();
async move {
client
.send_authz_post("check_access", CHECK_PATH, request, attempt)
.await
}
})
.await?;
memo.put_at(key, &decision, crate::time::Instant::now());
Ok(decision)
}
fn runner(&self, operation: &'static str) -> RetryRunner<'_> {
RetryRunner {
enabled: self.retry_enabled(),
operation,
telemetry: self.telemetry(),
jitter: &ThreadRngJitter,
sleeper: &TokioSleeper,
}
}
async fn send_authz_post<B, R>(
&self,
operation: &'static str,
path: &'static str,
body: &B,
attempt: u32,
) -> Result<R, Attempt>
where
B: Serialize + ?Sized,
R: for<'de> Deserialize<'de>,
{
let telemetry = self.telemetry();
telemetry.emit(TelemetryEvent::RequestStart {
operation,
method: "POST",
path_template: path,
attempt,
});
let started = crate::time::Instant::now();
let finish = |status: Option<u16>, outcome: Outcome| {
telemetry.emit(TelemetryEvent::RequestEnd {
operation,
method: "POST",
path_template: path,
attempt,
status,
duration: started.elapsed(),
outcome,
});
};
let response = match self
.http()
.post(self.authz_url(path))
.tenant_headers_of(self)
.session_credential_of(self)
.maybe_csrf_header(self)
.json(body)
.send()
.await
{
Ok(r) => r,
Err(e) => {
finish(None, Outcome::Failure);
return Err(Attempt::bare(AxiamError::Network {
message: format!("authz request failed: {e}"),
source: Some(Box::new(e)),
}));
}
};
if !response.status().is_success() {
let status = response.status().as_u16();
let retry_after = response
.headers()
.get(reqwest::header::RETRY_AFTER)
.and_then(|v| v.to_str().ok())
.and_then(parse_retry_after);
let message = response
.text()
.await
.unwrap_or_else(|_| "no response body".to_string());
finish(Some(status), Outcome::Failure);
return Err(Attempt {
err: AxiamError::from_http_status(status, message),
retry_after,
});
}
let status = response.status().as_u16();
match response.json().await {
Ok(v) => {
finish(Some(status), Outcome::Success);
Ok(v)
}
Err(e) => {
finish(Some(status), Outcome::Failure);
Err(Attempt::bare(AxiamError::Network {
message: format!("failed to parse authz response body: {e}"),
source: Some(Box::new(e)),
}))
}
}
}
fn authz_url(&self, path: &str) -> url::Url {
self.base_url()
.join(path)
.expect("authz path is a well-formed relative URL literal")
}
}