Struct aliri_oauth2::ScopesPolicy

pub struct ScopesPolicy { /* fields omitted */ }

An access policy based on OAuth2 scopes

This access policy takes the form of alternatives around required scopes. This policy will allow access if any of the alternatives would allow access. If the policy contains no alternatives, the default effect is to deny access.

Examples

Deny all requests

use aliri::Policy;
use aliri_oauth2::{Scopes, ScopesPolicy};

let policy = ScopesPolicy::deny_all();

let request = Scopes::single("admin");
assert!(policy.evaluate(&request).is_err());

Allow all requests

use aliri::Policy;
use aliri_oauth2::{Scopes, ScopesPolicy};

let policy = ScopesPolicy::allow_all();

let request = Scopes::empty();
assert!(policy.evaluate(&request).is_ok());

Allow requests with a single scope

use aliri::Policy;
use aliri_oauth2::{Scopes, ScopesPolicy};

let policy = ScopesPolicy::allow_one(
    Scopes::single("admin")
);

let request = Scopes::from_scopes(vec![
    "admin",
    "user",
]);
assert!(policy.evaluate(&request).is_ok());

let user_request = Scopes::from_scopes(vec![
    "user",
]);
assert!(policy.evaluate(&user_request).is_err());

Allow requests with multiple potential sets of scopes

use aliri::Policy;
use aliri_oauth2::{Scopes, ScopesPolicy};

let mut policy = ScopesPolicy::deny_all();
policy.allow(Scopes::single("admin"));
policy.allow(Scopes::from_scopes(vec![
    "special",
    "user",
]));

let admin_request = Scopes::from_scopes(vec![
    "admin",
]);
assert!(policy.evaluate(&admin_request).is_ok());

let user_request = Scopes::from_scopes(vec![
    "user",
]);
assert!(policy.evaluate(&user_request).is_err());

let special_user_request = Scopes::from_scopes(vec![
    "special",
    "user",
]);
assert!(policy.evaluate(&special_user_request).is_ok());

Implementations

impl ScopesPolicy

pub fn deny_all() -> Self

Constructs a policy that has no permissible alternatives

By default, this policy will deny all requests

pub fn allow_all() -> Self

Constructs a policy that does not require any scopes (allow)

pub fn allow_one(scopes: Scopes) -> Self

Constructs a policy that requires this set of scopes

pub fn allow(&mut self, scopes: Scopes)

Add an alternative set of required scopes

Trait Implementations

impl Clone for ScopesPolicy

fn clone(&self) -> ScopesPolicy

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ScopesPolicy

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Default for ScopesPolicy

fn default() -> ScopesPolicy

Returns the "default value" for a type.

impl Eq for ScopesPolicy

impl Extend<Scopes> for ScopesPolicy

fn extend<I>(&mut self, iter: I) where
    I: IntoIterator<Item = Scopes>, 

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬 This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl FromIterator<Scopes> for ScopesPolicy

fn from_iter<I>(iter: I) -> Self where
    I: IntoIterator<Item = Scopes>, 

Creates a value from an iterator.

impl IntoIterator for ScopesPolicy

type Item = Scopes

The type of the elements being iterated over.

type IntoIter = <Vec<Scopes> as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a> IntoIterator for &'a ScopesPolicy

type Item = &'a Scopes

The type of the elements being iterated over.

type IntoIter = Iter<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq<ScopesPolicy> for ScopesPolicy

fn eq(&self, other: &ScopesPolicy) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &ScopesPolicy) -> bool

This method tests for !=.

impl Policy for ScopesPolicy

type Request = Scopes

The request type evaluated by this policy

type Denial = InsufficientScopes

The error returned when this policy denies a request

fn evaluate(&self, held: &Self::Request) -> Result<(), Self::Denial>

Evaluates the request, producing an effect

impl StructuralEq for ScopesPolicy

impl StructuralPartialEq for ScopesPolicy