Enum AuthN 

pub enum AuthN {
    Disabled,
    Enabled {
        openid: Option<Authenticator>,
        token: Option<Authenticator>,
    },
}

An Authentication middleware for actix-web relying on drogue-cloud user-auth-service and an openID service

This middleware will act on each request and try to authenticate the request with :

• The Authorisation: Bearer header, which should contain an openID token.
• The Authorisation: Basic header, which should contain a username and an access token issued by the drogue-cloud API.
• The token query parameter, which should contain am openID token.

If more than one of the above is provided, the request will be responded with 400: Bad request.

After the authentication is successful, this middleware will inject the UserInformation in the request object and forward it.

Fields

• open_id - An instance of openid::Authenticator It’s an openID client. It is used to verify OpenID tokens.
• token - An instance of pat::Authenticator. It’s a client for drogue-cloud-user-auth-service. It is used to verify API keys.
• enable_access_token - Whether to allow access tokens for authentication.

Variants

Disabled

Authentication is disabled, all requests will be using UserInformation::Anonymous.

Enabled

Authentication is enabled, using openid or API tokens.

NOTE: If neither is provided, all requests will fail.

Fields

openid: Option<Authenticator>

token: Option<Authenticator>

Trait Implementations

impl Clone for AuthN

fn clone(&self) -> AuthN

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AuthN

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

Formats the value using the given formatter.

impl From<(Option<Authenticator>, Option<Authenticator>)> for AuthN

Map a combination of openid and PAT authenticator

fn from(auth: (Option<Authenticator>, Option<Authenticator>)) -> Self

Converts to this type from the input type.

impl<S, B> Transform<S, ServiceRequest> for AuthN

where S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error> + 'static, S::Future: 'static, B: 'static,

type Response = ServiceResponse<EitherBody<B>>

Responses produced by the service.

type Error = <S as Service<ServiceRequest>>::Error

Errors produced by the service.

type Transform = AuthMiddleware<S>

The TransformService value created by this factory

type InitError = ()

Errors produced while building a transform service.

type Future = Ready<Result<<AuthN as Transform<S, ServiceRequest>>::Transform, <AuthN as Transform<S, ServiceRequest>>::InitError>>

The future response value.

fn new_transform(&self, service: S) -> Self::Future

Creates and returns a new Transform component, asynchronously