synapse/state.py
def compute_event_context(self, event, old_state=None):
        """Build an EventContext structure for the event.

        This works out what the current state should be for the event, and
        generates a new state group if necessary.

        Args:
            event (synapse.events.EventBase):
            old_state (dict|None): The state at the event if it can't be
                calculated from existing events. This is normally only specified
                when receiving an event from federation where we don't have the
                prev events for, e.g. when backfilling.
        Returns:
            synapse.events.snapshot.EventContext:
        """

        if event.internal_metadata.is_outlier():
            # If this is an outlier, then we know it shouldn't have any current
            # state. Certainly store.get_current_state won't return any, and
            # persisting the event won't store the state group.
            context = EventContext()
            if old_state:
                context.prev_state_ids = {
                    (s.type, s.state_key): s.event_id for s in old_state
                }
                if event.is_state():
                    context.current_state_ids = dict(context.prev_state_ids)
                    key = (event.type, event.state_key)
                    context.current_state_ids[key] = event.event_id
                else:
                    context.current_state_ids = context.prev_state_ids
            else:
                context.current_state_ids = {}
                context.prev_state_ids = {}
            context.prev_state_events = []

            # We don't store state for outliers, so we don't generate a state
            # froup for it.
            context.state_group = None

            defer.returnValue(context)

        if old_state:
            # We already have the state, so we don't need to calculate it.
            # Let's just correctly fill out the context and create a
            # new state group for it.

            context = EventContext()
            context.prev_state_ids = {
                (s.type, s.state_key): s.event_id for s in old_state
            }

            if event.is_state():
                key = (event.type, event.state_key)
                if key in context.prev_state_ids:
                    replaces = context.prev_state_ids[key]
                    if replaces != event.event_id:  # Paranoia check
                        event.unsigned["replaces_state"] = replaces
                context.current_state_ids = dict(context.prev_state_ids)
                context.current_state_ids[key] = event.event_id
            else:
                context.current_state_ids = context.prev_state_ids

            context.state_group = yield self.store.store_state_group(
                event.event_id,
                event.room_id,
                prev_group=None,
                delta_ids=None,
                current_state_ids=context.current_state_ids,
            )

            context.prev_state_events = []
            defer.returnValue(context)

        logger.debug("calling resolve_state_groups from compute_event_context")
        entry = yield self.resolve_state_groups_for_events(
            event.room_id, [e for e, _ in event.prev_events],
        )

        curr_state = entry.state

        context = EventContext()
        context.prev_state_ids = curr_state
        if event.is_state():
            # If this is a state event then we need to create a new state
            # group for the state after this event.

            key = (event.type, event.state_key)
            if key in context.prev_state_ids:
                replaces = context.prev_state_ids[key]
                event.unsigned["replaces_state"] = replaces

            context.current_state_ids = dict(context.prev_state_ids)
            context.current_state_ids[key] = event.event_id

            if entry.state_group:
                # If the state at the event has a state group assigned then
                # we can use that as the prev group
                context.prev_group = entry.state_group
                context.delta_ids = {
                    key: event.event_id
                }
            elif entry.prev_group:
                # If the state at the event only has a prev group, then we can
                # use that as a prev group too.
                context.prev_group = entry.prev_group
                context.delta_ids = dict(entry.delta_ids)
                context.delta_ids[key] = event.event_id

            context.state_group = yield self.store.store_state_group(
                event.event_id,
                event.room_id,
                prev_group=context.prev_group,
                delta_ids=context.delta_ids,
                current_state_ids=context.current_state_ids,
            )
        else:
            context.current_state_ids = context.prev_state_ids
            context.prev_group = entry.prev_group
            context.delta_ids = entry.delta_ids

            if entry.state_group is None:
                entry.state_group = yield self.store.store_state_group(
                    event.event_id,
                    event.room_id,
                    prev_group=entry.prev_group,
                    delta_ids=entry.delta_ids,
                    current_state_ids=context.current_state_ids,
                )
                entry.state_id = entry.state_group

            context.state_group = entry.state_group

        context.prev_state_events = []
        defer.returnValue(context)
Build an EventContext structure for the event.

        This works out what the current state should be for the event, and
        generates a new state group if necessary.

        Args:
            event (synapse.events.EventBase):
            old_state (dict|None): The state at the event if it can't be
                calculated from existing events. This is normally only specified
                when receiving an event from federation where we don't have the
                prev events for, e.g. when backfilling.
        Returns:
            synapse.events.snapshot.EventContext:
        
Build an EventContext structure for the event.
This works out what the current state should be for the event, and
generates a new state group if necessary.
Build an EventContext structure for the event . This works out what the current state should be for the event and generates a new state group if necessary .
def compute_event_context(self, event, old_state=None):
        if event.internal_metadata.is_outlier():
            context = EventContext()
            if old_state:
                context.prev_state_ids = {
                    (s.type, s.state_key): s.event_id for s in old_state
                }
                if event.is_state():
                    context.current_state_ids = dict(context.prev_state_ids)
                    key = (event.type, event.state_key)
                    context.current_state_ids[key] = event.event_id
                else:
                    context.current_state_ids = context.prev_state_ids
            else:
                context.current_state_ids = {}
                context.prev_state_ids = {}
            context.prev_state_events = []
            context.state_group = None
            defer.returnValue(context)
        if old_state:
            context = EventContext()
            context.prev_state_ids = {
                (s.type, s.state_key): s.event_id for s in old_state
            }
            if event.is_state():
                key = (event.type, event.state_key)
                if key in context.prev_state_ids:
                    replaces = context.prev_state_ids[key]
                    if replaces != event.event_id:  
                        event.unsigned["replaces_state"] = replaces
                context.current_state_ids = dict(context.prev_state_ids)
                context.current_state_ids[key] = event.event_id
            else:
                context.current_state_ids = context.prev_state_ids
            context.state_group = yield self.store.store_state_group(
                event.event_id,
                event.room_id,
                prev_group=None,
                delta_ids=None,
                current_state_ids=context.current_state_ids,
            )
            context.prev_state_events = []
            defer.returnValue(context)
        logger.debug("calling resolve_state_groups from compute_event_context")
        entry = yield self.resolve_state_groups_for_events(
            event.room_id, [e for e, _ in event.prev_events],
        )
        curr_state = entry.state
        context = EventContext()
        context.prev_state_ids = curr_state
        if event.is_state():
            key = (event.type, event.state_key)
            if key in context.prev_state_ids:
                replaces = context.prev_state_ids[key]
                event.unsigned["replaces_state"] = replaces
            context.current_state_ids = dict(context.prev_state_ids)
            context.current_state_ids[key] = event.event_id
            if entry.state_group:
                context.prev_group = entry.state_group
                context.delta_ids = {
                    key: event.event_id
                }
            elif entry.prev_group:
                context.prev_group = entry.prev_group
                context.delta_ids = dict(entry.delta_ids)
                context.delta_ids[key] = event.event_id
            context.state_group = yield self.store.store_state_group(
                event.event_id,
                event.room_id,
                prev_group=context.prev_group,
                delta_ids=context.delta_ids,
                current_state_ids=context.current_state_ids,
            )
        else:
            context.current_state_ids = context.prev_state_ids
            context.prev_group = entry.prev_group
            context.delta_ids = entry.delta_ids
            if entry.state_group is None:
                entry.state_group = yield self.store.store_state_group(
                    event.event_id,
                    event.room_id,
                    prev_group=entry.prev_group,
                    delta_ids=entry.delta_ids,
                    current_state_ids=context.current_state_ids,
                )
                entry.state_id = entry.state_group
            context.state_group = entry.state_group
        context.prev_state_events = []
        defer.returnValue(context)
