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

slidge/util/archive_msg.py

@@ -0,0 +1,61 @@
+from copy import copy
+from datetime import datetime, timezone
+from typing import Optional, Union
+from xml.etree import ElementTree as ET
+
+from slixmpp import Message
+from slixmpp.plugins.xep_0297 import Forwarded
+
+
+def fix_namespaces(xml, old="{jabber:component:accept}", new="{jabber:client}"):
+    """
+    Hack to fix namespaces between jabber:component and jabber:client
+
+    Acts in-place.
+
+    :param xml:
+    :param old:
+    :param new:
+    """
+    xml.tag = xml.tag.replace(old, new)
+    for child in xml:
+        fix_namespaces(child, old, new)
+
+
+class HistoryMessage:
+    def __init__(self, stanza: Union[Message, str], when: Optional[datetime] = None):
+        if isinstance(stanza, str):
+            from_db = True
+            stanza = Message(xml=ET.fromstring(stanza))
+        else:
+            from_db = False
+
+        self.id = stanza["stanza_id"]["id"]
+        self.when: datetime = (
+            when or stanza["delay"]["stamp"] or datetime.now(tz=timezone.utc)
+        )
+
+        if not from_db:
+            del stanza["delay"]
+            del stanza["markable"]
+            del stanza["hint"]
+            del stanza["chat_state"]
+            if not stanza["body"]:
+                del stanza["body"]
+            fix_namespaces(stanza.xml)
+
+        self.stanza: Message = stanza
+
+    @property
+    def stanza_component_ns(self):
+        stanza = copy(self.stanza)
+        fix_namespaces(
+            stanza.xml, old="{jabber:client}", new="{jabber:component:accept}"
+        )
+        return stanza
+
+    def forwarded(self):
+        forwarded = Forwarded()
+        forwarded["delay"]["stamp"] = self.when
+        forwarded.append(self.stanza)
+        return forwarded

slidge/util/conf.py

