move plugins init and stop from main to plugins

Author: GabrielSalla

docs/plugins/plugins.md

@@ -94,7 +94,7 @@ The `start` and `stop` functions must have the following signatures:
 ```python
 async def init(controller_enabled: bool, executor_enabled: bool): ...
 
-async def stop(): ...
+async def stop(controller_enabled: bool, executor_enabled: bool): ...
 ```
 
 ## Queues

src/main.py

@@ -22,25 +22,6 @@
 _logger = logging.getLogger("main")
 
 
-async def init_plugins_services(controller_enabled: bool, executor_enabled: bool) -> None:
-    """Initialize the plugins services"""
-    for plugin_name, plugin in plugins.loaded_plugins.items():
-        _logger.info(f"Loading plugin '{plugin_name}'")
-
-        plugin_services = getattr(plugin, "services", None)
-        if plugin_services is None:
-            _logger.info(f"Plugin '{plugin_name}' has no services")
-            continue
-
-        for service_name in plugin_services.__all__:
-            service = getattr(plugin_services, service_name)
-            if hasattr(service, "init"):
-                await service.init(controller_enabled, executor_enabled)
-                _logger.info(f"Service '{plugin_name}.{service_name}' initialized")
-            else:
-                _logger.warning(f"Service '{plugin_name}.{service_name}' has no 'init' function")
-
-
 async def init(controller_enabled: bool, executor_enabled: bool) -> None:
     """Initialize the application dependencies. Some of the components will behave differently if
     they start with or without the controller."""
@@ -53,35 +34,23 @@ async def init(controller_enabled: bool, executor_enabled: bool) -> None:
     await http_server.init(controller_enabled)
 
     plugins.load_plugins()
-    await init_plugins_services(controller_enabled, executor_enabled)
+    await plugins.services.init_plugin_services(controller_enabled, executor_enabled)
 
     # The following modules depend on the plugins being loaded
     await databases.init()
     await message_queue.init()
 
 
-async def stop_plugins_services() -> None:
-    """Stop the plugins services"""
-    for plugin_name, plugin in plugins.loaded_plugins.items():
-        _logger.info(f"Stopping plugin '{plugin_name}'")
-
-        plugin_services = getattr(plugin, "services", None)
-        if plugin_services is None:
-            continue
-
-        for service_name in plugin_services.__all__:
-            service = getattr(plugin_services, service_name)
-            if hasattr(service, "stop"):
-                await protected_task(service.stop())
-
-
-async def finish() -> None:
+async def finish(controller_enabled: bool, executor_enabled: bool) -> None:
     """Finish the application, making sure any exception won't impact other closing tasks"""
     await protected_task(_logger, http_server.wait_stop())
     await protected_task(_logger, monitors_loader.wait_stop())
     await protected_task(_logger, databases.close())
     await protected_task(_logger, internal_database.close())
-    await protected_task(_logger, plugins.services.stop())
+    await protected_task(
+        _logger,
+        plugins.services.stop_plugin_services(controller_enabled, executor_enabled),
+    )
 
 
 async def main() -> None:
@@ -103,7 +72,10 @@ async def main() -> None:
     tasks = [modes[mode]() for mode in operation_modes]
     await asyncio.gather(*tasks)
 
-    await finish()
+    await finish(
+        controller_enabled="controller" in operation_modes,
+        executor_enabled="executor" in operation_modes,
+    )
 
 
 if __name__ == "__main__":

src/plugins/__init__.py

@@ -1,11 +1,19 @@
 from types import ModuleType
 
+from . import services
 from .plugins_loader import load_plugins as __load_plugins
 
 loaded_plugins: dict[str, ModuleType]
 
 
 def load_plugins() -> dict[str, ModuleType]:
+    """Load the plugins and return it as a dictionary"""
     global loaded_plugins
     loaded_plugins = __load_plugins()
     return loaded_plugins
+
+
+__all__ = [
+    "load_plugins",
+    "services",
+]

src/plugins/services.py

@@ -0,0 +1,61 @@
+import logging
+from types import ModuleType
+
+from utils.exception_handling import protected_task
+
+_logger = logging.getLogger("plugins.services")
+
+
+async def _plugin_service_run(
+    plugin_name: str,
+    plugin: ModuleType,
+    function_name: str,
+    controller_enabled: bool,
+    executor_enabled: bool,
+) -> None:
+    """Run a function of a plugin service, used to initialize or stop the services"""
+    plugin_services = getattr(plugin, "services", None)
+    if plugin_services is None:
+        _logger.info(f"Plugin '{plugin_name}' has no services")
+        return
+
+    plugin_services_names = getattr(plugin_services, "__all__", None)
+    if plugin_services_names is None:
+        _logger.warning(f"Plugin '{plugin_name}' has no '__all__' attribute in services")
+        return
+
+    for service_name in plugin_services_names:
+        service = getattr(plugin_services, service_name, None)
+        if service is None:
+            _logger.warning(f"Service '{plugin_name}.{service_name}' not found")
+            continue
+
+        target_function = getattr(service, function_name, None)
+        if target_function is None:
+            _logger.warning(
+                f"Service '{plugin_name}.{service_name}' has no '{function_name}' function"
+            )
+            continue
+
+        _logger.info(f"Running '{plugin_name}.{service_name}.{function_name}'")
+        await protected_task(_logger, target_function(controller_enabled, executor_enabled))
+
+
+async def init_plugin_services(controller_enabled: bool, executor_enabled: bool) -> None:
+    """Initialize the plugins services"""
+    # Import loaded plugins here after all the plugins are loaded
+    from . import load_plugins
+
+    for plugin_name, plugin in load_plugins().items():
+        _logger.info(f"Starting plugin '{plugin_name}' services")
+        await _plugin_service_run(plugin_name, plugin, "init", controller_enabled, executor_enabled)
+
+
+async def stop_plugin_services(controller_enabled: bool, executor_enabled: bool) -> None:
+    """Stop the plugins services"""
+    # Import loaded plugins here after all the plugins are loaded
+    from . import load_plugins
+
+    for plugin_name, plugin in load_plugins().items():
+        _logger.info(f"Stopping plugin '{plugin_name}' services")
+        await _plugin_service_run(plugin_name, plugin, "stop", controller_enabled, executor_enabled)

src/plugins/slack/services/websocket.py

@@ -96,7 +96,7 @@ async def init(controller_enabled: bool, executor_enabled: bool) -> None:  # pra
     await _handler.connect_async()
 
 
-async def stop() -> None:  # pragma: no cover
+async def stop(controller_enabled: bool, executor_enabled: bool) -> None:  # pragma: no cover
     global _handler
 
     if _handler is not None: