Struct Service 

pub struct Service {
    db: Data,
}

Stores and queries public room directory entries.

Each entry is keyed by room ID and optionally retains the alias used to publish it. A room without an entry is treated as private.

Fields

db: Data

Implementations

impl Service

pub fn set_public(&self, room_id: &RoomId, alias: Option<&RoomAliasId>)

Publishes a room in the directory.

The optional alias is stored with the room entry. Publishing without an alias stores an empty value while retaining public visibility.

impl Service

pub fn set_not_public(&self, room_id: &RoomId)

Removes a room from the public directory.

Removing an absent entry is harmless. Subsequent visibility queries report the room as private.

impl Service

pub async fn published_alias( &self, room_id: &RoomId, ) -> Result<OwnedRoomAliasId>

Returns the alias under which a room was published.

Rooms published without an alias store an empty value, which cannot deserialize as a room alias and therefore returns an error.

impl Service

pub fn public_rooms(&self) -> impl Stream<Item = &RoomId> + Send

Streams the room IDs currently published in the directory.

Each borrowed ID is valid only until the stream is polled again and must be copied before retention. Rows with unparsable room IDs are skipped.

impl Service

pub async fn is_public_room(&self, room_id: &RoomId) -> bool

Reports whether a room is currently public.

Visibility is determined by the presence of the room’s directory entry. Missing entries and failed lookups are treated as private.

impl Service

pub async fn visibility(&self, room_id: &RoomId) -> Visibility

Returns a room’s client-facing directory visibility.

A stored directory entry maps to [Visibility::Public]. Missing entries and failed lookups map to [Visibility::Private].

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 name(&self) -> &str

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

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