@@ -0,0 +1,206 @@
+import logging
+from functools import cached_property
+from types import GenericAlias
+from typing import Optional, Union, get_args, get_origin, get_type_hints
+
+import configargparse
+
+
+class Option:
+    DOC_SUFFIX = "__DOC"
+    DYNAMIC_DEFAULT_SUFFIX = "__DYNAMIC_DEFAULT"
+    SHORT_SUFFIX = "__SHORT"
+
+    def __init__(self, parent: "ConfigModule", name: str):
+        self.parent = parent
+        self.config_obj = parent.config_obj
+        self.name = name
+
+    @cached_property
+    def doc(self):
+        return getattr(self.config_obj, self.name + self.DOC_SUFFIX)
+
+    @cached_property
+    def required(self):
+        return not hasattr(
+            self.config_obj, self.name + self.DYNAMIC_DEFAULT_SUFFIX
+        ) and not hasattr(self.config_obj, self.name)
+
+    @cached_property
+    def default(self):
+        return getattr(self.config_obj, self.name, None)
+
+    @cached_property
+    def short(self):
+        return getattr(self.config_obj, self.name + self.SHORT_SUFFIX, None)
+
+    @cached_property
+    def nargs(self):
+        type_ = get_type_hints(self.config_obj).get(self.name, type(self.default))
+
+        if isinstance(type_, GenericAlias):
+            args = get_args(type_)
+            if args[1] is Ellipsis:
+                return "*"
+            else:
+                return len(args)
+
+    @cached_property
+    def type(self):
+        type_ = get_type_hints(self.config_obj).get(self.name, type(self.default))
+
+        if _is_optional(type_):
+            type_ = get_args(type_)[0]
+        elif isinstance(type_, GenericAlias):
+            args = get_args(type_)
+            type_ = args[0]
+
+        return type_
+
+    @cached_property
+    def names(self):
+        res = ["--" + self.name.lower().replace("_", "-")]
+        if s := self.short:
+            res.append("-" + s)
+        return res
+
+    @cached_property
+    def kwargs(self):
+        kwargs = dict(
+            required=self.required,
+            help=self.doc,
+            env_var=self.name_to_env_var(),
+        )
+        t = self.type
+        if t is bool:
+            if self.default:
+                kwargs["action"] = "store_false"
+            else:
+                kwargs["action"] = "store_true"
+        else:
+            kwargs["type"] = t
+            if self.required:
+                kwargs["required"] = True
+            else:
+                kwargs["default"] = self.default
+        if n := self.nargs:
+            kwargs["nargs"] = n
+        return kwargs
+
+    def name_to_env_var(self):
+        return self.parent.ENV_VAR_PREFIX + self.name
+
+
+class ConfigModule:
+    ENV_VAR_PREFIX = "SLIDGE_"
+
+    def __init__(
+        self, config_obj, parser: Optional[configargparse.ArgumentParser] = None
+    ):
+        self.config_obj = config_obj
+        if parser is None:
+            parser = configargparse.ArgumentParser()
+        self.parser = parser
+
+        self.add_options_to_parser()
+
+    def _list_options(self):
+        return {
+            o
+            for o in (set(dir(self.config_obj)) | set(get_type_hints(self.config_obj)))
+            if o.upper() == o and not o.startswith("_") and "__" not in o
+        }
+
+    def set_conf(self, argv: Optional[list[str]] = None):
+        if argv is not None:
+            # this is ugly, but necessary because for plugin config, we used
+            # remaining argv.
+            # when using (a) .ini file(s), for bool options, we end-up with
+            # remaining pseudo-argv such as --some-bool-opt=true when we really
+            # should have just --some-bool-opt
+            # TODO: get rid of configargparse and make this cleaner
+            options_long = {o.name: o for o in self.options}
+            no_explicit_bool = []
+            skip_next = False
+            for a, aa in zip(argv, argv[1:] + [""]):
+                if skip_next:
+                    skip_next = False
+                    continue
+                force_keep = False
+                if "=" in a:
+                    real_name, _value = a.split("=")
+                    opt: Optional[Option] = options_long.get(
+                        _argv_to_option_name(real_name)
+                    )
+                    if opt and opt.type is bool:
+                        if opt.default:
+                            if _value in _TRUEISH or not _value:
+                                continue
+                            else:
+                                a = real_name
+                                force_keep = True
+                        else:
+                            if _value in _TRUEISH:
+                                a = real_name
+                                force_keep = True
+                            else:
+                                continue
+                else:
+                    upper = _argv_to_option_name(a)
+                    opt = options_long.get(upper)
+                    if opt and opt.type is bool:
+                        if _argv_to_option_name(aa) not in options_long:
+                            log.debug("Removing %s from argv", aa)
+                            skip_next = True
+
+                if opt:
+                    if opt.type is bool:
+                        if force_keep or not opt.default:
+                            no_explicit_bool.append(a)
+                    else:
+                        no_explicit_bool.append(a)
+                else:
+                    no_explicit_bool.append(a)
+            log.debug("Removed boolean values from %s to %s", argv, no_explicit_bool)
+            argv = no_explicit_bool
+
+        args, rest = self.parser.parse_known_args(argv)
+        self.update_dynamic_defaults(args)
+        for name in self._list_options():
+            value = getattr(args, name.lower())
+            log.debug("Setting '%s' to %r", name, value)
+            setattr(self.config_obj, name, value)
+        return args, rest
+
+    @cached_property
+    def options(self) -> list[Option]:
+        res = []
+        for opt in self._list_options():
+            res.append(Option(self, opt))
+        return res
+
+    def add_options_to_parser(self):
+        p = self.parser
+        for o in sorted(self.options, key=lambda x: (not x.required, x.name)):
+            p.add_argument(*o.names, **o.kwargs)
+
+    def update_dynamic_defaults(self, args):
+        pass
+
+
+def _is_optional(t):
+    if get_origin(t) is Union:
+        args = get_args(t)
+        if len(args) == 2 and isinstance(None, args[1]):
+            return True
+    return False
+
+
+def _argv_to_option_name(arg: str):
+    return arg.upper().removeprefix("--").replace("-", "_")
+
+
+_TRUEISH = {"true", "True", "1", "on", "enabled"}
+
+
+log = logging.getLogger(__name__)

slidge/util/db.py

@@ -4,6 +4,7 @@ pseudo-roster for the gateway component.
 """
 
 import dataclasses
+import datetime
 import logging
 import os.path
 import shelve
@@ -14,9 +15,17 @@ 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):
+    cache: dict
+    dict: dict
+    writeback: bool
+    keyencoding: str
+    _protocol: int
+
     def __init__(
         self, filename: PathLike, key: str, flag="c", protocol=None, writeback=False
     ):
@@ -28,7 +37,7 @@ class EncryptedShelf(shelve.DbfilenameShelf):
             value = self.cache[key]
         except KeyError:
             f = BytesIO(self.dict[key.encode(self.keyencoding)])
-            value = Unpickler(f, key=self.secret_key).load()
+            value = Unpickler(f, key=self.secret_key).load()  # type:ignore
             if self.writeback:
                 self.cache[key] = value
         return value
@@ -37,7 +46,7 @@ class EncryptedShelf(shelve.DbfilenameShelf):
         if self.writeback:
             self.cache[key] = value
         f = BytesIO()
-        p = Pickler(f, self._protocol, key=self.secret_key)
+        p = Pickler(f, self._protocol, key=self.secret_key)  # type:ignore
         p.dump(value)
         self.dict[key.encode(self.keyencoding)] = f.getvalue()
 
@@ -45,13 +54,15 @@ class EncryptedShelf(shelve.DbfilenameShelf):
 @dataclasses.dataclass
 class GatewayUser:
     """
