slidge 0.1.0b2__py3-none-any.whl → 0.1.1__py3-none-any.whl

slidge/__init__.py

@@ -1,37 +1,61 @@
-import slixmpp.plugins
-
-from .core.contact import LegacyContact, LegacyRoster
-from .core.gateway import BaseGateway
-from .core.session import BaseSession
-from .util import (
-    FormField,
-    SearchResult,
-    xep_0030,
-    xep_0055,
-    xep_0077,
-    xep_0084,
-    xep_0100,
-    xep_0115,
-    xep_0292,
-    xep_0333,
-    xep_0356,
-    xep_0356_old,
-    xep_0363,
-    xep_0461,
-)
-from .util.db import GatewayUser, user_store
-
-slixmpp.plugins.__all__.extend(
-    ["xep_0055", "xep_0292_provider", "xep_0356", "xep_0356_old", "xep_0461"]
-)
+"""
+The main slidge package.
+
+Contains importable classes for a minimal function :term:`Legacy Module`.
+"""
+
+import sys
+import warnings
+
+from . import slixfix  # noqa: F401
+from .command import FormField, SearchResult  # noqa: F401
+from .contact import LegacyContact, LegacyRoster  # noqa: F401
+from .core import config as global_config  # noqa: F401
+from .core.gateway import BaseGateway  # noqa: F401
+from .core.session import BaseSession  # noqa: F401
+from .group import LegacyBookmarks, LegacyMUC, LegacyParticipant  # noqa: F401
+from .util.db import GatewayUser, user_store  # noqa: F401
+from .util.types import MucType  # noqa: F401
+from .util.util import addLoggingLevel
+
+from .__main__ import main  # isort: skip
+
+
+def entrypoint(module_name: str) -> None:
+    """
+    Entrypoint to be used in ``__main__.py`` of
+    :term:`legacy modules <Legacy Module>`.
+
+    :param module_name: An importable :term:`Legacy Module`.
+    """
+    sys.argv.extend(["--legacy", module_name])
+    main()
+
+
+def formatwarning(message, category, filename, lineno, line=""):
+    return f"{filename}:{lineno}:{category.__name__}:{message}\n"
+
+
+warnings.formatwarning = formatwarning
+
 
 __all__ = [
     "BaseGateway",
     "BaseSession",
-    "GatewayUser",
-    "LegacyContact",
-    "LegacyRoster",
-    "FormField",
-    "SearchResult",
+    # For backwards compatibility, these names are still importable from the
+    # top-level slidge module, but this is deprecated.
+    # "GatewayUser",
+    # "LegacyBookmarks",
+    # "LegacyMUC",
+    # "LegacyContact",
+    # "LegacyParticipant",
+    # "LegacyRoster",
+    # "MucType",
+    # "FormField",
+    # "SearchResult",
+    "entrypoint",
     "user_store",
+    "global_config",
 ]
+
+addLoggingLevel()

slidge/__main__.py

@@ -1,119 +1,72 @@
 """
 Slidge can be configured via CLI args, environment variables and/or INI files.
+
 To use env vars, use this convention: ``--home-dir`` becomes ``HOME_DIR``.
+
+Everything in ``/etc/slidge/conf.d/*`` is automatically used.
+To use a plugin-specific INI file, put it in another dir,
+and launch slidge with ``-c /path/to/plugin-specific.conf``.
+Use the long version of the CLI arg without the double dash prefix inside this
+INI file, eg ``debug=true``.
+
+An example configuration file is available at
+https://git.sr.ht/~nicoco/slidge/tree/master/item/dev/confs/slidge-example.ini
 """
+
+import asyncio
 import importlib
 import logging
+import os
+import signal
 from pathlib import Path
 
 import configargparse
 
 from slidge import BaseGateway
-from slidge.core.pubsub import PepAvatar
+from slidge.core import config
+from slidge.core.cache import avatar_cache
+from slidge.migration import migrate
+from slidge.util.conf import ConfigModule
 from slidge.util.db import user_store
