Struct ServerState 

pub struct ServerState {

    pub config: ServerConfig,
    pub storage: Arc<dyn Storage>,
    pub cache: Arc<dyn DistributedCache>,
    pub crypto: Arc<dyn CryptoProvider>,
    pub token_service: Arc<dyn TokenService>,
    pub token_manager: Arc<dyn TokenIssuer>,
    pub plugin_registry: Arc<dyn PluginRegistry>,
    pub federation_manager: Arc<dyn FederationManager>,
    pub login_failure_tracker: Arc<LoginFailureTracker>,
    pub email_sender: Arc<dyn EmailSender>,
    pub broker_client: Arc<dyn BrokerClient>,
    pub logout_notifier: Arc<dyn SessionLogoutNotifier>,
    pub signing_key_reload: Arc<dyn Fn() + Send + Sync>,
    pub keyset_generation: Arc<AtomicU64>,
    pub event_listeners: HashMap<String, Arc<dyn EventListener>>,
}

Fields

config: ServerConfig

storage: Arc<dyn Storage>

cache: Arc<dyn DistributedCache>

crypto: Arc<dyn CryptoProvider>

token_service: Arc<dyn TokenService>

token_manager: Arc<dyn TokenIssuer>

plugin_registry: Arc<dyn PluginRegistry>

federation_manager: Arc<dyn FederationManager>

login_failure_tracker: Arc<LoginFailureTracker>

email_sender: Arc<dyn EmailSender>

broker_client: Arc<dyn BrokerClient>

Server-to-server client for identity brokering. A trait so tests can stub the external IdP; production uses ReqwestBrokerClient.

logout_notifier: Arc<dyn SessionLogoutNotifier>

Back-channel logout dispatcher: notifies clients with a backchannel_logout_uri whenever one of their sessions is destroyed. Fire-and-forget; NoOpSessionLogoutNotifier in tests that do not exercise logout delivery.

signing_key_reload: Arc<dyn Fn() + Send + Sync>

Same-node signing-key reload hook: invoked by the admin API after key rotation/disable so the running crypto provider and JWKS snapshot pick up the storage mutation immediately instead of waiting for the next JWKS polling tick. Spawns the reload onto the runtime; no-op in tests that do not wire the concrete provider.

keyset_generation: Arc<AtomicU64>

Monotonic counter bumped every time this node reloads the shared signing-key set (admin reload hook, JWKS poll on change). The cached discovery document embeds the signing-algorithm list, so rendered discovery entries validate against it.

event_listeners: HashMap<String, Arc<dyn EventListener>>

Event listeners addressable by name from a realm’s events_listeners. Always contains "logging"; unknown realm listener names are ignored at dispatch time.

Implementations

impl ServerState

pub fn typed_executor(&self) -> TypedFlowExecutor

Build a TypedFlowExecutor from the current plugin registry.

pub fn typed_executor_with_flows( &self, flows: &[FlowConfig], ) -> TypedFlowExecutor

Build a TypedFlowExecutor whose executor resolves sub-flow stages against flows (pass the realm’s full stored flow set).

pub async fn bound_flow_executor( &self, realm: &Realm, bound: Option<&str>, default_alias: &str, fallback: fn(RealmId) -> FlowConfig, ) -> (FlowConfig, TypedFlowExecutor)

Resolve the realm’s bound top-level flow and an executor that can run it: the flow set is loaded from storage per request — one indexed query on Postgres, trivial on the in-memory/json backends, and deliberately uncached so admin flow edits take effect immediately. The realm’s binding field (bound, None → default_alias) picks the top-level flow; when the read fails (logged) or the alias is not in storage, the fallback code constructor keeps bootstrapping and legacy rigs working. The executor is built over the full loaded list so sub_flow_alias stages resolve.

Only the browser and registration bindings are consumed at runtime (here and in the login/registration routes). The direct-grant, reset-credentials, and first-broker-login bindings exist for Keycloak-representation parity and admin delete-guardrails only — those paths never run the flow engine.

pub async fn resolve_realm( &self, segment: &str, ) -> Result<Option<Realm>, IssuerdError>

Resolve the realm segment from a request URL to a realm.

URLs carry the human-readable realm name — discovery documents and token issuers embed the realm name (see TokenManager::issuer_for_realm). Name lookup is therefore deterministic; the id lookup remains as a fallback so old id-spelled bookmarks/URLs keep resolving (deterministic if an admin ever names a realm after another realm’s id: the name wins). The by-name step goes through the shared realm cache; the id fallback stays uncached.

pub async fn resolve_issuer_realm( &self, issuer: &str, ) -> Result<Option<Realm>, IssuerdError>

Resolve the realm an iss claim belongs to.

Issuers are realm-NAME based ({issuer_url}/realms/{name}). The trailing /realms/ segment is extracted and resolved by name; callers then use realm.id for storage lookups. Tokens issued before the name-based switch (id-spelled issuers) are intentionally NOT resolved here — they are rejected.

pub async fn from_config(config: &ServerConfig) -> Result<Self, IssuerdError>

pub async fn from_components( config: &ServerConfig, storage: Arc<dyn Storage>, cache: Arc<dyn DistributedCache>, ) -> Result<Self, IssuerdError>

Build server state from pre-constructed shared components.

ServerState::from_config constructs storage and cache from the config and delegates here. Tests (and embeddings) call this directly to share one storage/cache pair across several state instances, simulating a multi-node cluster in one process. config.storage still decides the master-realm bootstrap and JWKS refresh task eligibility.

pub async fn from_components_with_email_sender( config: &ServerConfig, storage: Arc<dyn Storage>, cache: Arc<dyn DistributedCache>, email_sender: Arc<dyn EmailSender>, ) -> Result<Self, IssuerdError>

ServerState::from_components with an explicit EmailSender.

Tests inject a recording sender here so both state.email_sender and the plugin registry’s email-code authenticator capture it — mutating state.email_sender after construction would leave the registry’s mailer pointing at the previous sender.

Trait Implementations

impl Clone for ServerState

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.