Struct Service 

pub struct Service {
    services: Arc<OnceServices>,
    channel: (Sender<Msg>, Receiver<Msg>),
    transport: Arc<dyn Transport>,
    select: Arc<dyn Select>,
    capacity: usize,
}

Coordinates coalesced, validated federation fetches with candidate failover.

A single worker owns all in-flight state and admits at most 256 distinct fetches at once; additional keys wait in its pending queue. Fetches have no whole-operation deadline or per-server fairness scheduler.

Fields

services: Arc<OnceServices>

channel: (Sender<Msg>, Receiver<Msg>)

transport: Arc<dyn Transport>

select: Arc<dyn Select>

capacity: usize

Implementations

impl Service

pub(super) async fn validate(&self, opts: &Opts, bytes: &[u8]) -> Result

Applies poison detection before a fetched response is accepted.

When check_conforms is enabled, malformed JSON rolls over to the next candidate; Backfill also rejects an empty batch while MissingEvents accepts one. Deep validation is limited to event and auth-event operations.

impl Service

async fn verify_pdu(&self, opts: &Opts, bytes: &[u8]) -> Result

Applies enabled event-ID and cryptographic checks to one PDU response.

Event verification errors are propagated, but its Verified classification is currently discarded, so check_hashes does not enforce a hash match.

impl Service

pub(super) async fn run_worker(self: Arc<Self>)

Runs the single owner task for request, deferral, and in-flight state.

The request map, pending queue, and fetch futures are owned exclusively by this task, so no lock guards them.

impl Service

async fn work_loop<'a>( &'a self, inflight: &mut HashMap<Key, Inflight>, pending: &mut VecDeque<Msg>, futures: &mut FuturesUnordered<BoxFuture<'a, (Key, Result<Arc<Outcome>, Failure>)>>, )

impl Service

fn on_request<'a>( &'a self, msg: Msg, inflight: &mut HashMap<Key, Inflight>, pending: &mut VecDeque<Msg>, futures: &FuturesUnordered<BoxFuture<'a, (Key, Result<Arc<Outcome>, Failure>)>>, )

impl Service

fn dispatch<'a>( &'a self, msg: Msg, inflight: &mut HashMap<Key, Inflight>, futures: &FuturesUnordered<BoxFuture<'a, (Key, Result<Arc<Outcome>, Failure>)>>, )

impl Service

fn push_attempt<'a>( &'a self, futures: &FuturesUnordered<BoxFuture<'a, (Key, Result<Arc<Outcome>, Failure>)>>, key: Key, opts: Arc<Opts>, weak: Weak<()>, )

Push one attempt future onto the worker’s set, yielding its key with the result so the worker can route it back. The lone construction site for the borrowed-future shape, shared by the fresh-dispatch and re-arm paths.

impl Service

fn on_complete<'a>( &'a self, key: Key, result: Result<Arc<Outcome>, Failure>, inflight: &mut HashMap<Key, Inflight>, pending: &mut VecDeque<Msg>, futures: &FuturesUnordered<BoxFuture<'a, (Key, Result<Arc<Outcome>, Failure>)>>, )

impl Service

async fn run_attempts( &self, opts: &Opts, interest: &Weak<()>, ) -> Result<Arc<Outcome>, Failure>

impl Service

async fn attempt( &self, server: OwnedServerName, opts: &Opts, ) -> (OwnedServerName, Option<Bytes>)

Fetch one candidate and validate it: Some(bytes) on a clean response, None on a transport error or a poisoned body. A miss is logged, never fatal, so it cannot cancel a sibling racing the same round.

impl Service

pub async fn fetch(&self, opts: Opts) -> Result<Arc<Outcome>>

Fetches raw response bytes over federation with coalescing and failover.

Requests coalesce only when their complete option identities match, except missing-event windows are order independent. The future resolves when one response passes every enabled check; candidate exhaustion, attempt limits, or round limits otherwise end it with failure.

Trait Implementations

impl Service for Service

fn build(args: &Args<'_>) -> Result<Arc<Self>>

Implement the construction of the service instance. Services are generally singletons so expect this to only be called once for a service type. Note that it may be called again after a server reload, but the prior instance will have been dropped first. Failure will shutdown the server with an error.

fn worker<'async_trait>( self: Arc<Self>, ) -> Pin<Box<dyn Future<Output = Result> + Send + 'async_trait>>

where Self: 'async_trait,

Implement the service’s worker loop. The service manager spawns a task and calls this function after all services have been built.

fn interrupt<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Interrupt the service. This is sent to initiate a graceful shutdown. The service worker should return from its work loop.

fn name(&self) -> &str

Return the name of the service. i.e. crate::service::make_name(std::module_path!())

fn clear_cache<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Clear any caches or similar runtime state.

fn memory_usage<'life0, 'life1, 'async_trait>( &'life0 self, _out: &'life1 mut (dyn Write + Send), ) -> Pin<Box<dyn Future<Output = Result> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Memory usage report in a markdown string.

fn unconstrained(&self) -> bool

Return true if the service worker opts out of the tokio cooperative budgeting. This can reduce tail latency at the risk of event loop starvation.