Struct App 

pub struct App {

    pub base: AppBase<ServerImpl<Details>>,
    pub transcryptor_url: Url,
    pub auths_url: Url,
    pub global_client_url: Url,
    pub hubs: Map<BasicInfo>,
    pub master_enc_key_part: PrivateKey,
    pub attr_id_secret: Box<[u8]>,
    pub auth_token_secret: SealingKey,
    pub auth_token_validity: Duration,
    pub pp_nonce_secret: SealingKey,
    pub pp_nonce_validity: Duration,
    pub user_object_hmac_secret: Box<[u8]>,
    pub quota: Quota,
    pub card_pseud_validity: Duration,
    pub broadcast: Sender<InterAppMsg>,
    pub cached_hub_info: RefCell<CachedResponse<CachedHubInfoEP>>,
    pub hub_cache_config: HubCacheConfig,
}

Fields

base: AppBase<ServerImpl<Details>>

transcryptor_url: Url

auths_url: Url

global_client_url: Url

hubs: Map<BasicInfo>

master_enc_key_part: PrivateKey

attr_id_secret: Box<[u8]>

auth_token_secret: SealingKey

auth_token_validity: Duration

pp_nonce_secret: SealingKey

pp_nonce_validity: Duration

user_object_hmac_secret: Box<[u8]>

quota: Quota

card_pseud_validity: Duration

broadcast: Sender<InterAppMsg>

channel for sending messages between apps

cached_hub_info: RefCell<CachedResponse<CachedHubInfoEP>>

hub_cache_config: HubCacheConfig

Implementations

impl App

pub(super) async fn handle_hub_ticket( app: Rc<Self>, signed_req: Json<Signed<TicketReq>>, ) -> Result<TicketResp>

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

Implements api::server::HubPingEP.

impl App

async fn discovery_info_of( &self, name: Name, url: &Url, ) -> Result<DiscoveryInfoResp>

Obtains and checks api::DiscoveryInfoResp from the given server

impl App

pub(super) fn cached_handle_user_welcome(app: &Self) -> Result<WelcomeResp>

Implements WelcomeEP

pub(super) async fn handle_cached_hub_info(app: Data<Rc<App>>) -> impl Responder

Implements CachedHubInfoEP

pub(super) async fn handle_user_state( app: Rc<Self>, auth_token: Header<AuthToken>, ) -> Result<StateResp>

Implements StateEP

pub(super) async fn handle_user_enter( app: Rc<Self>, req: Json<EnterReq>, auth_token: Option<Header<AuthToken>>, ) -> Result<EnterResp>

Implements EnterEP

fn id_attr(&self, attr: Attr) -> IdedAttr

Computes and caches the Id of an Attr.

async fn precheck_attrs_for_registration( &self, attrs: &HashMap<Id, IdedAttr>, attr_states: &mut HashMap<Id, (AttrState, UpdateVersion)>, retrieved_attr_states: &mut bool, register_only_with_unique_attrs: bool, ) -> Result<Option<EnterResp>>

Pre-checks whether the given attributes in attrs are suitable for registering a new user.

Potential problems:

1. None of the given attributes is bannable.
2. One of the attributes is banned
3. One of the attributes already identifies another user.
4. One if the attributes already bans another user (if register_only_with_unique_attrs is set

Might try to retrieve attribute states for attributes not already in attr_states, and will add those to attr_states. If it did, will set retrieved_attr_states.

Returns Ok(None) when there are no issues.

The situation can, of course, change between the time of the check and the time of registration.

pub(super) async fn handle_user_refresh( app: Rc<Self>, auth_token: Header<AuthToken>, ) -> Result<RefreshResp>

Implements RefreshEP

fn issue_auth_token( &self, user_state: &UserState, ) -> Result<Result<AuthTokenPackage, AuthTokenDeniedReason>>

Issues auth token for given user, if allowed

impl App

pub(super) fn open_auth_token( &self, auth_token: AuthToken, ) -> Result<Id, Opaque>

Opens the given AuthToken returning the enclosed user’s Id.

pub(super) fn open_auth_token_ext( &self, auth_token: AuthToken, accept_expired: bool, ) -> Result<Id, Opaque>

Like Self::open_auth_token, but with the option to accept an expired auth token.

pub(super) async fn open_auth_token_and_get_user_state( &self, auth_token: AuthToken, ) -> Result<Result<(UserState, UpdateVersion), Opaque>>

Opens the given AuthToken and retrieve the associated UserState.

Returns Ok(Err(Opaque)) when the auth token was invalid.

pub(super) async fn open_auth_token_and_get_user_state_ext( &self, auth_token: AuthToken, accept_expired: bool, ) -> Result<Result<(UserState, UpdateVersion), Opaque>>

Like Self::open_auth_token_and_get_user_state but with the option to accept an expired auth token.

impl App

pub async fn handle_user_card_pseud( app: Rc<Self>, auth_token: Header<AuthToken>, ) -> Result<CardPseudResp>

Implements api::phc::user::CardPseudEP endpoint.

impl App

pub(super) async fn handle_user_new_object( app: Rc<Self>, payload: Bytes, path: Path<(Handle,)>, __arg3: Header<AuthToken>, ) -> Result<StoreObjectResp>

Implements NewObjectEP

pub(super) async fn handle_user_overwrite_object( app: Rc<Self>, payload: Bytes, path: Path<(Handle, Id)>, __arg3: Header<AuthToken>, ) -> Result<StoreObjectResp>

Implements api::phc::user::OverwriteObjectEP

async fn handle_user_store_object( &self, payload: Bytes, handle: Handle, overwrite_hash: Option<Id>, auth_token: AuthToken, ) -> Result<StoreObjectResp>

Called by Self::handle_user_new_object and Self::handle_user_overwrite_object.

Note on the implementation

To add a user object we: (1) First add the UserObject to the object store, if its not there already; (2) Add a reference to that object in UserState; and (3) Delete the old UserObject object, if there is any.

This way, if the process fails between steps (1) and (2), the client will simply retry, and if the process fails between steps (2) and (3) we are only left with an orphaned object. (Which is not a big deal.)

pub(crate) async fn handle_user_get_object( app: Rc<Self>, path: Path<(Id, Id)>, ) -> Payload<Result<GetObjectResp>>

Implements GetObjectEP.

impl App

pub(crate) async fn handle_user_ppp( app: Rc<Self>, auth_token: Header<AuthToken>, ) -> Result<PppResp>

Implements PppEP.

pub(crate) async fn handle_user_hhpp( app: Rc<Self>, req: Json<HhppReq>, auth_token: Header<AuthToken>, ) -> Result<HhppResp>

Implements HhppEP.

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_di: 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.