Struct StatelessAuthorizationStrategy 

pub struct StatelessAuthorizationStrategy { /* private fields */ }

Stateless authorization strategy.

This strategy delegates all authorization decisions directly to the underlying provider without any caching. Each request is fully evaluated, ensuring that the most up-to-date policies are always applied.

Use Cases

• High-security environments where real-time policy enforcement is critical
• Systems with frequently changing authorization policies
• Deployments with limited memory resources
• Scenarios where authorization overhead is acceptable

Trade-offs

Advantages:

• Always uses the latest policies
• No cache consistency issues
• Lower memory footprint
• Simpler implementation

Disadvantages:

• Higher latency per request
• Increased load on authorization provider
• No performance optimization for repeated requests

Examples

use rocketmq_auth::StatelessAuthorizationStrategy;
use rocketmq_auth::AuthConfig;

let config = AuthConfig::default();
let strategy = StatelessAuthorizationStrategy::new(config, None)?;

// Each evaluation queries the provider directly
let context = DefaultAuthorizationContext::of(subject, resource, action, ip);
match strategy.evaluate(&context).await? {
    AuthorizationDecision::Allow => proceed(),
    AuthorizationDecision::Deny(reason) => reject(reason),
}

Implementations

impl StatelessAuthorizationStrategy

pub fn new( auth_config: AuthConfig, metadata_service: Option<Box<dyn Any + Send + Sync>>, ) -> AuthServiceResult<Self>

Creates a new stateless authorization strategy.

Arguments

• auth_config - Authorization configuration
• metadata_service - Optional metadata service for provider initialization

Returns

A new StatelessAuthorizationStrategy instance.

Errors

Returns an error if the base strategy initialization fails.

Examples

let config = AuthConfig::default();
let strategy = StatelessAuthorizationStrategy::new(config, None)?;

pub fn base(&self) -> &AbstractAuthorizationStrategy

Gets a reference to the base authorization strategy.

Trait Implementations

impl AuthorizationStrategy for StatelessAuthorizationStrategy

fn evaluate<'a>( &'a self, context: &'a DefaultAuthorizationContext, ) -> Pin<Box<dyn Future<Output = AuthServiceResult<AuthorizationDecision>> + 'a>>

Evaluates authorization for the given context without caching.

This method delegates directly to the base do_evaluate method, ensuring every request is fully evaluated.

Arguments

• context - The authorization context to evaluate

Returns

• Ok(AuthorizationDecision) for a final allow or deny
• Err(AuthServiceError) if evaluation cannot make a decision

Examples

let strategy = StatelessAuthorizationStrategy::new(config, None)?;
let context = DefaultAuthorizationContext::of(subject, resource, action, ip);
match strategy.evaluate(&context).await? {
    AuthorizationDecision::Allow => proceed(),
    AuthorizationDecision::Deny(reason) => reject(reason),
}