From dce27715882bd73baa1e1db9c769d373b45152b9 Mon Sep 17 00:00:00 2001 From: Tulir Asokan Date: Tue, 16 Oct 2018 22:15:35 +0300 Subject: [PATCH] Make it run --- maubot/__main__.py | 24 +++++++++++++++-- maubot/__meta__.py | 2 +- maubot/config.py | 14 ++++++++++ maubot/db.py | 2 +- maubot/loader/__init__.py | 2 +- maubot/loader/abc.py | 9 +++++++ maubot/loader/zip.py | 54 ++++++++++++++++++++++++--------------- maubot/server.py | 9 ++++--- 8 files changed, 88 insertions(+), 28 deletions(-) diff --git a/maubot/__main__.py b/maubot/__main__.py index 76dc72a..f91b30d 100644 --- a/maubot/__main__.py +++ b/maubot/__main__.py @@ -20,17 +20,22 @@ import argparse import asyncio import copy import sys +import os from .config import Config from .db import Base, init as init_db from .server import MaubotServer from .client import Client, init as init_client +from .loader import ZippedPluginLoader, MaubotZipImportError from .__meta__ import __version__ parser = argparse.ArgumentParser(description="A plugin-based Matrix bot system.", prog="python -m maubot") parser.add_argument("-c", "--config", type=str, default="config.yaml", metavar="", help="the path to your config file") +parser.add_argument("-b", "--base-config", type=str, default="example-config.yaml", + metavar="", help="the path to the example config " + "(for automatic config updates)") args = parser.parse_args() config = Config(args.config, args.base_config) @@ -38,13 +43,14 @@ config.load() config.update() logging.config.dictConfig(copy.deepcopy(config["logging"])) -log = logging.getLogger("maubot") +log = logging.getLogger("maubot.init") log.debug(f"Initializing maubot {__version__}") db_engine: sql.engine.Engine = sql.create_engine(config["database"]) db_factory = orm.sessionmaker(bind=db_engine) db_session = orm.scoping.scoped_session(db_factory) -Base.metadata.bind=db_engine +Base.metadata.bind = db_engine +Base.metadata.create_all() loop = asyncio.get_event_loop() @@ -52,8 +58,22 @@ init_db(db_session) init_client(loop) server = MaubotServer(config, loop) +loader_log = logging.getLogger("maubot.loader.zip") +loader_log.debug("Preloading plugins...") +for directory in config["plugin_directories"]: + for file in os.listdir(directory): + if not file.endswith(".mbp"): + continue + path = os.path.join(directory, file) + try: + loader = ZippedPluginLoader.get(path) + loader_log.debug(f"Preloaded plugin {loader.id} from {loader.path}.") + except MaubotZipImportError: + loader_log.exception(f"Failed to load plugin at {path}.") + try: loop.run_until_complete(server.start()) + log.debug("Startup actions complete, running forever.") loop.run_forever() except KeyboardInterrupt: log.debug("Keyboard interrupt received, stopping...") diff --git a/maubot/__meta__.py b/maubot/__meta__.py index 038c1c1..9792e10 100644 --- a/maubot/__meta__.py +++ b/maubot/__meta__.py @@ -1 +1 @@ -__version__ = "0.1.0+dev" +__version__ = "0.1.0.dev1" diff --git a/maubot/config.py b/maubot/config.py index bbcbba0..d9f719f 100644 --- a/maubot/config.py +++ b/maubot/config.py @@ -13,14 +13,28 @@ # # You should have received a copy of the GNU Affero General Public License # along with this program. If not, see . +import random +import string + from mautrix.util import BaseConfig class Config(BaseConfig): + @staticmethod + def _new_token() -> str: + return "".join(random.choice(string.ascii_lowercase + string.digits) for _ in range(64)) + def update(self): base, copy, copy_dict = self._pre_update() copy("database") copy("plugin_directories") + copy("server.hostname") + copy("server.port") copy("server.listen") copy("server.base_path") + shared_secret = self["server.shared_secret"] + if shared_secret is None or shared_secret == "generate": + base["server.shared_secret"] = self._new_token() + else: + base["server.shared_secret"] = shared_secret copy("logging") diff --git a/maubot/db.py b/maubot/db.py index fd4e4cc..8a3d428 100644 --- a/maubot/db.py +++ b/maubot/db.py @@ -60,7 +60,7 @@ class DBPlugin(Base): nullable=False) -class DBClient(ClientStore, Base): +class DBClient(Base): query: Query __tablename__ = "client" diff --git a/maubot/loader/__init__.py b/maubot/loader/__init__.py index 552e342..304cc57 100644 --- a/maubot/loader/__init__.py +++ b/maubot/loader/__init__.py @@ -1,2 +1,2 @@ from .abc import PluginLoader, PluginClass -from .zip import ZippedPluginLoader +from .zip import ZippedPluginLoader, MaubotZipImportError diff --git a/maubot/loader/abc.py b/maubot/loader/abc.py index 71c6ce3..92d01f6 100644 --- a/maubot/loader/abc.py +++ b/maubot/loader/abc.py @@ -21,12 +21,21 @@ from ..plugin_base import Plugin PluginClass = TypeVar("PluginClass", bound=Plugin) +class IDConflictError(Exception): + pass + + class PluginLoader(ABC): id_cache: Dict[str, 'PluginLoader'] = {} id: str version: str + @property + @abstractmethod + def source(self) -> str: + pass + @abstractmethod def load(self) -> Type[PluginClass]: pass diff --git a/maubot/loader/zip.py b/maubot/loader/zip.py index a69ccec..f6cf645 100644 --- a/maubot/loader/zip.py +++ b/maubot/loader/zip.py @@ -20,7 +20,7 @@ import configparser from ..lib.zipimport import zipimporter, ZipImportError from ..plugin_base import Plugin -from .abc import PluginLoader, PluginClass +from .abc import PluginLoader, PluginClass, IDConflictError class MaubotZipImportError(Exception): @@ -36,35 +36,50 @@ class ZippedPluginLoader(PluginLoader): modules: List[str] main_class: str main_module: str - loaded: bool + _loaded: Type[PluginClass] _importer: zipimporter def __init__(self, path: str) -> None: self.path = path self.id = None - self.loaded = False + self._loaded = None self._load_meta() self._run_preload_checks(self._get_importer()) + try: + existing = self.id_cache[self.id] + raise IDConflictError(f"Plugin with id {self.id} already loaded from {existing.source}") + except KeyError: + pass self.path_cache[self.path] = self self.id_cache[self.id] = self + @classmethod + def get(cls, path: str) -> 'ZippedPluginLoader': + try: + return cls.path_cache[path] + except KeyError: + return cls(path) + + @property + def source(self) -> str: + return self.path + def __repr__(self) -> str: return ("") + f"loaded={self._loaded}>") def _load_meta(self) -> None: try: file = ZipFile(self.path) data = file.read("maubot.ini") except FileNotFoundError as e: - raise MaubotZipImportError(f"Maubot plugin not found at {self.path}") from e + raise MaubotZipImportError("Maubot plugin not found") from e except BadZipFile as e: - raise MaubotZipImportError(f"File at {self.path} is not a maubot plugin") from e + raise MaubotZipImportError("File is not a maubot plugin") from e except KeyError as e: - raise MaubotZipImportError( - "File at {path} does not contain a maubot plugin definition") from e + raise MaubotZipImportError("File does not contain a maubot plugin definition") from e config = configparser.ConfigParser() try: config.read_string(data.decode("utf-8"), source=f"{self.path}/maubot.ini") @@ -77,8 +92,7 @@ class ZippedPluginLoader(PluginLoader): if "/" in main_class: main_module, main_class = main_class.split("/")[:2] except (configparser.Error, KeyError, IndexError, ValueError) as e: - raise MaubotZipImportError( - f"Maubot plugin definition in file at {self.path} is invalid") from e + raise MaubotZipImportError("Maubot plugin definition in file is invalid") from e if self.id and meta_id != self.id: raise MaubotZipImportError("Maubot plugin ID changed during reload") self.id, self.version, self.modules = meta_id, version, modules @@ -91,8 +105,7 @@ class ZippedPluginLoader(PluginLoader): importer.reset_cache() return importer except ZipImportError as e: - raise MaubotZipImportError( - f"File at {self.path} not found or not a maubot plugin") from e + raise MaubotZipImportError("File not found or not a maubot plugin") from e def _run_preload_checks(self, importer: zipimporter) -> None: try: @@ -102,29 +115,30 @@ class ZippedPluginLoader(PluginLoader): f"Main class {self.main_class} not in {self.main_module}") except ZipImportError as e: raise MaubotZipImportError( - f"Main module {self.main_module} not found in {self.path}") from e + f"Main module {self.main_module} not found in file") from e for module in self.modules: try: importer.find_module(module) except ZipImportError as e: - raise MaubotZipImportError(f"Module {module} not found in {self.path}") from e + raise MaubotZipImportError(f"Module {module} not found in file") from e - def load(self) -> Type[PluginClass]: - importer = self._get_importer(reset_cache=self.loaded) + def load(self, reset_cache: bool = False) -> Type[PluginClass]: + if self._loaded is not None and not reset_cache: + return self._loaded + importer = self._get_importer(reset_cache=reset_cache) self._run_preload_checks(importer) for module in self.modules: importer.load_module(module) - self.loaded = True main_mod = sys.modules[self.main_module] plugin = getattr(main_mod, self.main_class) if not issubclass(plugin, Plugin): - raise MaubotZipImportError( - f"Main class of plugin at {self.path} does not extend maubot.Plugin") + raise MaubotZipImportError("Main class of plugin does not extend maubot.Plugin") + self._loaded = plugin return plugin def reload(self) -> Type[PluginClass]: self.unload() - return self.load() + return self.load(reset_cache=True) def unload(self) -> None: for name, mod in list(sys.modules.items()): diff --git a/maubot/server.py b/maubot/server.py index 55a4b4a..7a666ec 100644 --- a/maubot/server.py +++ b/maubot/server.py @@ -16,7 +16,7 @@ from aiohttp import web import asyncio -from mautrix.api import PathBuilder +from mautrix.api import PathBuilder, Method from .config import Config from .__meta__ import __version__ @@ -29,13 +29,16 @@ class MaubotServer: self.config = config path = PathBuilder(config["server.base_path"]) - self.app.router.add_get(path.version, self.version) + self.add_route(Method.GET, path.version, self.version) as_path = PathBuilder(config["server.appservice_base_path"]) - self.app.router.add_put(as_path.transactions, self.handle_transaction) + self.add_route(Method.PUT, as_path.transactions, self.handle_transaction) self.runner = web.AppRunner(self.app) + def add_route(self, method: Method, path: PathBuilder, handler) -> None: + self.app.router.add_route(method.value, str(path), handler) + async def start(self) -> None: await self.runner.setup() site = web.TCPSite(self.runner, self.config["server.hostname"], self.config["server.port"])