Struct Service 

pub struct Service {
    pub stateinfo_cache: Mutex<LruCache<ShortStateHash, Vec<ShortStateInfo>>>,
    db: Data,
    services: Arc<OnceServices>,
}

Fields

stateinfo_cache: Mutex<LruCache<ShortStateHash, Vec<ShortStateInfo>>>

db: Data

services: Arc<OnceServices>

Implementations

impl Service

pub async fn load_shortstatehash_info( &self, shortstatehash: ShortStateHash, ) -> Result<Vec<ShortStateInfo>>

Returns a stack with info on shortstatehash, full state, added diff and removed diff for the selected shortstatehash and each parent layer.

impl Service

async fn cache_shortstatehash_info( &self, shortstatehash: ShortStateHash, stack: Vec<ShortStateInfo>, ) -> Result

Returns a stack with info on shortstatehash, full state, added diff and removed diff for the selected shortstatehash and each parent layer.

impl Service

async fn new_shortstatehash_info( &self, shortstatehash: ShortStateHash, ) -> Result<Vec<ShortStateInfo>>

impl Service

pub fn compress_state_events<'a, I>( &'a self, state: I, ) -> impl Stream<Item = CompressedStateEvent> + Send + 'a

where I: Iterator<Item = (&'a ShortStateKey, &'a EventId)> + Clone + Debug + Send + 'a,

impl Service

pub async fn compress_state_event( &self, shortstatekey: ShortStateKey, event_id: &EventId, ) -> CompressedStateEvent

impl Service

pub fn save_state_from_diff( &self, shortstatehash: ShortStateHash, statediffnew: Arc<CompressedState>, statediffremoved: Arc<CompressedState>, diff_to_sibling: usize, parent_states: Vec<ShortStateInfo>, ) -> Result

Creates a new shortstatehash that often is just a diff to an already existing shortstatehash and therefore very efficient.

There are multiple layers of diffs. The bottom layer 0 always contains the full state. Layer 1 contains diffs to states of layer 0, layer 2 diffs to layer 1 and so on. If layer n > 0 grows too big, it will be combined with layer n-1 to create a new diff on layer n-1 that’s based on layer n-2. If that layer is also too big, it will recursively fix above layers too.

• shortstatehash - Shortstatehash of this state
• statediffnew - Added to base. Each vec is shortstatekey+shorteventid
• statediffremoved - Removed from base. Each vec is shortstatekey+shorteventid
• diff_to_sibling - Approximately how much the diff grows each time for this layer
• parent_states - A stack with info on shortstatehash, full state, added diff and removed diff for each parent layer

impl Service

pub async fn save_state( &self, room_id: &RoomId, new_state_ids_compressed: Arc<CompressedState>, ) -> Result<HashSetCompressStateEvent>

Returns the new shortstatehash, and the state diff from the previous room state

impl Service

async fn get_statediff( &self, shortstatehash: ShortStateHash, ) -> Result<StateDiff>

impl Service

fn save_statediff(&self, shortstatehash: ShortStateHash, diff: &StateDiff)

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