slidge 0.1.0__py3-none-any.whl

slidge/__init__.py

@@ -0,0 +1,61 @@
+"""
+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",
+    # 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

@@ -0,0 +1,192 @@
+"""
+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 importlib
+import logging
+import os
+import signal
+from pathlib import Path
+
+import configargparse
+
+from slidge import BaseGateway
+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
+
+
+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)
+
+        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_argument(
+        "-c",
+        "--config",
+        help="Path to a INI config file.",
+        env_var="SLIDGE_CONFIG",
+        is_config_file=True,
+    )
+    p.add_argument(
+        "-q",
+        "--quiet",
+        help="loglevel=WARNING",
+        action="store_const",
+        dest="loglevel",
+        const=logging.WARNING,
+        default=logging.INFO,
+        env_var="SLIDGE_QUIET",
+    )
+    p.add_argument(
+        "-d",
+        "--debug",
+        help="loglevel=DEBUG",
+        action="store_const",
+        dest="loglevel",
+        const=logging.DEBUG,
+        env_var="SLIDGE_DEBUG",
+    )
+    p.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+    )
+    configurator = MainConfig(config, p)
+    return configurator
+
+
+def get_parser():
+    return get_configurator().parser
+
+
+def configure():
+    configurator = get_configurator()
+    args, unknown_argv = configurator.set_conf()
+
+    if not (h := config.HOME_DIR).exists():
+        logging.info("Creating directory '%s'", h)
+        h.mkdir()
+
+    db_file = config.HOME_DIR / "slidge.db"
+    user_store.set_file(db_file, args.secret_key)
+
+    avatar_cache.set_dir(h / "slidge_avatars_v2")
+
+    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
+    try:
+        gateway.loop.run_forever()
+    except KeyboardInterrupt:
+        logging.debug("Received SIGINT")
+    except SigTermInterrupt:
+        logging.debug("Received SIGTERM")
+    except SystemExit as e:
+        return_code = e.code  # type: ignore
+        logging.debug("Exit called")
+    except Exception as e:
+        return_code = 2
+        logging.exception("Exception in __main__")
+        logging.exception(e)
+    finally:
+        if gateway.has_crashed:
+            if return_code != 0:
+                logging.warning("Return code has been set twice. Please report this.")
+            return_code = 3
+        if gateway.is_connected():
+            logging.debug("Gateway is connected, cleaning up")
+            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__)