Split out static state methods from StateHandler

1 files changed, 74 insertions, 70 deletions

diff --git a/synapse/state.py b/synapse/state.py
index b9d5627a82..c75499c3e0 100644
--- a/synapse/state.py
+++ b/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,9 +336,10 @@ 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(
-                    state_sets, event_type, state_key
-                )
+                with Measure(self.clock, "state._resolve_events"):
+                    new_state, _ = Resolver.resolve_events(
+                        state_sets, event_type, state_key
+                    )
                 new_state = {
                     key: e.event_id for key, e in new_state.items()
                 }
@@ -388,68 +390,78 @@ class StateHandler(object):
         logger.info(
             "Resolving state for %s with %d groups", event.room_id, len(state_sets)
         )
-        if event.is_state():
-            return self._resolve_events(
-                state_sets, event.type, event.state_key
-            )
-        else:
-            return self._resolve_events(state_sets)
+        with Measure(self.clock, "state._resolve_events"):
+            if event.is_state():
+                return Resolver.resolve_events(
+                    state_sets, event.type, event.state_key
+                )
+            else:
+                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:
-                    state.setdefault(
-                        (e.type, e.state_key),
-                        {}
-                    )[e.event_id] = e
-
-            unconflicted_state = {
-                k: v.values()[0] for k, v in state.items()
-                if len(v.values()) == 1
-            }
+        state = {}
+        for st in state_sets:
+            for e in st:
+                state.setdefault(
+                    (e.type, e.state_key),
+                    {}
+                )[e.event_id] = e
+
+        unconflicted_state = {
+            k: v.values()[0] for k, v in state.items()
+            if len(v.values()) == 1
+        }
 
-            conflicted_state = {
-                k: v.values()
-                for k, v in state.items()
-                if len(v.values()) > 1
-            }
+        conflicted_state = {
+            k: v.values()
+            for k, v in state.items()
+            if len(v.values()) > 1
+        }
 
-            if event_type:
-                prev_states_events = conflicted_state.get(
-                    (event_type, state_key), []
-                )
-                prev_states = [s.event_id for s in prev_states_events]
-            else:
-                prev_states = []
+        if event_type:
+            prev_states_events = conflicted_state.get(
+                (event_type, state_key), []
+            )
+            prev_states = [s.event_id for s in prev_states_events]
+        else:
+            prev_states = []
 
-            auth_events = {
-                k: e for k, e in unconflicted_state.items()
-                if k[0] in AuthEventTypes
-            }
+        auth_events = {
+            k: e for k, e in unconflicted_state.items()
+            if k[0] in AuthEventTypes
+        }
 
-            try:
-                resolved_state = self._resolve_state_events(
-                    conflicted_state, auth_events
-                )
-            except:
-                logger.exception("Failed to resolve state")
-                raise
+        try:
+            resolved_state = Resolver._resolve_state_events(
+                conflicted_state, auth_events
+            )
+        except:
+            logger.exception("Failed to resolve state")
+            raise
 
-            new_state = unconflicted_state
-            new_state.update(resolved_state)
+        new_state = unconflicted_state
+        new_state.update(resolved_state)
 
         return new_state, prev_states
 
-    @log_function
-    def _resolve_state_events(self, conflicted_state, auth_events):
+    @staticmethod
+    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):
-        reverse = [i for i in reversed(self._ordered_events(events))]
+    @staticmethod
+    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):
-        for event in self._ordered_events(events):
+    @staticmethod
+    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)