slidge 0.1.3__py3-none-any.whl → 0.2.0a1__py3-none-any.whl

slidge/main.py

@@ -0,0 +1,201 @@
+"""
+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 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
+from slidge.util.db import user_store
+
+
+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()
+
+    db_file = config.HOME_DIR / "slidge.db"
+    user_store.set_file(db_file, args.secret_key)
+
+    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()
+
+    BaseGateway.store = SlidgeStore(get_engine(config.DB_URL))
+    gateway: BaseGateway = BaseGateway.get_unique_subclass()()
+    avatar_cache.http = gateway.http
+    avatar_cache.store = gateway.store.avatars
+    avatar_cache.set_dir(config.HOME_DIR / "slidge_avatars_v3")
+    avatar_cache.legacy_avatar_type = gateway.AVATAR_ID_TYPE
+
+    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,5 +1,10 @@
 import logging
 import shutil
+import sys
+from pathlib import Path
+
+from alembic import command
+from alembic.config import Config
 
 from .core import config
 
@@ -11,8 +16,33 @@ def remove_avatar_cache_v1():
         shutil.rmtree(old_dir)
 
 
+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 migrate():
     remove_avatar_cache_v1()
+    command.upgrade(get_alembic_cfg(), "head")
+
+
+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

@@ -1,11 +1,12 @@
 # This module contains patches for slixmpp; some have pending requests upstream
 # and should be removed on the next slixmpp release.
-
-# ruff: noqa: F401
+import logging
+from collections import defaultdict
 
 import slixmpp.plugins
 from slixmpp import Message
 from slixmpp.plugins.xep_0050 import XEP_0050, Command
+from slixmpp.plugins.xep_0356.privilege import _VALID_ACCESSES, XEP_0356
 from slixmpp.xmlstream import StanzaBase
 
 from . import (  # xep_0356,
@@ -22,6 +23,37 @@ from . import (  # xep_0356,
     xep_0490,
 )
 
+# ruff: noqa: F401
+
+
+# TODO: Remove me once https://codeberg.org/poezio/slixmpp/pulls/3541 makes it
+#       to a slixmpp release
+def _handle_privilege(self, msg: StanzaBase):
+    """
+    Called when the XMPP server advertise the component's privileges.
+
+    Stores the privileges in this instance's granted_privileges attribute (a dict)
+    and raises the privileges_advertised event
+    """
+    permissions = self.granted_privileges[msg.get_from()]
+    for perm in msg["privilege"]["perms"]:
+        access = perm["access"]
+        if access == "iq":
+            if not perm.get_plugin("namespace", check=True):
+                permissions.iq = defaultdict(lambda: perm["type"])
+            else:
+                for ns in perm["namespaces"]:
+                    permissions.iq[ns["ns"]] = ns["type"]
+        elif access in _VALID_ACCESSES:
+            setattr(permissions, access, perm["type"])
+        else:
+            log.warning("Received an invalid privileged access: %s", access)
+    log.debug("Privileges: %s", self.granted_privileges)
+    self.xmpp.event("privileges_advertised")
+
+
+XEP_0356._handle_privilege = _handle_privilege
+
 
 def session_bind(self, jid):
     self.xmpp["xep_0030"].add_feature(Command.namespace)
@@ -66,3 +98,4 @@ slixmpp.plugins.PLUGINS.extend(
 
 
 Message.reply = reply  # type: ignore
+log = logging.getLogger(__name__)

slidge/slixfix/roster.py

@@ -1,6 +1,11 @@
+from typing import TYPE_CHECKING
+
 from slixmpp import JID
 
-from ..util.db import log, user_store
+from ..util.db import log
+
+if TYPE_CHECKING:
+    from .. import BaseGateway
 
 
 class YesSet(set):
@@ -23,6 +28,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 +39,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 {

slidge/slixfix/xep_0292/vcard4.py

@@ -26,6 +26,7 @@ class VCard4Provider(BasePlugin):
 
     def __init__(self, *a, **k):
         super(VCard4Provider, self).__init__(*a, **k)
+        # TODO: store that in DB and not in RAM
         self._vcards = dict[JidStr, StoredVCard]()
 
     def plugin_init(self):
@@ -56,6 +57,8 @@ class VCard4Provider(BasePlugin):
         if not hasattr(self.xmpp, "get_session_from_jid"):
             return None
         jid = JID(jid)
+        if not jid.local:
+            return None
         requested_by = JID(requested_by)
         session = self.xmpp.get_session_from_jid(requested_by)
         if session is None:

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)
         )

slidge/util/db.py

@@ -15,8 +15,6 @@ from typing import Iterable, Optional, Union
 from pickle_secure import Pickler, Unpickler
 from slixmpp import JID, Iq, Message, Presence
 
-from .sql import db
-
 
 # noinspection PyUnresolvedReferences
 class EncryptedShelf(shelve.DbfilenameShelf):
@@ -94,10 +92,6 @@ class GatewayUser:
         # """
         return self.registration_form.get(field, default)
 
