Struct ruma_state_res::StateResolution

pub struct StateResolution;

Implementations

impl StateResolution

pub fn resolve<E: Event>(
    room_id: &RoomId,
    room_version: &RoomVersionId,
    state_sets: &[StateMap<EventId>],
    auth_events: Vec<Vec<EventId>>,
    event_map: &mut EventMap<Arc<E>>
) -> Result<StateMap<EventId>>

Resolve sets of state events as they come in. Internally StateResolution builds a graph and an auth chain to allow for state conflict resolution.

Arguments

• state_sets - The incoming state to resolve. Each StateMap represents a possible fork in the state of a room.

• auth_events - The full recursive set of auth_events for each event in the state_sets.

• event_map - The EventMap acts as a local cache of state, any event that is not found in the event_map will cause an unrecoverable Error in resolve.

pub fn separate(
    state_sets: &[StateMap<EventId>]
) -> (StateMap<EventId>, StateMap<Vec<EventId>>)

Split the events that have no conflicts from those that are conflicting. The return tuple looks like (unconflicted, conflicted).

State is determined to be conflicting if for the given key (EventType, StateKey) there is not exactly one eventId. This includes missing events, if one state_set includes an event that none of the other have this is a conflicting event.

pub fn get_auth_chain_diff(
    _room_id: &RoomId,
    auth_event_ids: &[Vec<EventId>]
) -> Result<BTreeSet<EventId>>

Returns a Vec of deduped EventIds that appear in some chains but not others.

pub fn reverse_topological_power_sort<E: Event>(
    room_id: &RoomId,
    events_to_sort: &[EventId],
    event_map: &mut EventMap<Arc<E>>,
    auth_diff: &BTreeSet<EventId>
) -> Vec<EventId>

Events are sorted from “earliest” to “latest”. They are compared using the negative power level (reverse topological ordering), the origin server timestamp and incase of a tie the EventIds are compared lexicographically.

The power level is negative because a higher power level is equated to an earlier (further back in time) origin server timestamp.

pub fn lexicographical_topological_sort<F>(
    graph: &BTreeMap<EventId, BTreeSet<EventId>>,
    key_fn: F
) -> Vec<EventId> where
    F: Fn(&EventId) -> (i64, MilliSecondsSinceUnixEpoch, EventId), 

Sorts the event graph based on number of outgoing/incoming edges, where key_fn is used as a tie breaker. The tie breaker happens based on power level, age, and event_id.

pub fn iterative_auth_check<E: Event>(
    room_id: &RoomId,
    room_version: &RoomVersion,
    events_to_check: &[EventId],
    unconflicted_state: &StateMap<EventId>,
    event_map: &mut EventMap<Arc<E>>
) -> Result<StateMap<EventId>>

Check the that each event is authenticated based on the events before it.

Returns

The unconflicted_state combined with the newly auth’ed events. So any event that fails the event_auth::auth_check will be excluded from the returned StateMap<EventId>.

For each events_to_check event we gather the events needed to auth it from the event_map or store and verify each event using the event_auth::auth_check function.

pub fn mainline_sort<E: Event>(
    room_id: &RoomId,
    to_sort: &[EventId],
    resolved_power_level: Option<&EventId>,
    event_map: &mut EventMap<Arc<E>>
) -> Vec<EventId>

Returns the sorted to_sort list of EventIds based on a mainline sort using the depth of resolved_power_level, the server timestamp, and the eventId.

The depth of the given event is calculated based on the depth of it’s closest “parent” power_level event. If there have been two power events the after the most recent are depth 0, the events before (with the first power level as a parent) will be marked as depth 1. depth 1 is “older” than depth 0.

Trait Implementations

impl Default for StateResolution

fn default() -> StateResolution

Returns the “default value” for a type.