Don't centralise registration of hooks and web resources

synapse/app/_base.py

@@ -35,6 +35,7 @@
 from synapse.app.phone_stats_home import start_phone_stats_home
 from synapse.config.homeserver import HomeServerConfig
 from synapse.crypto import context_factory
+from synapse.events.spamcheck import LegacySpamCheckerWrapper
 from synapse.logging.context import PreserveLoggingContext
 from synapse.metrics.background_process_metrics import wrap_as_background_process
 from synapse.metrics.jemalloc import setup_jemalloc_stats
@@ -343,6 +344,8 @@ def run_sighup(*args, **kwargs):
     for module, config in hs.config.modules.loaded_modules:
         module(config=config, api=module_api)
 
+    LegacySpamCheckerWrapper.load_modules(hs)
+
     # It is now safe to start your Synapse.
     hs.start_listening()
     hs.get_datastore().db_pool.start_profiling()

synapse/app/homeserver.py

@@ -125,7 +125,7 @@ def _listener_http(self, config: HomeServerConfig, listener_config: ListenerConf
             resources[path] = resource
 
         # Attach additional resources registered by modules.
-        resources.update(module_api.get_registered_web_resources())
+        resources.update(self._module_web_resources)
 
         # try to find something useful to redirect '/' to
         if WEB_CLIENT_PREFIX in resources:

synapse/config/modules.py

@@ -22,7 +22,7 @@ class ModulesConfig(Config):
     def read_config(self, config: dict, **kwargs):
         self.loaded_modules = []
 
-        configured_modules = config.get("modules", [])
+        configured_modules = config.get("modules") or []
         for i, module in enumerate(configured_modules):
             config_path = ("modules", "<item %i>" % i)
             if not isinstance(module, dict):

synapse/module_api/__init__.py

@@ -53,7 +53,7 @@ class ModuleApi:
     can register new users etc if necessary.
     """
 
-    def __init__(self, hs, auth_handler):
+    def __init__(self, hs: "HomeServer", auth_handler):
         self._hs = hs
 
         self._store = hs.get_datastore()
@@ -67,8 +67,7 @@ def __init__(self, hs, auth_handler):
         self._http_client = hs.get_simple_http_client()  # type: SimpleHttpClient
         self._public_room_list_manager = PublicRoomListManager(hs)
 
-        self._callbacks: Dict[str, List[Callable]] = {}
-        self._web_resources: Dict[str, IResource] = {}
+        self._spam_checker = hs.get_spam_checker()
 
     @property
     def http_client(self):
@@ -87,35 +86,10 @@ def public_room_list_manager(self):
         """
         return self._public_room_list_manager
 
-    def register_hook(self, fn_name: str, callback: Callable):
-        """Registers the given callback as a hook with the given name.
-
-        This function must be called in the __init__ method of the modules using it.
-
-        If multiple modules register the same hook, their callbacks will be run in the
-        same order as the modules appear in the configuration file (highest first).
-
-        Args:
-            fn_name: The hook name.
-            callback: The function to call for this hook.
-        """
-        if fn_name not in self._callbacks.keys():
-            self._callbacks[fn_name] = [callback]
-            return
-
-        self._callbacks[fn_name].append(callback)
-
-    def get_registered_hook(self, fn_name: str) -> List[Callable]:
-        """Get the callbacks registered by modules for the given hook name.
-
-        Args:
-            fn_name: The name of the hook.
-
-        Returns:
-            The callbacks implementing the hook, or an empty list if there is no callback
-            for this hook.
-        """
-        return self._callbacks.get(fn_name, [])
+    @property
+    def register_spam_checker_callbacks(self):
+        """Registers callbacks for spam checking capabilities."""
+        return self._spam_checker.register_callbacks
 
     def register_web_resource(self, path: str, resource: IResource):
         """Registers a web resource to be served at the given path.
@@ -129,19 +103,7 @@ def register_web_resource(self, path: str, resource: IResource):
             path: The path to register the resource for.
             resource: The resource to attach to this path.
         """
-        # Don't register a resource that's already been registered. Like with hooks, we
-        # want to give priority to the module that's the highest in the configuration
-        # file, so in case of a conflict we keep the resource registered by this module.
-        if path not in self._web_resources.keys():
-            self._web_resources[path] = resource
-
-    def get_registered_web_resources(self) -> Dict[str, IResource]:
-        """Get the web resources registered by modules.
-
-        Returns:
-            A dict associating a path with the resource to attach to it.
-        """
-        return self._web_resources
+        self._hs.register_module_web_resource(path, resource)
 
     def get_user_by_req(self, req, allow_guest=False):
         """Check the access_token provided for a request

synapse/server.py

@@ -37,6 +37,7 @@
 from twisted.internet import defer
 from twisted.mail.smtp import sendmail
 from twisted.web.iweb import IPolicyForHTTPS
+from twisted.web.resource import IResource
 
 from synapse.api.auth import Auth
 from synapse.api.filtering import Filtering
@@ -257,6 +258,22 @@ def __init__(
 
         self.datastores = None  # type: Optional[Databases]
 
+        self._module_web_resources: Dict[str, IResource] = {}
+
+    def register_module_web_resource(self, path: str, resource: IResource):
+        """Allows a module to register a web resource to be served at the given path.
+
+        If multiple modules register a resource for the same path, the module that
+        appears the highest in the configuration file takes priority.
+
+        Args:
+            path: The path to register the resource for.
+            resource: The resource to attach to this path.
+        """
+        # Don't register a resource that's already been registered.
+        if path not in self._module_web_resources.keys():
+            self._module_web_resources[path] = resource
+
     def get_instance_id(self) -> str:
         """A unique ID for this synapse process instance.