-    def commit(self):
-        db.user_store(self)
-        user_store.commit(self)
-
 
 class UserStore:
     """
@@ -126,8 +120,6 @@ class UserStore:
             self._users = EncryptedShelf(filename, key=secret_key)
         else:
             self._users = shelve.open(str(filename))
-        for user in self._users.values():
-            db.user_store(user)
         log.info("Registered users in the DB: %s", list(self._users.keys()))
 
     def get_all(self) -> Iterable[GatewayUser]:
@@ -138,28 +130,8 @@ class UserStore:
         """
         return self._users.values()
 
-    def add(self, jid: JID, registration_form: dict[str, Optional[str]]):
-        """
-        Add a user to the store.
-
-        NB: there is no reason to call this manually, as this should be covered
-        by slixmpp XEP-0077 and XEP-0100 plugins
-
-        :param jid: JID of the gateway user
-        :param registration_form: Content of the registration form (:xep:`0077`)
-        """
-        log.debug("Adding user %s", jid)
-        self._users[jid.bare] = user = GatewayUser(
-            bare_jid=jid.bare,
-            registration_form=registration_form,
-            registration_date=datetime.datetime.now(),
-        )
-        self._users.sync()
-        user.commit()
-        log.debug("Store: %s", self._users)
-
     def commit(self, user: GatewayUser):
-        self._users[user.bare_jid] = user
+        self._users[user.jid.bare] = user
         self._users.sync()
 
     def get(self, _gateway_jid, _node, ifrom: JID, iq) -> Optional[GatewayUser]:
@@ -179,24 +151,6 @@ class UserStore:
         log.debug("Getting user %s", ifrom.bare)
         return self._users.get(ifrom.bare)
 
-    def remove(self, _gateway_jid, _node, ifrom: JID, _iq):
-        """
-        Remove a user from the store
-
-        NB: there is no reason to call this, it is used by SliXMPP internal API
-        """
-        self.remove_by_jid(ifrom)
-
-    def remove_by_jid(self, jid: JID):
-        """
-        Remove a user from the store, by JID
-        """
-        j = jid.bare
-        log.debug("Removing user %s", j)
-        db.user_del(self._users[j])
-        del self._users[j]
-        self._users.sync()
-
     def get_by_jid(self, jid: JID) -> Optional[GatewayUser]:
         """
         Convenience function to get a user from their JID.

slidge/util/test.py

@@ -7,6 +7,7 @@ from xml.dom.minidom import parseString
 
 import xmldiff.main
 from slixmpp import (
+    JID,
     ElementBase,
     Iq,
     MatcherId,
@@ -20,6 +21,7 @@ from slixmpp.stanza.error import Error
 from slixmpp.test import SlixTest, TestTransport
 from slixmpp.xmlstream import highlight, tostring
 from slixmpp.xmlstream.matcher import MatchIDSender
+from sqlalchemy import create_engine, delete
 
 from slidge import (
     BaseGateway,
@@ -29,12 +31,16 @@ from slidge import (
     LegacyMUC,
     LegacyParticipant,
     LegacyRoster,
-    user_store,
 )
 
 from ..command import Command
 from ..core import config
 from ..core.config import _TimedeltaSeconds
+from ..core.pubsub import PepAvatar, PepNick
+from ..db import SlidgeStore
+from ..db.avatar import avatar_cache
+from ..db.meta import Base
+from ..db.models import Contact
 
 
 class SlixTestPlus(SlixTest):
@@ -187,10 +193,10 @@ class SlidgeTest(SlixTestPlus):
         no_roster_push = False
         upload_requester = None
         ignore_delay_threshold = _TimedeltaSeconds("300")
+        last_seen_fallback = True
 
     @classmethod
     def setUpClass(cls):
-        user_store.set_file(Path(tempfile.mkdtemp()) / "test.db")
         for k, v in vars(cls.Config).items():
             setattr(config, k.upper(), v)
 
@@ -209,9 +215,17 @@ class SlidgeTest(SlixTestPlus):
                 self.plugin, LegacyBookmarks, base_ok=True
             )
 
+        engine = self.db_engine = create_engine("sqlite+pysqlite:///:memory:")
+        Base.metadata.create_all(engine)
+        BaseGateway.store = SlidgeStore(engine)
         self.xmpp = BaseGateway.get_self_or_unique_subclass()()
-
+        self.xmpp.TEST_MODE = True
+        PepNick.contact_store = self.xmpp.store.contacts
+        PepAvatar.store = self.xmpp.store
+        avatar_cache.store = self.xmpp.store.avatars
+        avatar_cache.set_dir(Path(tempfile.mkdtemp()))
         self.xmpp._always_send_everything = True
+        engine.echo = True
 
         self.xmpp.connection_made(TestTransport(self.xmpp))
         self.xmpp.session_bind_event.set()
@@ -242,10 +256,63 @@ class SlidgeTest(SlixTestPlus):
         self.xmpp.use_presence_ids = False
         Error.namespace = "jabber:component:accept"
 
+    def tearDown(self):
+        self.db_engine.echo = False
+        super().tearDown()
+        import slidge.db.store
+
+        if slidge.db.store._session is not None:
+            slidge.db.store._session.commit()
+            slidge.db.store._session = None
+        Base.metadata.drop_all(self.xmpp.store._engine)
+
+    def setup_logged_session(self):
+        user = self.xmpp.store.users.new(
+            JID("romeo@montague.lit/gajim"), {"username": "romeo", "city": ""}
+        )
+        user.preferences = {"sync_avatar": True, "sync_presence": True}
+        self.xmpp.store.users.update(user)
+
+        with self.xmpp.store.session() as session:
+            session.execute(delete(Contact))
+            session.commit()
+
+        self.run_coro(self.xmpp._on_user_register(Iq(sfrom="romeo@montague.lit/gajim")))
+        welcome = self.next_sent()
+        assert welcome["body"]
+        stanza = self.next_sent()
+        assert "logging in" in stanza["status"].lower(), stanza
+        stanza = self.next_sent()
+        assert "syncing contacts" in stanza["status"].lower(), stanza
+        stanza = self.next_sent()
+        assert "yup" in stanza["status"].lower(), stanza
+
+        self.romeo = BaseSession.get_self_or_unique_subclass().from_jid(
+            JID("romeo@montague.lit")
+        )
+        self.juliet: LegacyContact = self.run_coro(
+            self.romeo.contacts.by_legacy_id("juliet")
+        )
+        self.room: LegacyMUC = self.run_coro(self.romeo.bookmarks.by_legacy_id("room"))
+        self.first_witch: LegacyParticipant = self.run_coro(
+            self.room.get_participant("firstwitch")
+        )
+        self.send(  # language=XML
+            """
+            <iq type="get"
+                to="romeo@montague.lit"
+                id="1"
+                from="aim.shakespeare.lit">
+              <pubsub xmlns="http://jabber.org/protocol/pubsub">
+                <items node="urn:xmpp:avatar:metadata" />
+              </pubsub>
+            </iq>
+            """
+        )
+
     @classmethod
     def tearDownClass(cls):
         reset_subclasses()
-        user_store._users = None
 
 
 def format_stanza(stanza):

slidge/util/types.py

@@ -3,6 +3,7 @@ Typing stuff
 """
 
 from dataclasses import dataclass