def compute_event_context ( self , event , old_state = None ) : if event . internal_metadata . is_outlier ( ) : context = EventContext ( ) if old_state : context . prev_state_ids = { ( s . type , s . state_key ) : s . event_id for s in old_state } if event . is_state ( ) : context . current_state_ids = dict ( context . prev_state_ids ) key = ( event . type , event . state_key ) context . current_state_ids [ key ] = event . event_id else : context . current_state_ids = context . prev_state_ids else : context . current_state_ids = { } context . prev_state_ids = { } context . prev_state_events = [ ] context . state_group = None defer . returnValue ( context ) if old_state : context = EventContext ( ) context . prev_state_ids = { ( s . type , s . state_key ) : s . event_id for s in old_state } if event . is_state ( ) : key = ( event . type , event . state_key ) if key in context . prev_state_ids : replaces = context . prev_state_ids [ key ] if replaces != event . event_id : event . unsigned [ "replaces_state" ] = replaces context . current_state_ids = dict ( context . prev_state_ids ) context . current_state_ids [ key ] = event . event_id else : context . current_state_ids = context . prev_state_ids context . state_group = yield self . store . store_state_group ( event . event_id , event . room_id , prev_group = None , delta_ids = None , current_state_ids = context . current_state_ids , ) context . prev_state_events = [ ] defer . returnValue ( context ) logger . debug ( "calling resolve_state_groups from compute_event_context" ) entry = yield self . resolve_state_groups_for_events ( event . room_id , [ e for e , _ in event . prev_events ] , ) curr_state = entry . state context = EventContext ( ) context . prev_state_ids = curr_state if event . is_state ( ) : key = ( event . type , event . state_key ) if key in context . prev_state_ids : replaces = context . prev_state_ids [ key ] event . unsigned [ "replaces_state" ] = replaces context . current_state_ids = dict ( context . prev_state_ids ) context . current_state_ids [ key ] = event . event_id if entry . state_group : context . prev_group = entry . state_group context . delta_ids = { key : event . event_id } elif entry . prev_group : context . prev_group = entry . prev_group context . delta_ids = dict ( entry . delta_ids ) context . delta_ids [ key ] = event . event_id context . state_group = yield self . store . store_state_group ( event . event_id , event . room_id , prev_group = context . prev_group , delta_ids = context . delta_ids , current_state_ids = context . current_state_ids , ) else : context . current_state_ids = context . prev_state_ids context . prev_group = entry . prev_group context . delta_ids = entry . delta_ids if entry . state_group is None : entry . state_group = yield self . store . store_state_group ( event . event_id , event . room_id , prev_group = entry . prev_group , delta_ids = entry . delta_ids , current_state_ids = context . current_state_ids , ) entry . state_id = entry . state_group context . state_group = entry . state_group context . prev_state_events = [ ] defer . returnValue ( context )
Build an EventContext structure for the event.
Build an EventContext structure for the event .
"""Build an EventContext structure for the event.

        This works out what the current state should be for the event, and
        generates a new state group if necessary.

        Args:
            event (synapse.events.EventBase):
            old_state (dict|None): The state at the event if it can't be
                calculated from existing events. This is normally only specified
                when receiving an event from federation where we don't have the
                prev events for, e.g. when backfilling.
        Returns:
            synapse.events.snapshot.EventContext:
        """ # If this is an outlier, then we know it shouldn't have any current # state. Certainly store.get_current_state won't return any, and # persisting the event won't store the state group. # We don't store state for outliers, so we don't generate a state # froup for it. # We already have the state, so we don't need to calculate it. # Let's just correctly fill out the context and create a # new state group for it. # Paranoia check # If this is a state event then we need to create a new state # group for the state after this event. # If the state at the event has a state group assigned then # we can use that as the prev group # If the state at the event only has a prev group, then we can # use that as a prev group too.
None
synapse.events.snapshot.EventContext
self
event
None
old_state
The state at the event if it can't be
calculated from existing events. This is normally only specified
when receiving an event from federation where we don't have the
prev events for, e.g. when backfilling.
The state at the event if it can ' t be calculated from existing events . This is normally only specified when receiving an event from federation where we don ' t have the prev events for e . g . when backfilling .