-    A dataclass representing a gateway user
+    A gateway user
     """
 
     bare_jid: str
     """Bare JID of the user"""
     registration_form: dict[str, Optional[str]]
     """Content of the registration form, as a dict"""
+    plugin_data: Optional[dict] = None
+    registration_date: Optional[datetime.datetime] = None
 
     def __hash__(self):
         return hash(self.bare_jid)
@@ -59,6 +70,10 @@ class GatewayUser:
     def __repr__(self):
         return f"<User {self.bare_jid}>"
 
+    def __post_init__(self):
+        if self.registration_date is None:
+            self.registration_date = datetime.datetime.now()
+
     @property
     def jid(self) -> JID:
         """
@@ -69,16 +84,20 @@ class GatewayUser:
         return JID(self.bare_jid)
 
     def get(self, field: str, default: str = "") -> Optional[str]:
-        """
-        Get fields from the registration form (required to comply with slixmpp backend protocol)
-
-        :param field: Name of the field
-        :param default: Default value to return if the field is not present
-
-        :return: Value of the field
-        """
+        # """
+        # Get fields from the registration form (required to comply with slixmpp backend protocol)
+        #
+        # :param field: Name of the field
+        # :param default: Default value to return if the field is not present
+        #
+        # :return: Value of the field
+        # """
         return self.registration_form.get(field, default)
 
+    def commit(self):
+        db.user_store(self)
+        user_store.commit(self)
+
 
 class UserStore:
     """
@@ -107,6 +126,8 @@ 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]:
@@ -128,18 +149,24 @@ class UserStore:
         :param registration_form: Content of the registration form (:xep:`0077`)
         """
         log.debug("Adding user %s", jid)
