Struct App 

pub struct App {
    pub base: AppBase<ServerImpl<Details>>,
    pub attribute_types: Map<Type>,
    pub yivi: Option<YiviCtx>,
    pub auth_state_secret: SealingKey,
    pub auth_window: Duration,
    pub attr_key_secret: Vec<u8>,
    pub chained_sessions_ctl: Option<ChainedSessionsCtl>,
}

Authentication server per-thread App that handles incoming requests.

Fields

base: AppBase<ServerImpl<Details>>

attribute_types: Map<Type>

yivi: Option<YiviCtx>

auth_state_secret: SealingKey

auth_window: Duration

attr_key_secret: Vec<u8>

chained_sessions_ctl: Option<ChainedSessionsCtl>

Implementations

impl App

Implementaton of endpoints

pub async fn handle_auth_start( app: Rc<Self>, req: Json<AuthStartReq>, ) -> Result<AuthStartResp>

Implements api::auths::AuthStartEP

fn create_disclosure_con_for( &self, attr_type_id: &AttributeTypeIdentifier, ) -> Result<Vec<AttributeRequest>>

Creates a disclosure ‘conjunction’ for the given yivi attribute type identifier.

This is almost always just the attibute type idenfitier itself, unless we’re dealing with the pubhubs card - in which case two other factors are added that fixes the registration source, and allows the user to see the ‘comment’ attached to the card (usually the redacted email address and phone number.)

The yivi attribute type that will provide the actual value for the pubhubs attribute will always come first. This is important because yivi::SessionResult::validate_and_extract_raw_singles will only pick the first value from each inner conjunction.

async fn handle_auth_start_yivi( app: Rc<Self>, state: AuthState, yivi_chained_session: bool, yivi_chained_session_drip: bool, ) -> Result<AuthStartResp>

pub async fn handle_auth_complete( app: Rc<Self>, req: Json<AuthCompleteReq>, ) -> Result<AuthCompleteResp>

async fn handle_auth_complete_yivi( app: Rc<Self>, state: AuthState, disclosure: JWT, ) -> Result<AuthCompleteResp>

impl App

pub(crate) fn registration_source<'a>(&'a self, yivi: &'a YiviCtx) -> &'a str

Gets the registration source to use when issuing a pubhubs card

pub(crate) fn issue_card( &self, card_pseud_package: CardPseudPackage, comment: Option<String>, ) -> Result<(ExtendedSessionRequest, Attr)>

Creates a yivi issuance request and pubhubs attribute for a PubHubs card

pub async fn handle_card(app: Rc<Self>, req: Json<CardReq>) -> Result<CardResp>

Implements api::auths::CardEP.

impl App

pub async fn handle_attr_keys( app: Rc<Self>, reqs: Json<HashMap<Handle, AttrKeyReq>>, ) -> Result<AttrKeysResp>

Implements api::auths::AttrKeysEP.

impl App

Helper functions

pub fn get_yivi(&self) -> Result<&YiviCtx, ErrorCode>

pub fn attr_type_from_handle<'s>( &'s self, attr_type_handle: &Handle, ) -> Option<&'s Type>

Get attr::Type by handle::Handle, returning None when it cannot be found.

impl App

async fn handle_hub_ping( app: Rc<Self>, signed_req: Json<TicketSigned<PingReq>>, ) -> Result<PingResp>

Implements api::server::HubPingEP.

fn cached_handle_welcome(app: &Self) -> Result<WelcomeResp>

Implements api::auths::WelcomeEP.

impl App

pub fn chained_sessions_ctl_or_bad_request(&self) -> Result<&ChainedSessionsCtl>

pub async fn handle_yivi_wait_for_result( app: Rc<Self>, req: Json<YiviWaitForResultReq>, ) -> Result<YiviWaitForResultResp>

Implements the api::auths::YiviWaitForResultEP endpoint.

pub async fn handle_yivi_next_session( app: Data<Rc<App>>, query: Query<YiviNextSessionQuery>, result_jwt: String, ) -> impl Responder

Implements the api::auths::YIVI_NEXT_SESSION_PATH endpoint.

async fn regular_wfns_responder( wfns_fut: impl Future<Output = Result<Option<ExtendedSessionRequest>>>, ) -> impl Responder

fn dripping_wfns_responder( wfns_fut: impl Future<Output = Result<Option<ExtendedSessionRequest>>> + 'static, ) -> impl Responder

pub async fn handle_yivi_release_next_session( app: Rc<Self>, req: Json<YiviReleaseNextSessionReq>, ) -> Result<YiviReleaseNextSessionResp>

Implements the api::auths::YiviReleaseNextSessionEP endpoint.

Methods from Deref<Target = AppBase<ServerImpl<Details>>>

pub async fn get_object<T>( &self, id: &T::Identifier, ) -> Result<Option<(T, UpdateVersion)>>

where T: ObjectDetails,

Tries to retrieve an object of type T from this server’s object store with the given id, returning Ok(None) if no such object exists.

pub async fn put_object<T>( &self, obj: &T, update: Option<UpdateVersion>, ) -> Result<Option<UpdateVersion>>

where T: ObjectDetails,

Attempts to put an object of type T into the object store, only overwriting the object that is already present when the version of the to-be-overwritten object is passed via update.

Returs Ok(None) when there is already an object present in the store with that id and type, but its version was not specified in update.

pub async fn delete_object<T>(&self, id: T::Identifier) -> Result<bool>

where T: ObjectDetails,

Attempts to delete an object with the given Id; returns true when an object was deleted, and false when no object with the given id was found.

pub fn running_state_or_please_retry( &self, ) -> Result<&RunningState<S::ExtraRunningState>, ErrorCode>

Returns the current RunningState of this server when available. Otherwise returns api::ErrorCode::PleaseRetry.

pub fn running_state_or_internal_error( &self, ) -> Result<&RunningState<S::ExtraRunningState>, ErrorCode>

Returns the current RunningState of this server when available. Otherwise returns api::ErrorCode::InternalError.

Trait Implementations

impl App<ServerImpl<Details>> for App

fn configure_actix_app(self: &Rc<Self>, sc: &mut ServiceConfig)

Allows App to add server-specific endpoints. Non-server specific endpoints are added by AppBase::configure_actix_app.

fn check_constellation(&self, constellation: &Constellation) -> bool

Checks whether the given constellation properly reflects this server’s configuration.

async fn discover( self: &Rc<Self>, phc_inf: DiscoveryInfoResp, ) -> Result<DiscoverVerdict>

Runs the discovery routine for this server given api::DiscoveryInfoResp already obtained from Pubhubs Central. If the server is not PHC itself, the Constellation in this api::DiscoveryInfoResp must be set.

fn master_enc_key_part(&self) -> Option<&PrivateKey>

Should return the master encryption key part for PHC and the transcryption.

async fn local_task(_weak: Weak<Self>)

Will be invoked for each instance of App that is created.

async fn global_task(_app: Rc<Self>) -> Result<Infallible>

Will be invoked once for each server, after discovery

impl Deref for App

type Target = AppBase<ServerImpl<Details>>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.