+from slidge.util.util import get_version  # noqa: F401
 
 
-# noinspection PyUnresolvedReferences
-def get_parser():
-    p = configargparse.ArgParser(
-        default_config_files=["/etc/slidge/conf.d/*.conf"], description=__doc__
+class MainConfig(ConfigModule):
+    def update_dynamic_defaults(self, args):
+        # force=True is needed in case we call a logger before this is reached,
+        # or basicConfig has no effect
+        logging.basicConfig(
+            level=args.loglevel,
+            filename=args.log_file,
+            force=True,
+            format=args.log_format,
+        )
+
+        if args.home_dir is None:
+            args.home_dir = Path("/var/lib/slidge") / str(args.jid)
+
+        if args.user_jid_validator is None:
+            args.user_jid_validator = ".*@" + args.server
+
+
+class SigTermInterrupt(Exception):
+    pass
+
+
+def get_configurator():
+    p = configargparse.ArgumentParser(
+        default_config_files=os.getenv(
+            "SLIDGE_CONF_DIR", "/etc/slidge/conf.d/*.conf"
+        ).split(":"),
+        description=__doc__,
     )
-    p.add(
+    p.add_argument(
         "-c",
         "--config",
         help="Path to a INI config file.",
         env_var="SLIDGE_CONFIG",
         is_config_file=True,
     )
-    p.add(
-        "--legacy-module",
-        help="Importable python module containing (at least) "
-        "a BaseGateway and a LegacySession subclass",
-        env_var="SLIDGE_LEGACY_MODULE",
-    )
-    p.add(
-        "-s",
-        "--server",
-        env_var="SLIDGE_SERVER",
-        required=True,
-        help="The XMPP server's host name.",
-    )
-    p.add(
-        "-p",
-        "--port",
-        default="5347",
-        env_var="SLIDGE_PORT",
-        help="The XMPP server's port for incoming component connections",
-    )
-    p.add(
-        "--secret",
-        required=True,
-        env_var="SLIDGE_SECRET",
-        help="The gateway component's secret (required to connect to the XMPP server)",
-    )
-    p.add(
-        "-j",
-        "--jid",
-        required=True,
-        env_var="SLIDGE_JID",
-        help="The gateway component's JID",
-    )
-    p.add(
-        "--upload-service",
-        env_var="SLIDGE_UPLOAD",
-        help="JID of an HTTP upload service the gateway can use. "
-        "This is optional, as it should be automatically determined via service discovery",
-    )
-    p.add(
-        "--home-dir",
-        env_var="SLIDGE_HOME_DIR",
-        help="Shelve file used to store persistent user data. "
-        "Defaults to /var/lib/slidge/${SLIDGE_JID}",
-    )
-    p.add(
-        "--admins",
-        env_var="SLIDGE_ADMINS",
-        nargs="*",
-        help="JIDs of the gateway admins",
-    )
-    p.add(
-        "--user-jid-validator",
-        env_var="SLIDGE_RESTRICT",
-        help="Regular expression to restrict user that can register to the gateway by JID. "
-        "Defaults to .*@${SLIDGE_SERVER}, forbids the gateway to JIDs "
-        "not using the same XMPP server as the gateway",
-    )
-    p.add(
-        "--secret-key",
-        env_var="SLIDGE_SECRET_KEY",
-        help="Encryption for disk storage",
-    )
-    p.add(
-        "--no-roster-push",
-        env_var="SLIDGE_NO_ROSTER_PUSH",
-        help="Do not fill users' rosters with legacy contacts automatically",
-        action="store_true",
-    )
-    p.add_argument(
-        "--avatar-size",
-        env_var="SLIDGE_AVATAR_SIZE",
-        type=int,
-        default=200,
-        help="Maximum image size (width and height), image ratio will be preserved",
-    )
-    p.add_argument(
-        "--upload-requester",
-        env_var="SLIDGE_UPLOAD_REQUESTER",
-        help="Set which JID should request the upload slots. Defaults to the component JID.",
-    )
-    p.add_argument(
-        "--ignore-delay-threshold",
-        env_var="SLIDGE_IGNORE_DELAY_THRESHOLD",
-        help="Threshold, in seconds, below which the <delay> information is stripped "
-        "out of emitted stanzas.",
-        default=300,
-    )
-
     p.add_argument(
         "-q",
         "--quiet",
@@ -133,34 +86,73 @@ def get_parser():
         const=logging.DEBUG,
         env_var="SLIDGE_DEBUG",
     )
-
-    return p
+    p.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+    )
+    configurator = MainConfig(config, p)
+    return configurator
 
 
-def main():
-    args, argv = get_parser().parse_known_args()
-    logging.basicConfig(level=args.loglevel)
+def get_parser():
+    return get_configurator().parser
 
-    if args.home_dir is None:
-        args.home_dir = Path("/var/lib/slidge") / args.jid
-    else:
-        args.home_dir = Path(args.home_dir)
 
-    if not args.home_dir.exists():
-        logging.info("Creating directory '%s'", args.home_dir)
-        args.home_dir.mkdir()
+def configure():
+    configurator = get_configurator()
+    args, unknown_argv = configurator.set_conf()
 
-    if args.user_jid_validator is None:
-        args.user_jid_validator = ".*@" + args.server
+    if not (h := config.HOME_DIR).exists():
+        logging.info("Creating directory '%s'", h)
+        h.mkdir()
 
-    db_file = Path(args.home_dir) / "slidge.db"
+    db_file = config.HOME_DIR / "slidge.db"
     user_store.set_file(db_file, args.secret_key)
 
-    PepAvatar.AVATAR_SIZE = args.avatar_size
+    avatar_cache.set_dir(h / "slidge_avatars_v2")
 
-    importlib.import_module(args.legacy_module)
-    gateway = BaseGateway.get_unique_subclass()(args)
-    gateway.config(argv)
+    config.UPLOAD_REQUESTER = config.UPLOAD_REQUESTER or config.JID.bare
+
+    return unknown_argv
+
+
+def handle_sigterm(_signum, _frame):
+    logging.info("Caught SIGTERM")
+    raise SigTermInterrupt
+
+
+def main():
+    signal.signal(signal.SIGTERM, handle_sigterm)
+
+    unknown_argv = configure()
+    logging.info("Starting slidge version %s", __version__)
+
+    legacy_module = importlib.import_module(config.LEGACY_MODULE)
+    logging.debug("Legacy module: %s", dir(legacy_module))
+    logging.info(
+        "Starting legacy module: '%s' version %s",
+        config.LEGACY_MODULE,
+        getattr(legacy_module, "__version__", "No version"),
+    )
+
+    if plugin_config_obj := getattr(
+        legacy_module, "config", getattr(legacy_module, "Config", None)
+    ):
+        logging.debug("Found a config object in plugin: %r", plugin_config_obj)
+        ConfigModule.ENV_VAR_PREFIX += (
+            f"_{config.LEGACY_MODULE.split('.')[-1].upper()}_"
+        )
+        logging.debug("Env var prefix: %s", ConfigModule.ENV_VAR_PREFIX)
+        ConfigModule(plugin_config_obj).set_conf(unknown_argv)
+    else:
+        if unknown_argv:
+            raise RuntimeError("Some arguments have not been recognized", unknown_argv)
+
+    migrate()
+
+    gateway: BaseGateway = BaseGateway.get_unique_subclass()()
+    avatar_cache.http = gateway.http
     gateway.connect()
 
     return_code = 0
@@ -168,8 +160,10 @@ def main():
         gateway.loop.run_forever()
     except KeyboardInterrupt:
         logging.debug("Received SIGINT")
+    except SigTermInterrupt:
+        logging.debug("Received SIGTERM")
     except SystemExit as e:
-        return_code = e.code
+        return_code = e.code  # type: ignore
         logging.debug("Exit called")
     except Exception as e:
         return_code = 2
@@ -182,15 +176,23 @@ def main():
             return_code = 3
         if gateway.is_connected():
             logging.debug("Gateway is connected, cleaning up")
-            gateway.shutdown()
+            gateway.loop.run_until_complete(asyncio.gather(*gateway.shutdown()))
             gateway.disconnect()
             gateway.loop.run_until_complete(gateway.disconnected)
         else:
             logging.debug("Gateway is not connected, no need to clean up")
+        user_store.close()
+        avatar_cache.close()
+        gateway.loop.run_until_complete(gateway.http.close())
         logging.info("Successful clean shut down")
     logging.debug("Exiting with code %s", return_code)
     exit(return_code)
 
 
+# this should be modified before publish, but if someone cloned from the repo,
+# it can help
+__version__ = get_version()
+
+
 if __name__ == "__main__":
     main()

slidge/command/__init__.py

@@ -0,0 +1,28 @@
+"""
+This module implements an unified API to define :term:`adhoc <Ad-hoc Command>`
+or :term:`chatbot <Chatbot Command>` commands. Just subclass a :class:`Command`,
+and make sures it is imported in your legacy module's ``__init__.py``.
+"""
+
+from . import admin, register, user  # noqa: F401
+from .base import (
+    Command,
+    CommandAccess,
+    CommandResponseType,
+    Confirmation,
+    Form,
+    FormField,
+    SearchResult,
+    TableResult,
+)
+
+__all__ = (
+    "Command",
+    "CommandAccess",
+    "CommandResponseType",
+    "Confirmation",
+    "Form",
+    "FormField",
+    "SearchResult",
+    "TableResult",
+)

slidge/command/adhoc.py

@@ -0,0 +1,258 @@
+import asyncio
+import functools
+import logging
+from functools import partial
+from typing import TYPE_CHECKING, Any, Callable, Optional, Union
+
+from slixmpp import JID, Iq  # type: ignore[attr-defined]
+from slixmpp.exceptions import XMPPError
+from slixmpp.plugins.xep_0004 import Form as SlixForm  # type: ignore[attr-defined]
+from slixmpp.plugins.xep_0030.stanza.items import DiscoItems
+
+from . import Command, CommandResponseType, Confirmation, Form, TableResult
+from .base import FormField
+
+if TYPE_CHECKING:
+    from ..core.gateway.base import BaseGateway
+    from ..core.session import BaseSession
+
+
+AdhocSessionType = dict[str, Any]
+
+
+class AdhocProvider:
+    """
+    A slixmpp-like plugin to handle adhoc commands, with less boilerplate and
+    untyped dict values than slixmpp.
+    """
+
+    def __init__(self, xmpp: "BaseGateway") -> None:
+        self.xmpp = xmpp
+        self._commands = dict[str, Command]()
+        self._categories = dict[str, list[Command]]()
+        xmpp.plugin["xep_0030"].set_node_handler(
+            "get_items",
+            jid=xmpp.boundjid,
+            node=self.xmpp.plugin["xep_0050"].stanza.Command.namespace,
+            handler=self.get_items,
+        )
+
+    async def __wrap_initial_handler(
+        self, command: Command, iq: Iq, adhoc_session: AdhocSessionType
+    ) -> AdhocSessionType:
+        ifrom = iq.get_from()
+        session = command.raise_if_not_authorized(ifrom)
+        result = await self.__wrap_handler(command.run, session, ifrom)
+        return await self.__handle_result(session, result, adhoc_session)
+
+    async def __handle_category_list(
+        self, category: str, iq: Iq, adhoc_session: AdhocSessionType
+    ) -> AdhocSessionType:
+        session = self.xmpp.get_session_from_stanza(iq)
+        commands = []
+        for command in self._categories[category]:
+            try:
+                command.raise_if_not_authorized(iq.get_from())
+            except XMPPError:
+                continue
+            commands.append(command)
+        return await self.__handle_result(
+            session,
+            Form(
+                category,
+                "",
+                [
+                    FormField(
+                        var="command",
+                        label="Command",
+                        type="list-single",
+                        options=[
+                            {"label": command.NAME, "value": str(i)}
+                            for i, command in enumerate(commands)
+                        ],
+                    )
+                ],
+                partial(self.__handle_category_choice, commands),
+            ),
+            adhoc_session,
+        )
+
+    async def __handle_category_choice(
+        self,
+        commands: list[Command],
+        form_values: dict[str, str],
+        session: "BaseSession[Any, Any]",
+        jid: JID,
+    ):
+        command = commands[int(form_values["command"])]
+        result = await self.__wrap_handler(command.run, session, jid)
+        return result
+
+    async def __handle_result(
+        self,
+        session: Optional["BaseSession[Any, Any]"],
+        result: CommandResponseType,
+        adhoc_session: AdhocSessionType,
+    ) -> AdhocSessionType:
+        if isinstance(result, str) or result is None:
+            adhoc_session["has_next"] = False
+            adhoc_session["next"] = None
+            adhoc_session["payload"] = None
+            adhoc_session["notes"] = [("info", result or "Success!")]
+            return adhoc_session
+
+        if isinstance(result, Form):
+            adhoc_session["next"] = partial(self.__wrap_form_handler, session, result)
+            adhoc_session["has_next"] = True
+            adhoc_session["payload"] = result.get_xml()
+            return adhoc_session
+
+        if isinstance(result, Confirmation):
+            adhoc_session["next"] = partial(self.__wrap_confirmation, session, result)
+            adhoc_session["has_next"] = True
+            adhoc_session["payload"] = result.get_form()
+            adhoc_session["next"] = partial(self.__wrap_confirmation, session, result)
+            return adhoc_session
+
+        if isinstance(result, TableResult):
+            adhoc_session["next"] = None
+            adhoc_session["has_next"] = False
+            adhoc_session["payload"] = result.get_xml()
+            return adhoc_session
+
+        raise XMPPError("internal-server-error", text="OOPS!")
+
+    @staticmethod
+    async def __wrap_handler(f: Union[Callable, functools.partial], *a, **k):  # type: ignore
+        try:
+            if asyncio.iscoroutinefunction(f):
+                return await f(*a, **k)
+            elif hasattr(f, "func") and asyncio.iscoroutinefunction(f.func):
+                return await f(*a, **k)
+            else:
+                return f(*a, **k)
+        except Exception as e:
+            log.debug("Exception in %s", f, exc_info=e)
+            raise XMPPError("internal-server-error", text=str(e))
+
+    async def __wrap_form_handler(
+        self,
+        session: Optional["BaseSession[Any, Any]"],
+        result: Form,
+        form: SlixForm,
+        adhoc_session: AdhocSessionType,
+    ) -> AdhocSessionType:
+        form_values = result.get_values(form)
+        new_result = await self.__wrap_handler(
+            result.handler,
+            form_values,
+            session,
+            adhoc_session["from"],
+            *result.handler_args,
+            **result.handler_kwargs,
+        )
+
+        return await self.__handle_result(session, new_result, adhoc_session)
+
+    async def __wrap_confirmation(
+        self,
+        session: Optional["BaseSession[Any, Any]"],
+        confirmation: Confirmation,
+        form: SlixForm,
+        adhoc_session: AdhocSessionType,
+    ) -> AdhocSessionType:
+        if form.get_values().get("confirm"):  # type: ignore[no-untyped-call]
+            result = await self.__wrap_handler(
+                confirmation.handler,
+                session,
+                adhoc_session["from"],
+                *confirmation.handler_args,
+                **confirmation.handler_kwargs,
+            )
+            if confirmation.success:
+                result = confirmation.success
+        else:
+            result = "You canceled the operation"
+
+        return await self.__handle_result(session, result, adhoc_session)
+
+    def register(self, command: Command, jid: Optional[JID] = None) -> None:
+        """
+        Register a command as a adhoc command.
+
+        this does not need to be called manually, ``BaseGateway`` takes care of
+        that.
+
+        :param command:
+        :param jid:
+        """
+        if jid is None:
+            jid = self.xmpp.boundjid
+        elif not isinstance(jid, JID):
+            jid = JID(jid)
+
+        if (category := command.CATEGORY) is None:
+            if command.NODE in self._commands:
+                raise RuntimeError(
+                    "There is already a command for the node '%s'", command.NODE
+                )
+            self._commands[command.NODE] = command
+            self.xmpp.plugin["xep_0050"].add_command(  # type: ignore[no-untyped-call]
+                jid=jid,
+                node=command.NODE,
+                name=command.NAME,
+                handler=partial(self.__wrap_initial_handler, command),
+            )
+        else:
+            if category not in self._categories:
+                self._categories[category] = list[Command]()
+                self.xmpp.plugin["xep_0050"].add_command(  # type: ignore[no-untyped-call]
+                    jid=jid,
+                    node=category,
+                    name=category,
+                    handler=partial(self.__handle_category_list, category),
+                )
+            self._categories[category].append(command)
+
+    async def get_items(self, jid: JID, node: str, iq: Iq) -> DiscoItems:
+        """
+        Get items for a disco query
+
+        :param jid: who is requesting the disco
+        :param node: which command node is requested
+        :param iq:  the disco query IQ
+        :return: commands accessible to the given JID will be listed
+        """
+        all_items = self.xmpp.plugin["xep_0030"].static.get_items(jid, node, None, None)
+        log.debug("Static items: %r", all_items)
+        if not all_items:
+            return DiscoItems()
+
+        ifrom = iq.get_from()
+
+        filtered_items = DiscoItems()
+        filtered_items["node"] = self.xmpp.plugin["xep_0050"].stanza.Command.namespace
+        for item in all_items:
+            authorized = True
+            if item["node"] in self._categories:
+                for command in self._categories[item["node"]]:
+                    try:
+                        command.raise_if_not_authorized(ifrom)
+                    except XMPPError:
+                        authorized = False
+                    else:
+                        authorized = True
+                        break
+            else:
+                try:
+                    self._commands[item["node"]].raise_if_not_authorized(ifrom)
+                except XMPPError:
+                    authorized = False
+
+            if authorized:
+                filtered_items.append(item)
+
+        return filtered_items
+
+
+log = logging.getLogger(__name__)