Struct PluginRegistry 

pub struct PluginRegistry { /* private fields */ }

Registry of available claims plugins

Implementations

impl PluginRegistry

pub fn register( &mut self, name: impl Into<String>, plugin: Arc<dyn ClaimsPlugin>, )

Register a plugin with a name

Examples found in repository

examples/dispatcher_usage.rs (line 129)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut plugins = PluginRegistry::default();
    plugins.register("demo", Arc::new(DemoClaimsPlugin));

    let mut plugin_configs = HashMap::new();
    plugin_configs.insert(
        "demo".to_owned(),
        PluginConfig::Oidc {
            tenant_claim: "tenants".to_owned(),
            roles_claim: "roles".to_owned(),
        },
    );

    let config = AuthConfig {
        mode: AuthModeConfig {
            provider: "demo".to_owned(),
        },
        issuers: vec!["https://issuer.local".to_owned()],
        audiences: vec!["demo-api".to_owned()],
        plugins: plugin_configs,
        ..AuthConfig::default()
    };

    let validation = ValidationConfig {
        allowed_issuers: config.issuers.clone(),
        allowed_audiences: config.audiences.clone(),
        leeway_seconds: config.leeway_seconds,
        require_uuid_subject: true,
        require_uuid_tenants: true,
    };

    let subject = Uuid::new_v4();
    let tenant = Uuid::new_v4();
    let expires_at = OffsetDateTime::now_utc() + Duration::minutes(15);

    let raw_claims = serde_json::json!({
        "iss": "https://issuer.local",
        "sub": subject.to_string(),
        "aud": ["demo-api"],
        "exp": expires_at.unix_timestamp(),
        "tenant_id": tenant.to_string(),
        "roles": ["viewer:read"]
    });

    let dispatcher = AuthDispatcher::new(validation, &config, &plugins)?
        .with_key_provider(Arc::new(StaticKeyProvider::new(raw_claims)));

    let claims = dispatcher.validate_jwt("demo-token").await?;
    let perm_list = if claims.permissions.is_empty() {
        "none".to_owned()
    } else {
        claims
            .permissions
            .iter()
            .map(|p| format!("{}:{}", p.resource_pattern(), p.action()))
            .collect::<Vec<_>>()
            .join(", ")
    };
    println!(
        "Validated token for subject {} with permissions {}",
        claims.subject, perm_list
    );

    Ok(())
}

pub fn get(&self, name: &str) -> Result<&Arc<dyn ClaimsPlugin>, ConfigError>

Get a plugin by name.

Errors

Returns ConfigError::UnknownPlugin if no plugin with the given name exists.

pub fn contains(&self, name: &str) -> bool

Check if a plugin exists

pub fn plugin_names(&self) -> Vec<String>

Get all plugin names

pub fn len(&self) -> usize

Number of registered plugins

pub fn is_empty(&self) -> bool

Check if registry is empty

Trait Implementations

impl Default for PluginRegistry

fn default() -> PluginRegistry

Returns the “default value” for a type.