use crate::action::{ActionContext, ApiResponse, DynAction, PermissionMode};
use crate::definition::ActionRef;
use crate::error::BaseError;
use async_trait::async_trait;
use std::sync::Arc;
#[derive(Debug, Clone)]
pub(crate) struct AuthorizationPolicy {
pub(crate) is_public: bool,
groups: Arc<[PermissionGroup]>,
}
impl AuthorizationPolicy {
pub(crate) fn new(is_public: bool, groups: impl Into<Arc<[PermissionGroup]>>) -> Self {
Self {
is_public,
groups: groups.into(),
}
}
pub(crate) fn authorize(&self, context: &ActionContext) -> Result<(), BaseError> {
if self.is_public {
return Ok(());
}
let user = context
.authenticated_user()
.ok_or_else(|| BaseError::Unauthorized("需要登录".to_string()))?;
for group in self.groups.iter() {
if !permissions_match(user, &group.permissions, group.mode) {
return Err(BaseError::PermissionDenied(format!(
"缺少 {} 权限: {:?}",
group.label, group.permissions
)));
}
}
Ok(())
}
pub(crate) fn allows(&self, context: &ActionContext) -> bool {
self.authorize(context).is_ok()
}
}
#[derive(Debug, Clone)]
pub(crate) struct PermissionGroup {
label: &'static str,
permissions: Arc<[String]>,
mode: PermissionMode,
}
impl PermissionGroup {
pub(crate) fn new(
label: &'static str,
permissions: impl Into<Arc<[String]>>,
mode: PermissionMode,
) -> Self {
Self {
label,
permissions: permissions.into(),
mode,
}
}
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub enum MiddlewareScope {
#[default]
AllActions,
ProtectedActions,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MiddlewareRole {
Unspecified,
Authentication,
TenantResolution,
StepUpProtection,
}
#[async_trait]
pub trait Middleware: Send + Sync + 'static {
fn role(&self) -> MiddlewareRole {
MiddlewareRole::Unspecified
}
fn target_action(&self) -> Option<&ActionRef> {
None
}
fn scope(&self) -> MiddlewareScope {
MiddlewareScope::AllActions
}
async fn handle(&self, ctx: ActionContext, next: Next<'_>) -> Result<ApiResponse, BaseError>;
}
pub struct Next<'a> {
pub(crate) remaining: &'a [Arc<dyn Middleware>],
pub(crate) action: Arc<dyn DynAction>,
pub(crate) policy: &'a AuthorizationPolicy,
}
impl<'a> Next<'a> {
pub async fn run(self, ctx: ActionContext) -> Result<ApiResponse, BaseError> {
let mut remaining = self.remaining;
while let Some((current, rest)) = remaining.split_first() {
remaining = rest;
let action_applies = match current.target_action() {
None => true,
Some(target) => ctx.dispatch_target().is_some_and(|(module, action)| {
module == target.module().as_str() && action == target.action().as_str()
}),
};
let scope_applies = match current.scope() {
MiddlewareScope::AllActions => true,
MiddlewareScope::ProtectedActions => !self.policy.is_public,
};
if action_applies && scope_applies {
let next = Next {
remaining: rest,
action: self.action,
policy: self.policy,
};
return current.handle(ctx, next).await;
}
}
authorize_and_dispatch(self.action, self.policy, ctx).await
}
}
async fn authorize_and_dispatch(
action: Arc<dyn DynAction>,
policy: &AuthorizationPolicy,
context: ActionContext,
) -> Result<ApiResponse, BaseError> {
let span = tracing::info_span!(
"authorize",
is_public = policy.is_public,
granted = tracing::field::Empty,
);
let _enter = span.enter();
authorize(policy, &context).inspect_err(|_| {
span.record("granted", false);
})?;
span.record("granted", true);
drop(_enter);
action.dispatch(context).await
}
pub(crate) fn authorize(
policy: &AuthorizationPolicy,
context: &ActionContext,
) -> Result<(), BaseError> {
policy.authorize(context)
}
fn permissions_match(
user: &crate::action::User,
permissions: &[String],
mode: PermissionMode,
) -> bool {
if permissions.is_empty() {
return true;
}
match mode {
PermissionMode::All => permissions
.iter()
.all(|permission| user.has_permission(permission)),
PermissionMode::Any => permissions
.iter()
.any(|permission| user.has_permission(permission)),
}
}
pub struct RequestIdMiddleware;
#[async_trait]
impl Middleware for RequestIdMiddleware {
async fn handle(
&self,
mut ctx: ActionContext,
next: Next<'_>,
) -> Result<ApiResponse, BaseError> {
if let Some(raw) = ctx
.request
.headers
.get("X-Request-Id")
.or_else(|| ctx.request.headers.get("x-request-id"))
{
if let Some(rid) = crate::action::RequestId::parse_hex(raw) {
ctx = ctx.with_request_id(rid);
}
}
tracing::Span::current().record("request_id", tracing::field::display(ctx.request_id));
next.run(ctx).await
}
}