slidge 0.1.0rc1__py3-none-any.whl → 0.1.2__py3-none-any.whl

slidge/__init__.py

@@ -1,38 +1,61 @@
-import slixmpp.plugins
-
-from .core import config as global_config
-from .core.contact import LegacyContact, LegacyRoster
-from .core.gateway import BaseGateway
-from .core.muc import LegacyBookmarks, LegacyMUC, LegacyParticipant, MucType
-from .core.session import BaseSession
-from .util import (
-    FormField,
-    SearchResult,
-    xep_0030,
-    xep_0050,
-    xep_0077,
-    xep_0100,
-    xep_0292,
-    xep_0356,
-    xep_0356_old,
-    xep_0461,
-)
-from .util.db import GatewayUser, user_store
-
-slixmpp.plugins.__all__.extend(["xep_0292_provider", "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",
-    "LegacyBookmarks",
-    "LegacyMUC",
-    "LegacyContact",
-    "LegacyParticipant",
-    "LegacyRoster",
-    "MucType",
-    "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,9 +1,22 @@
 """
 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
 
@@ -12,13 +25,22 @@ 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):
-        logging.basicConfig(level=args.loglevel)
+        # 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)
@@ -33,7 +55,10 @@ class SigTermInterrupt(Exception):
 
 def get_configurator():
     p = configargparse.ArgumentParser(
-        default_config_files=["/etc/slidge/conf.d/*.conf"], description=__doc__
+        default_config_files=os.getenv(
+            "SLIDGE_CONF_DIR", "/etc/slidge/conf.d/*.conf"
+        ).split(":"),
+        description=__doc__,
     )
     p.add_argument(
         "-c",
@@ -61,6 +86,11 @@ def get_configurator():
         const=logging.DEBUG,
         env_var="SLIDGE_DEBUG",
     )
+    p.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+    )
     configurator = MainConfig(config, p)
     return configurator
 
@@ -80,7 +110,7 @@ def configure():
     db_file = config.HOME_DIR / "slidge.db"
     user_store.set_file(db_file, args.secret_key)
 
-    avatar_cache.set_dir(h / "slidge_avatars")
+    avatar_cache.set_dir(h / "slidge_avatars_v2")
 
     config.UPLOAD_REQUESTER = config.UPLOAD_REQUESTER or config.JID.bare
 
@@ -96,8 +126,15 @@ 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)
@@ -112,7 +149,10 @@ def main():
         if unknown_argv:
             raise RuntimeError("Some arguments have not been recognized", unknown_argv)
 
-    gateway = BaseGateway.get_unique_subclass()()
+    migrate()
+
+    gateway: BaseGateway = BaseGateway.get_unique_subclass()()
+    avatar_cache.http = gateway.http
     gateway.connect()
 
     return_code = 0
@@ -136,17 +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__)

slidge/command/admin.py

@@ -0,0 +1,193 @@
+# Commands only accessible for slidge admins
+import functools
+import logging
+from datetime import datetime
+from typing import Any, Optional
+
+from slixmpp import JID
+from slixmpp.exceptions import XMPPError
+
+from ..util.db import user_store
+from ..util.types import AnyBaseSession
+from .base import (
+    Command,
+    CommandAccess,
+    Confirmation,
+    Form,
+    FormField,
+    FormValues,
+    TableResult,
+)
+from .categories import ADMINISTRATION
+
+
+class AdminCommand(Command):
+    ACCESS = CommandAccess.ADMIN_ONLY
+    CATEGORY = ADMINISTRATION
+
+
+class ListUsers(AdminCommand):
+    NAME = "👤 List registered users"
+    HELP = "List the users registered to this gateway"
+    NODE = CHAT_COMMAND = "list_users"
+
+    async def run(self, _session, _ifrom, *_):
+        items = []
+        for u in user_store.get_all():
+            d = u.registration_date
+            if d is None:
+                joined = ""
+            else:
+                joined = d.isoformat(timespec="seconds")
+            items.append({"jid": u.bare_jid, "joined": joined})
+        return TableResult(
+            description="List of registered users",
+            fields=[FormField("jid", type="jid-single"), FormField("joined")],
+            items=items,  # type:ignore
+        )
+
+
+class SlidgeInfo(AdminCommand):
+    NAME = "ℹ️ Server information"
+    HELP = "List the users registered to this gateway"
+    NODE = CHAT_COMMAND = "info"
+    ACCESS = CommandAccess.ANY
+
+    async def run(self, _session, _ifrom, *_):
+        from ..__main__ import __version__
+
+        start = self.xmpp.datetime_started
+        uptime = datetime.now() - start
+
+        if uptime.days:
+            days_ago = f"{uptime.days} day{'s' if uptime.days != 1 else ''}"
+        else:
+            days_ago = None
+        hours, seconds = divmod(uptime.seconds, 3600)
+
+        if hours:
+            hours_ago = f"{hours} hour"
+            if hours != 1:
+                hours_ago += "s"
+        else:
+            hours_ago = None
+
+        minutes, seconds = divmod(seconds, 60)
+        if minutes:
+            minutes_ago = f"{minutes} minute"
+            if minutes_ago != 1:
+                minutes_ago += "s"
+        else:
+            minutes_ago = None
+
+        if any((days_ago, hours_ago, minutes_ago)):
+            seconds_ago = None
+        else:
+            seconds_ago = f"{seconds} second"
+            if seconds != 1:
+                seconds_ago += "s"
+
+        ago = ", ".join(
+            [a for a in (days_ago, hours_ago, minutes_ago, seconds_ago) if a]
+        )
+
+        return (
+            f"{self.xmpp.COMPONENT_NAME} version {__version__}\n"
+            f"Up since {start:%Y-%m-%d %H:%M} ({ago} ago)"
+        )
+
+
+class DeleteUser(AdminCommand):
+    NAME = "❌ Delete a user"
+    HELP = "Unregister a user from the gateway"
+    NODE = CHAT_COMMAND = "delete_user"
+
+    async def run(self, _session, _ifrom, *_):
+        return Form(
+            title="Remove a slidge user",
+            instructions="Enter the bare JID of the user you want to delete",
+            fields=[FormField("jid", type="jid-single", label="JID", required=True)],
+            handler=self.delete,
+        )
+
+    async def delete(
+        self, form_values: FormValues, _session: AnyBaseSession, _ifrom: JID
+    ) -> Confirmation:
+        jid: JID = form_values.get("jid")  # type:ignore
+        user = user_store.get_by_jid(jid)
+        if user is None:
+            raise XMPPError("item-not-found", text=f"There is no user '{jid}'")
+
+        return Confirmation(
+            prompt=f"Are you sure you want to unregister '{jid}' from slidge?",
+            success=f"User {jid} has been deleted",
+            handler=functools.partial(self.finish, jid=jid),
+        )
+
+    async def finish(
+        self, _session: Optional[AnyBaseSession], _ifrom: JID, jid: JID
+    ) -> None:
+        user = user_store.get_by_jid(jid)
+        if user is None:
+            raise XMPPError("bad-request", f"{jid} has no account here!")
+        await self.xmpp.unregister_user(user)
+
+
+class ChangeLoglevel(AdminCommand):
+    NAME = "📋 Change the verbosity of the logs"
+    HELP = "Set the logging level"
+    NODE = CHAT_COMMAND = "loglevel"
+
+    async def run(self, _session, _ifrom, *_):
+        return Form(
+            title=self.NAME,
+            instructions=self.HELP,
+            fields=[
+                FormField(
+                    "level",
+                    label="Log level",
+                    required=True,
+                    type="list-single",
+                    options=[
+                        {"label": "WARNING (quiet)", "value": str(logging.WARNING)},
+                        {"label": "INFO (normal)", "value": str(logging.INFO)},
+                        {"label": "DEBUG (verbose)", "value": str(logging.DEBUG)},
+                    ],
+                )
+            ],
+            handler=self.finish,
+        )
+
+    @staticmethod
+    async def finish(
+        form_values: FormValues, _session: AnyBaseSession, _ifrom: JID
+    ) -> None:
+        logging.getLogger().setLevel(int(form_values["level"]))  # type:ignore
+
+
+class Exec(AdminCommand):
+    NAME = HELP = "Exec arbitrary python code. SHOULD NEVER BE AVAILABLE IN PROD."
+    CHAT_COMMAND = "!"
+    NODE = "exec"
+    ACCESS = CommandAccess.ADMIN_ONLY
+
+    prev_snapshot = None
+
+    context = dict[str, Any]()
+
+    def __init__(self, xmpp):
+        super().__init__(xmpp)
+
+    async def run(self, session, ifrom: JID, *args):
+        from contextlib import redirect_stdout
+        from io import StringIO
+
+        f = StringIO()
+        with redirect_stdout(f):
+            exec(" ".join(args), self.context)
+
+        out = f.getvalue()
+        if out:
+            return f"```\n{out}\n```"
+        else:
+            return "No output"