+from datetime import datetime
 from enum import IntEnum
 from pathlib import Path
 from typing import (
@@ -20,14 +21,13 @@ from typing import (
 )
 
 from slixmpp import Message, Presence
-from slixmpp.types import PresenceShows
+from slixmpp.types import PresenceShows, PresenceTypes
 
 if TYPE_CHECKING:
     from ..contact import LegacyContact
     from ..core.pubsub import PepItem
     from ..core.session import BaseSession
     from ..group.participant import LegacyMUC, LegacyParticipant
-    from .db import GatewayUser
 
     AnyBaseSession = BaseSession[Any, Any]
 else:
@@ -84,13 +84,16 @@ class MessageReference(Generic[LegacyMessageType]):
 
     At the very minimum, the legacy message ID attribute must be set, but to
     ensure that the quote is displayed in all XMPP clients, the author must also
-    be set.
+    be set (use the string "user" if the slidge user is the author of the referenced
+    message).
     The body is used as a fallback for XMPP clients that do not support :xep:`0461`
     of that failed to find the referenced message.
     """
 
     legacy_id: LegacyMessageType
-    author: Optional[Union["GatewayUser", "LegacyParticipant", "LegacyContact"]] = None
+    author: Optional[Union[Literal["user"], "LegacyParticipant", "LegacyContact"]] = (
+        None
+    )
     body: Optional[str] = None
 
 
@@ -178,3 +181,25 @@ class Mention(NamedTuple):
 class Hat(NamedTuple):
     uri: str
     title: str
+
+
+class UserPreferences(TypedDict):
+    sync_avatar: bool
+    sync_presence: bool
+
+
+class MamMetadata(NamedTuple):
+    id: str
+    sent_on: datetime
+
+
+class HoleBound(NamedTuple):
+    id: int | str
+    timestamp: datetime
+
+
+class CachedPresence(NamedTuple):
+    last_seen: Optional[datetime] = None
+    ptype: Optional[PresenceTypes] = None
+    pstatus: Optional[str] = None
+    pshow: Optional[PresenceShows] = None

slidge/util/util.py

@@ -4,7 +4,9 @@ import re
 import subprocess
 import warnings
 from abc import ABCMeta
+from functools import wraps
 from pathlib import Path
+from time import time
 from typing import TYPE_CHECKING, Callable, NamedTuple, Optional, Type
 
 from .types import Mention, ResourceDict
@@ -293,3 +295,23 @@ def replace_mentions(
         cursor = mention.end
     pieces.append(text[cursor:])
     return "".join(pieces)
+
+
+def with_session(func):
+    @wraps(func)
+    async def wrapped(self, *args, **kwargs):
+        with self.xmpp.store.session():
+            return await func(self, *args, **kwargs)
+
+    return wrapped
+
+
+def timeit(func):
+    @wraps(func)
+    async def wrapped(self, *args, **kwargs):
+        start = time()
+        r = await func(self, *args, **kwargs)
+        self.log.info("%s took %s ms", func.__name__, round((time() - start) * 1000))
+        return r
+
+    return wrapped