Struct RoomFactory 

pub(crate) struct RoomFactory {
    runtime_policy: RoomRuntimePolicy,
    metrics: Arc<RuntimeMetrics>,
    allocator: Mutex<RoomRuntimeAllocator>,
}

Cold-path constructor for rooms that are new to the directory.

RoomFactory keeps runtime-wide creation dependencies behind the manager so RoomManager::serve_room can focus on idempotent lookup and publication. Each call to Self::create returns an unpublished Room with fresh process-local placement. The caller must insert it in the directory before exposing it to other runtime entrypoints.

Fields

runtime_policy: RoomRuntimePolicy

Runtime-wide room rules cloned into each room.

Keeping the policy here makes every room start from the validated boot-time policy while still letting the room own its copy.

metrics: Arc<RuntimeMetrics>

Process metric catalog cloned into each room.

allocator: Mutex<RoomRuntimeAllocator>

Serialized allocator for process-local placement ids.

This keeps concurrent create requests from receiving the same runtime placement.

Implementations

impl RoomFactory

pub(crate) fn new( runtime_policy: RoomRuntimePolicy, metrics: Arc<RuntimeMetrics>, ) -> Self

Builds the factory for one RoomManager lifetime.

pub(crate) fn create( &self, issuer: &str, key: &str, config: &RoomConfig, ) -> Arc<Room>

Creates an unpublished room from one manager lookup miss

The room emits no creation diagnostics. RoomManager publishes it before emitting its creation event

fn allocate_runtime_context(&self) -> RoomRuntimeContext

Reserves runtime-local placement for one new room.

The primary router id is allocated here, but worker placement remains unset until the first session join assigns the room from live load data.

The mutex is poisoned-tolerant because placement allocation has no partial side effect beyond the counters themselves. Recovering the inner value keeps later room creation possible after an unrelated panic.

pub(super) fn allocate_spillover_router(&self) -> RouterId

reserve a new process-unique identifier for a spillover router

this provides the room engine with a thread-safe way to allocate new router identities on the fly when media load exceeds the primary worker capacity. the allocator lock is held only long enough to increment the counter, keeping the cold-path creation from blocking active request loops

Trait Implementations

impl Debug for RoomFactory

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.