Split out static state methods from StateHandler

synapse/state.py

@@ -16,6 +16,7 @@
 
 from twisted.internet import defer
 
+from synapse import event_auth
 from synapse.util.logutils import log_function
 from synapse.util.caches.expiringcache import ExpiringCache
 from synapse.util.metrics import Measure
@@ -335,7 +336,8 @@ class StateHandler(object):
                     [state_map[e_id] for key, e_id in st.items() if e_id in state_map]
                     for st in state_groups_ids.values()
                 ]
-                new_state, _ = self._resolve_events(
+                with Measure(self.clock, "state._resolve_events"):
+                    new_state, _ = Resolver.resolve_events(
                         state_sets, event_type, state_key
                     )
                 new_state = {
@@ -388,21 +390,31 @@ class StateHandler(object):
         logger.info(
             "Resolving state for %s with %d groups", event.room_id, len(state_sets)
         )
+        with Measure(self.clock, "state._resolve_events"):
             if event.is_state():
-            return self._resolve_events(
+                return Resolver.resolve_events(
                     state_sets, event.type, event.state_key
                 )
             else:
-            return self._resolve_events(state_sets)
+                return Resolver.resolve_events(state_sets)
 
-    def _resolve_events(self, state_sets, event_type=None, state_key=""):
+
+def _ordered_events(events):
+    def key_func(e):
+        return -int(e.depth), hashlib.sha1(e.event_id).hexdigest()
+
+    return sorted(events, key=key_func)
+
+
+class Resolver(object):
+    @staticmethod
+    def resolve_events(state_sets, event_type=None, state_key=""):
         """
         Returns
             (dict[(str, str), synapse.events.FrozenEvent], list[str]): a tuple
             (new_state, prev_states). new_state is a map from (type, state_key)
             to event. prev_states is a list of event_ids.
         """
-        with Measure(self.clock, "state._resolve_events"):
         state = {}
         for st in state_sets:
             for e in st:
@@ -436,7 +448,7 @@ class StateHandler(object):
         }
 
         try:
-                resolved_state = self._resolve_state_events(
+            resolved_state = Resolver._resolve_state_events(
                 conflicted_state, auth_events
             )
         except:
@@ -448,8 +460,8 @@ class StateHandler(object):
 
         return new_state, prev_states
 
-    @log_function
+    @staticmethod
-    def _resolve_state_events(self, conflicted_state, auth_events):
+    def _resolve_state_events(conflicted_state, auth_events):
         """ This is where we actually decide which of the conflicted state to
         use.
 
@@ -464,7 +476,7 @@ class StateHandler(object):
         if power_key in conflicted_state:
             events = conflicted_state[power_key]
             logger.debug("Resolving conflicted power levels %r", events)
-            resolved_state[power_key] = self._resolve_auth_events(
+            resolved_state[power_key] = Resolver._resolve_auth_events(
                 events, auth_events)
 
         auth_events.update(resolved_state)
@@ -472,7 +484,7 @@ class StateHandler(object):
         for key, events in conflicted_state.items():
             if key[0] == EventTypes.JoinRules:
                 logger.debug("Resolving conflicted join rules %r", events)
-                resolved_state[key] = self._resolve_auth_events(
+                resolved_state[key] = Resolver._resolve_auth_events(
                     events,
                     auth_events
                 )
@@ -482,7 +494,7 @@ class StateHandler(object):
         for key, events in conflicted_state.items():
             if key[0] == EventTypes.Member:
                 logger.debug("Resolving conflicted member lists %r", events)
-                resolved_state[key] = self._resolve_auth_events(
+                resolved_state[key] = Resolver._resolve_auth_events(
                     events,
                     auth_events
                 )
@@ -492,14 +504,15 @@ class StateHandler(object):
         for key, events in conflicted_state.items():
             if key not in resolved_state:
                 logger.debug("Resolving conflicted state %r:%r", key, events)
-                resolved_state[key] = self._resolve_normal_events(
+                resolved_state[key] = Resolver._resolve_normal_events(
                     events, auth_events
                 )
 
         return resolved_state
 
-    def _resolve_auth_events(self, events, auth_events):
+    @staticmethod
-        reverse = [i for i in reversed(self._ordered_events(events))]
+    def _resolve_auth_events(events, auth_events):
+        reverse = [i for i in reversed(_ordered_events(events))]
 
         auth_events = dict(auth_events)
 
@@ -507,23 +520,20 @@ class StateHandler(object):
         for event in reverse[1:]:
             auth_events[(prev_event.type, prev_event.state_key)] = prev_event
             try:
-                # FIXME: hs.get_auth() is bad style, but we need to do it to
-                # get around circular deps.
                 # The signatures have already been checked at this point
-                self.hs.get_auth().check(event, auth_events, do_sig_check=False)
+                event_auth.check(event, auth_events, do_sig_check=False)
                 prev_event = event
             except AuthError:
                 return prev_event
 
         return event
 
-    def _resolve_normal_events(self, events, auth_events):
+    @staticmethod
-        for event in self._ordered_events(events):
+    def _resolve_normal_events(events, auth_events):
+        for event in _ordered_events(events):
             try:
-                # FIXME: hs.get_auth() is bad style, but we need to do it to
-                # get around circular deps.
                 # The signatures have already been checked at this point
-                self.hs.get_auth().check(event, auth_events, do_sig_check=False)
+                event_auth.check(event, auth_events, do_sig_check=False)
                 return event
             except AuthError:
                 pass
@@ -531,9 +541,3 @@ class StateHandler(object):
         # Use the last event (the one with the least depth) if they all fail
         # the auth check.
         return event
-
-    def _ordered_events(self, events):
-        def key_func(e):
-            return -int(e.depth), hashlib.sha1(e.event_id).hexdigest()
-
-        return sorted(events, key=key_func)