slidge 0.1.2__py3-none-any.whl → 0.2.0__py3-none-any.whl

slidge/main.py

@@ -0,0 +1,202 @@
+"""
+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 inspect
+import logging
+import os
+import re
+import signal
+from pathlib import Path
+
+import configargparse
+
+from slidge import BaseGateway
+from slidge.__version__ import __version__
+from slidge.core import config
+from slidge.core.pubsub import PepAvatar, PepNick
+from slidge.db import SlidgeStore
+from slidge.db.avatar import avatar_cache
+from slidge.db.meta import get_engine
+from slidge.migration import migrate
+from slidge.util.conf import ConfigModule
+
+
+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 = ".*@" + re.escape(args.server)
+
+        if args.db_url is None:
+            args.db_url = f"sqlite:///{args.home_dir}/slidge.sqlite"
+
+
+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()
+
+    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)
+    ):
+        # If the legacy module has default parameters that depend on dynamic defaults
+        # of the slidge main config, it needs to be refreshed at this point, because
+        # now the dynamic defaults are set.
+        if inspect.ismodule(plugin_config_obj):
+            importlib.reload(plugin_config_obj)
+        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()
+
+    store = SlidgeStore(get_engine(config.DB_URL))
+    BaseGateway.store = store
+    gateway: BaseGateway = BaseGateway.get_unique_subclass()()
+    avatar_cache.store = gateway.store.avatars
+    avatar_cache.set_dir(config.HOME_DIR / "slidge_avatars_v3")
+
+    PepAvatar.store = gateway.store
+    PepNick.contact_store = gateway.store.contacts
+
+    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.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")
+        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)

slidge/migration.py

@@ -1,7 +1,16 @@
 import logging
 import shutil
+import sys
+from pathlib import Path
+
+from alembic import command
+from alembic.config import Config
+from slixmpp import JID
 
 from .core import config
+from .db.meta import get_engine
+from .db.models import GatewayUser
+from .db.store import SlidgeStore
 
 
 def remove_avatar_cache_v1():
@@ -11,8 +20,43 @@ def remove_avatar_cache_v1():
         shutil.rmtree(old_dir)
 
 
-def migrate():
+def get_alembic_cfg() -> Config:
+    alembic_cfg = Config()
+    alembic_cfg.set_section_option(
+        "alembic",
+        "script_location",
+        str(Path(__file__).parent / "db" / "alembic"),
+    )
+    return alembic_cfg
+
+
+def remove_resource_parts_from_users() -> None:
+    with SlidgeStore(get_engine(config.DB_URL)).session() as orm:
+        for user in orm.query(GatewayUser).all():
+            if user.jid.resource:
+                user.jid = JID(user.jid.bare)
+                orm.add(user)
+        orm.commit()
+
+
+def migrate() -> None:
     remove_avatar_cache_v1()
+    command.upgrade(get_alembic_cfg(), "head")
+    remove_resource_parts_from_users()
+
+
+def main():
+    """
+    Updates the (dev) database in ./dev/slidge.sqlite and generates a revision
+
+    Usage: python -m slidge.migration "Revision message blah blah blah"
+    """
+    alembic_cfg = get_alembic_cfg()
+    command.upgrade(alembic_cfg, "head")
+    command.revision(alembic_cfg, sys.argv[1], autogenerate=True)
 
 
 log = logging.getLogger(__name__)
+
+if __name__ == "__main__":
+    main()

slidge/slixfix/__init__.py

@@ -4,8 +4,10 @@
 # ruff: noqa: F401
 
 import slixmpp.plugins
-from slixmpp import Message
+from slixmpp import Iq, Message
+from slixmpp.exceptions import XMPPError
 from slixmpp.plugins.xep_0050 import XEP_0050, Command
+from slixmpp.plugins.xep_0231 import XEP_0231
 from slixmpp.xmlstream import StanzaBase
 
 from . import (  # xep_0356,
@@ -23,6 +25,34 @@ from . import (  # xep_0356,
 )
 
 
+async def _handle_bob_iq(self, iq: Iq):
+    cid = iq["bob"]["cid"]
+
+    if iq["type"] == "result":
+        await self.api["set_bob"](iq["from"], None, iq["to"], args=iq["bob"])
+        self.xmpp.event("bob", iq)
+    elif iq["type"] == "get":
+        data = await self.api["get_bob"](iq["to"], None, iq["from"], args=cid)
+
+        if data is None:
+            raise XMPPError(
+                "item-not-found",
+                f"Bits of binary '{cid}' is not available.",
+            )
+
+        if isinstance(data, Iq):
+            data["id"] = iq["id"]
+            data.send()
+            return
+
+        iq = iq.reply()
+        iq.append(data)
+        iq.send()
+
+
+XEP_0231._handle_bob_iq = _handle_bob_iq
+
+
 def session_bind(self, jid):
     self.xmpp["xep_0030"].add_feature(Command.namespace)
     # awful hack to for the disco items: we need to comment this line

slidge/{core/gateway → slixfix}/delivery_receipt.py

@@ -11,7 +11,7 @@ from slixmpp import JID, Message
 from slixmpp.types import MessageTypes
 
 if TYPE_CHECKING:
-    from .base import BaseGateway
+    from slidge.core.gateway import BaseGateway
 
 
 class DeliveryReceipt:

slidge/slixfix/roster.py

@@ -1,6 +1,10 @@
+import logging
+from typing import TYPE_CHECKING
+
 from slixmpp import JID
 
-from ..util.db import log, user_store
+if TYPE_CHECKING:
+    from .. import BaseGateway
 
 
 class YesSet(set):
@@ -23,6 +27,9 @@ class RosterBackend:
     This is rudimentary but the only sane way I could come up with so far.
     """
 