-        self._users[jid.bare] = GatewayUser(
+        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.sync()
+
     def get(self, _gateway_jid, _node, ifrom: JID, iq) -> Optional[GatewayUser]:
         """
         Get a user from the store
 
-        NB: there is no reason to call this, it is used by SliXMPP plugins
+        NB: there is no reason to call this, it is used by SliXMPP internal API
 
         :param _gateway_jid:
         :param _node:
@@ -156,15 +183,18 @@ class UserStore:
         """
         Remove a user from the store
 
-        NB: there is no reason to call this, it is used by SliXMPP plugins
+        NB: there is no reason to call this, it is used by SliXMPP internal API
+        """
+        self.remove_by_jid(ifrom)
 
-        :param _gateway_jid:
-        :param _node:
-        :param ifrom:
-        :param _iq:
+    def remove_by_jid(self, jid: JID):
+        """
+        Remove a user from the store, by JID
         """
-        log.debug("Removing user %s", ifrom.bare)
-        del self._users[ifrom.bare]
+        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]:
@@ -185,64 +215,15 @@ class UserStore:
         """
         return self.get_by_jid(s.get_from())
 
-
-class YesSet(set):
-    """
-    A pseudo-set which always test True for membership
-    """
-
-    def __contains__(self, item):
-        log.debug("Test in")
-        return True
-
-
-class RosterBackend:
-    """
-    A pseudo-roster for the gateway component.
-
-    If a user is in the user store, this will behave as if the user is part of the
-    roster with subscription "both", and "none" otherwise.
-
-    This is rudimentary but the only sane way I could come up with so far.
-    """
-
-    @staticmethod
-    def entries(_owner_jid, _default=None):
-        return YesSet()
-
-    @staticmethod
-    def save(_owner_jid, _jid, _item_state, _db_state):
-        pass
-
-    @staticmethod
-    def load(_owner_jid, jid, _db_state):
-        log.debug("Load %s", jid)
-        user = user_store.get_by_jid(JID(jid))
-        log.debug("User %s", user)
-        if user is None:
-            return {
-                "name": "",
-                "groups": [],
-                "from": False,
-                "to": False,
-                "pending_in": False,
-                "pending_out": False,
-                "whitelisted": False,
-                "subscription": "both",
-            }
-        else:
-            return {
-                "name": "",
-                "groups": [],
-                "from": True,
-                "to": True,
-                "pending_in": False,
-                "pending_out": False,
-                "whitelisted": False,
-                "subscription": "none",
-            }
+    def close(self):
+        self._users.sync()
+        self._users.close()
 
 
 user_store = UserStore()
+"""
+A persistent store for slidge users. Not public, but I didn't find how to hide
+it from the docs!
+"""
 
 log = logging.getLogger(__name__)

slidge/util/schema.sql

@@ -0,0 +1,126 @@
+CREATE TABLE user(
+  id INTEGER PRIMARY KEY,
+  jid TEXT UNIQUE
+);
+
+CREATE TABLE muc(
+  id INTEGER PRIMARY KEY,
+  jid TEXT,
+  user_id INTEGER,
+  FOREIGN KEY(user_id) REFERENCES user(id),
+  UNIQUE(user_id, jid)
+);
+
+CREATE TABLE mam_message(
+  id INTEGER PRIMARY KEY,
+  message_id TEXT,
+  sent_on INTEGER,
+  sender_jid TEXT,
+  xml TEXT,
+  muc_id INTEGER,
+  user_id INTEGER,
+  FOREIGN KEY(muc_id) REFERENCES muc(id),
+  FOREIGN KEY(user_id) REFERENCES user(id),
+  UNIQUE(user_id, muc_id, message_id)
+);
+
+CREATE INDEX mam_sent_on ON mam_message(sent_on);
+CREATE INDEX muc_jid ON muc(jid);
+
+CREATE TABLE session_message_sent(
+  id INTEGER PRIMARY KEY,
+  legacy_id UNIQUE,
+  xmpp_id TEXT,
+  user_id INTEGER,
+  FOREIGN KEY(user_id) REFERENCES user(id)
+);
+
+CREATE INDEX session_message_sent_legacy_id
+    ON session_message_sent(legacy_id);
+CREATE INDEX session_message_sent_xmpp_id
+    ON session_message_sent(xmpp_id);
+
+CREATE TABLE session_message_sent_muc(
+  id INTEGER PRIMARY KEY,
+  legacy_id UNIQUE,
+  xmpp_id TEXT,
+  user_id INTEGER,
+  FOREIGN KEY(user_id) REFERENCES user(id)
+);
+
+CREATE INDEX session_message_sent_muc_legacy_id
+    ON session_message_sent_muc(legacy_id);
+CREATE INDEX session_message_sent_muc_xmpp_id
+    ON session_message_sent_muc(xmpp_id);
+
+CREATE TABLE session_thread_sent_muc(
+  id INTEGER PRIMARY KEY,
+  legacy_id UNIQUE,
+  xmpp_id TEXT,
+  user_id INTEGER,
+  FOREIGN KEY(user_id) REFERENCES user(id)
+);
+
+CREATE INDEX session_thread_sent_muc_legacy_id
+    ON session_thread_sent_muc(legacy_id);
+CREATE INDEX session_thread_sent_muc_xmpp_id
+    ON session_thread_sent_muc(xmpp_id);
+
+
+CREATE TABLE attachment(
+  id INTEGER PRIMARY KEY,
+  legacy_id UNIQUE,
+  url TEXT UNIQUE,
+  sims TEXT,
+  sfs TEXT
+);
+
+CREATE INDEX attachment_legacy_id ON attachment(legacy_id);
+CREATE INDEX attachment_url ON attachment(url);
+
+CREATE TABLE attachment_legacy_msg_id(
+  id INTEGER PRIMARY KEY,
+  legacy_id UNIQUE
+);
+
+CREATE TABLE attachment_xmpp_ids(
+  id INTEGER PRIMARY KEY,
+  legacy_msg_id INTEGER,
+  xmpp_id TEXT,
+  FOREIGN KEY(legacy_msg_id) REFERENCES attachment_legacy_msg_id(id)
+);
+
+CREATE TABLE nick(
+  id INTEGER PRIMARY KEY,
+  jid UNIQUE,
+  nick TEXT,
+  user_id INTEGER,
+  FOREIGN KEY(user_id) REFERENCES user(id),
+  UNIQUE(jid, user_id)
+);
+
+CREATE INDEX nick_jid ON nick(jid);
+
+
+CREATE TABLE avatar(
+  id INTEGER PRIMARY KEY,
+  jid TEXT UNIQUE,
+  cached_id TEXT
+);
+
+CREATE INDEX avatar_jid ON avatar(jid);
+
+
+CREATE TABLE presence(
+  id INTEGER PRIMARY KEY,
+  jid TEXT,
+  last_seen INTEGER,
+  ptype TEXT,
+  pstatus TEXT,
+  pshow TEXT,
+  user_id INTEGER,
+  FOREIGN KEY(user_id) REFERENCES user(id),
+  UNIQUE(jid, user_id)
+);
+
+CREATE INDEX presence_jid ON presence(jid);