+    def __init__(self, xmpp: "BaseGateway"):
+        self.xmpp = xmpp
+
     @staticmethod
     def entries(_owner_jid, _default=None):
         return YesSet()
@@ -31,10 +38,9 @@ class RosterBackend:
     def save(_owner_jid, _jid, _item_state, _db_state):
         pass
 
-    @staticmethod
-    def load(_owner_jid, jid, _db_state):
+    def load(self, _owner_jid, jid, _db_state):
         log.debug("Load %s", jid)
-        user = user_store.get_by_jid(JID(jid))
+        user = self.xmpp.store.users.get(JID(jid))
         log.debug("User %s", user)
         if user is None:
             return {
@@ -58,3 +64,6 @@ class RosterBackend:
                 "whitelisted": False,
                 "subscription": "none",
             }
+
+
+log = logging.getLogger(__name__)

slidge/slixfix/xep_0292/vcard4.py

@@ -1,100 +1,14 @@
-import logging
-from typing import TYPE_CHECKING, NamedTuple, Optional
-
-from slixmpp import JID, CoroutineCallback, Iq, StanzaPath
 from slixmpp.plugins.base import BasePlugin, register_plugin
-from slixmpp.plugins.xep_0292.stanza import NS, VCard4
-from slixmpp.types import JidStr
-
-from slidge.contact import LegacyContact
-
-if TYPE_CHECKING:
-    from slidge.core.gateway import BaseGateway
-
-
-class StoredVCard(NamedTuple):
-    content: VCard4
-    authorized_jids: set[JidStr]
+from slixmpp.plugins.xep_0292.stanza import NS
 
 
 class VCard4Provider(BasePlugin):
-    xmpp: "BaseGateway"
-
     name = "xep_0292_provider"
     description = "VCard4 Provider"
     dependencies = {"xep_0030"}
 
-    def __init__(self, *a, **k):
-        super(VCard4Provider, self).__init__(*a, **k)
-        self._vcards = dict[JidStr, StoredVCard]()
-
     def plugin_init(self):
-        self.xmpp.register_handler(
-            CoroutineCallback(
-                "get_vcard",
-                StanzaPath(f"iq@type=get/vcard"),
-                self.handle_vcard_get,  # type:ignore
-            )
-        )
-
         self.xmpp.plugin["xep_0030"].add_feature(NS)
 
-    def _get_cached_vcard(self, jid: JidStr, requested_by: JidStr) -> Optional[VCard4]:
-        vcard = self._vcards.get(JID(jid).bare)
-        if vcard:
-            if auth := vcard.authorized_jids:
-                if JID(requested_by).bare in auth:
-                    return vcard.content
-            else:
-                return vcard.content
-        return None
-
-    async def get_vcard(self, jid: JidStr, requested_by: JidStr) -> Optional[VCard4]:
-        if vcard := self._get_cached_vcard(jid, requested_by):
-            log.debug("Found a cached vcard")
-            return vcard
-        if not hasattr(self.xmpp, "get_session_from_jid"):
-            return None
-        jid = JID(jid)
-        requested_by = JID(requested_by)
-        session = self.xmpp.get_session_from_jid(requested_by)
-        if session is None:
-            return
-        entity = await session.get_contact_or_group_or_participant(jid)
-        if isinstance(entity, LegacyContact):
-            log.debug("Fetching vcard")
-            await entity.fetch_vcard()
-            return self._get_cached_vcard(jid, requested_by)
-        return None
-
-    async def handle_vcard_get(self, iq: Iq):
-        r = iq.reply()
-        if vcard := await self.get_vcard(iq.get_to().bare, iq.get_from().bare):
-            r.append(vcard)
-        else:
-            r.enable("vcard")
-        r.send()
-
-    def set_vcard(
-        self,
-        jid: JidStr,
-        vcard: VCard4,
-        /,
-        authorized_jids: Optional[set[JidStr]] = None,
-    ):
-        cache = self._vcards.get(jid)
-        new = StoredVCard(
-            vcard, authorized_jids if authorized_jids is not None else set()
-        )
-        self._vcards[jid] = new
-        if cache == new:
-            return
-        if self.xmpp["pubsub"] and authorized_jids:
-            for to in authorized_jids:
-                self.xmpp.loop.create_task(
-                    self.xmpp["pubsub"].broadcast_vcard_event(jid, to)
-                )
-
 
 register_plugin(VCard4Provider)
-log = logging.getLogger(__name__)

slidge/util/archive_msg.py

@@ -1,6 +1,7 @@
 from copy import copy
 from datetime import datetime, timezone
 from typing import Optional, Union
+from uuid import uuid4
 from xml.etree import ElementTree as ET
 
 from slixmpp import Message
@@ -30,7 +31,7 @@ class HistoryMessage:
         else:
             from_db = False
 
-        self.id = stanza["stanza_id"]["id"]
+        self.id = stanza["stanza_id"]["id"] or uuid4().hex
         self.when: datetime = (
             when or stanza["delay"]["stamp"] or datetime.now(tz=timezone.utc)
         )