slidge 0.2.0a2__py3-none-any.whl → 0.2.0a4__py3-none-any.whl

slidge/__version__.py

@@ -2,4 +2,4 @@ from slidge.util.util import get_version  # noqa: F401
 
 # this is modified before publish, but if someone cloned from the repo,
 # it can help
-__version__ = "0.2.0alpha2"
+__version__ = "0.2.0alpha4"

slidge/command/admin.py

@@ -1,5 +1,6 @@
 # Commands only accessible for slidge admins
 import functools
+import importlib
 import logging
 from datetime import datetime
 from typing import Any, Optional
@@ -7,6 +8,7 @@ from typing import Any, Optional
 from slixmpp import JID
 from slixmpp.exceptions import XMPPError
 
+from ..core import config
 from ..util.types import AnyBaseSession
 from .base import (
     Command,
@@ -90,8 +92,12 @@ class SlidgeInfo(AdminCommand):
             [a for a in (days_ago, hours_ago, minutes_ago, seconds_ago) if a]
         )
 
+        legacy_module = importlib.import_module(config.LEGACY_MODULE)
+        version = getattr(legacy_module, "__version__", "No version")
+
         return (
-            f"{self.xmpp.COMPONENT_NAME} version {__version__}\n"
+            f"{self.xmpp.COMPONENT_NAME} (slidge core {__version__},"
+            f" {config.LEGACY_MODULE} {version})\n"
             f"Up since {start:%Y-%m-%d %H:%M} ({ago} ago)"
         )
 

slidge/contact/contact.py

@@ -3,6 +3,7 @@ import logging
 import warnings
 from datetime import date
 from typing import TYPE_CHECKING, Generic, Iterable, Optional, Self, Union
+from xml.etree import ElementTree as ET
 
 from slixmpp import JID, Message, Presence
 from slixmpp.exceptions import IqError
@@ -125,6 +126,16 @@ class LegacyContact(
         self._is_friend: bool = False
         self._added_to_roster = False
         self._caps_ver: str | None = None
+        self._vcard_fetched = False
+        self._vcard: str | None = None
+
+    async def get_vcard(self, fetch=True) -> VCard4 | None:
+        if fetch and not self._vcard_fetched:
+            await self.fetch_vcard()
+        if self._vcard is None:
+            return None
+
+        return VCard4(xml=ET.fromstring(self._vcard))
 
     @property
     def is_friend(self):
@@ -373,7 +384,17 @@ class LegacyContact(
         elif country:
             vcard.add_address(country, locality)
 
-        self.xmpp.vcard.set_vcard(self.jid.bare, vcard, {self.user_jid.bare})
+        self._vcard = str(vcard)
+        self._vcard_fetched = True
+        self.session.create_task(
+            self.xmpp.pubsub.broadcast_vcard_event(self.jid, self.user_jid, vcard)
+        )
+
+        if self._updating_info:
+            return
+
+        assert self.contact_pk is not None
+        self.xmpp.store.contacts.set_vcard(self.contact_pk, self._vcard)
 
     def get_roster_item(self):
         item = {
@@ -584,6 +605,8 @@ class LegacyContact(
         contact._caps_ver = stored.caps_ver
         contact._set_logger_name()
         contact._set_avatar_from_store(stored)
+        contact._vcard = stored.vcard
+        contact._vcard_fetched = stored.vcard_fetched
         return contact
 
 

slidge/contact/roster.py

@@ -8,6 +8,7 @@ from slixmpp.exceptions import IqError, XMPPError
 from slixmpp.jid import JID_UNESCAPE_TRANSFORMATIONS, _unescape_node
 
 from ..core.mixins.lock import NamedLockMixin
+from ..db.models import Contact
 from ..db.store import ContactStore
 from ..util import SubclassableOnce
 from ..util.types import LegacyContactType, LegacyUserIdType
@@ -63,37 +64,6 @@ class LegacyRoster(
             for stored in self.__store.get_all(user_pk=self.session.user_pk):
                 yield self._contact_cls.from_store(self.session, stored)
 
-    async def __finish_init_contact(
-        self, legacy_id: LegacyUserIdType, jid_username: str, *args, **kwargs
-    ):
-        async with self.lock(("finish", legacy_id)):
-            with self.__store.session():
-                stored = self.__store.get_by_legacy_id(
-                    self.session.user_pk, str(legacy_id)
-                )
-                if stored is not None:
-                    if stored.updated:
-                        return self._contact_cls.from_store(self.session, stored)
-                    c: LegacyContact = self._contact_cls(
-                        self.session, legacy_id, jid_username, *args, **kwargs
-                    )
-                    c.contact_pk = stored.id
-                else:
-                    c = self._contact_cls(
-                        self.session, legacy_id, jid_username, *args, **kwargs
-                    )
-                try:
-                    with c.updating_info():
-                        await c.avatar_wrap_update_info()
-                except Exception as e:
-                    raise XMPPError("internal-server-error", str(e))
-                c._caps_ver = await c.get_caps_ver(c.jid)
-                need_avatar = c.contact_pk is None
-                c.contact_pk = self.__store.update(c, commit=not self.__filling)
-                if need_avatar:
-                    c._post_avatar_update()
-        return c
-
     def known_contacts(self, only_friends=True) -> dict[str, LegacyContactType]:
         if only_friends:
             return {c.jid.bare: c for c in self if c.is_friend}
@@ -112,17 +82,15 @@ class LegacyRoster(
         # """
         username = contact_jid.node
         async with self.lock(("username", username)):
-            with self.__store.session():
-                stored = self.__store.get_by_jid(self.session.user_pk, contact_jid)
-                if stored is not None and stored.updated:
-                    return self._contact_cls.from_store(self.session, stored)
-
             legacy_id = await self.jid_username_to_legacy_id(username)
             log.debug("Contact %s not found", contact_jid)
             if self.get_lock(("legacy_id", legacy_id)):
                 log.debug("Already updating %s", contact_jid)
                 return await self.by_legacy_id(legacy_id)
-            return await self.__finish_init_contact(legacy_id, username)
+
+            with self.__store.session():
+                stored = self.__store.get_by_jid(self.session.user_pk, contact_jid)
+                return await self.__update_contact(stored, legacy_id, username)
 
     async def by_legacy_id(
         self, legacy_id: LegacyUserIdType, *args, **kwargs
@@ -145,26 +113,48 @@ class LegacyRoster(
         if legacy_id == self.user_legacy_id:
             raise ContactIsUser
         async with self.lock(("legacy_id", legacy_id)):
-            with self.__store.session():
-                stored = self.__store.get_by_legacy_id(
-                    self.session.user_pk, str(legacy_id)
-                )
-                if stored is not None and stored.updated:
-                    return self._contact_cls.from_store(
-                        self.session, stored, *args, **kwargs
-                    )
-
             username = await self.legacy_id_to_jid_username(legacy_id)
-            log.debug("Contact %s not found", legacy_id)
             if self.get_lock(("username", username)):
                 log.debug("Already updating %s", username)
                 jid = JID()
                 jid.node = username
                 jid.domain = self.session.xmpp.boundjid.bare
                 return await self.by_jid(jid)
-            return await self.__finish_init_contact(
-                legacy_id, username, *args, **kwargs
-            )
+
+            with self.__store.session():
+                stored = self.__store.get_by_legacy_id(
+                    self.session.user_pk, str(legacy_id)
+                )
+                return await self.__update_contact(
+                    stored, legacy_id, username, *args, **kwargs
+                )
+
+    async def __update_contact(
+        self,
+        stored: Contact | None,
+        legacy_id: LegacyUserIdType,
+        username: str,
+        *a,
+        **kw,
+    ) -> LegacyContactType:
+        if stored is None:
+            contact = self._contact_cls(self.session, legacy_id, username, *a, **kw)
+        else:
+            contact = self._contact_cls.from_store(self.session, stored, *a, **kw)
+            if stored.updated:
+                return contact
+
+        try:
+            with contact.updating_info():
+                await contact.avatar_wrap_update_info()
+        except Exception as e:
+            raise XMPPError("internal-server-error", str(e))
+        contact._caps_ver = await contact.get_caps_ver(contact.jid)
+        need_avatar = contact.contact_pk is None
+        contact.contact_pk = self.__store.update(contact, commit=not self.__filling)
+        if need_avatar:
+            contact._post_avatar_update()
+        return contact
 
     async def by_stanza(self, s) -> LegacyContact:
         # """
@@ -225,7 +215,7 @@ class LegacyRoster(
                 item = contact.get_roster_item()
                 old = user_roster.get(contact.jid.bare)
                 if old is not None and all(
-                    old[k] == item[contact.jid.bare][k]
+                    old[k] == item[contact.jid.bare].get(k)
                     for k in ("subscription", "groups", "name")
                 ):
                     self.log.debug("No need to update roster")

slidge/core/gateway/base.py

@@ -36,7 +36,6 @@ from ...command.register import RegistrationType
 from ...db import GatewayUser, SlidgeStore
 from ...db.avatar import avatar_cache
 from ...slixfix.roster import RosterBackend
-from ...slixfix.xep_0292.vcard4 import VCard4Provider
 from ...util import ABCSubclassableOnceAtMost
 from ...util.types import AvatarType, MessageOrPresenceTypeVar
 from ...util.util import timeit
@@ -316,7 +315,7 @@ class BaseGateway(
 
         from ...group.room import LegacyMUC
 
-        LegacyMUC.get_unique_subclass().xmpp = self
+        LegacyMUC.get_self_or_unique_subclass().xmpp = self
 
         self.get_session_from_stanza: Callable[
             [Union[Message, Presence, Iq]], BaseSession
@@ -331,7 +330,6 @@ class BaseGateway(
 
         self.register_plugin("pubsub", {"component_name": self.COMPONENT_NAME})
         self.pubsub: PubSubComponent = self["pubsub"]
-        self.vcard: VCard4Provider = self["xep_0292_provider"]
         self.delivery_receipt: DeliveryReceipt = DeliveryReceipt(self)
 
         # with this we receive user avatar updates

slidge/core/gateway/session_dispatcher.py

@@ -68,6 +68,13 @@ class SessionDispatcher:
                 _exceptions_to_xmpp_errors(self.on_ibr_remove),  # type: ignore
             )
         )
+        self.xmpp.register_handler(
+            CoroutineCallback(
+                "get_vcard",
+                StanzaPath("iq@type=get/vcard"),
+                _exceptions_to_xmpp_errors(self.on_get_vcard),  # type:ignore
+            )
+        )
 
         for event in (
             "legacy_message",
@@ -778,6 +785,18 @@ class SessionDispatcher:
 
         raise XMPPError("feature-not-implemented")
 
+    async def on_get_vcard(self, iq: Iq):
+        session = await self.__get_session(iq)
+        session.raise_if_not_logged()
+        contact = await session.contacts.by_jid(iq.get_to())
+        vcard = await contact.get_vcard()
+        reply = iq.reply()
+        if vcard:
+            reply.append(vcard)
+        else:
+            reply.enable("vcard")
+        reply.send()
+
     def _xmpp_msg_id_to_legacy(self, session: "BaseSession", xmpp_id: str):
         sent = self.xmpp.store.sent.get_legacy_id(session.user_pk, xmpp_id)
         if sent is not None:

slidge/core/gateway/vcard_temp.py

@@ -79,14 +79,14 @@ class VCardTemp:
             elif not (contact := entity.contact):
                 raise XMPPError("item-not-found", "This participant has no contact")
             else:
-                vcard = await self.xmpp.vcard.get_vcard(contact.jid, iq.get_from())
+                vcard = await contact.get_vcard()
                 avatar = contact.get_avatar()
                 type_ = "image/png"
         else:
             avatar = entity.get_avatar()
             type_ = "image/png"
             if isinstance(entity, LegacyContact):
-                vcard = await self.xmpp.vcard.get_vcard(entity.jid, iq.get_from())
+                vcard = await entity.get_vcard(fetch=False)
             else:
                 vcard = None
         v = self.xmpp.plugin["xep_0054"].make_vcard()

slidge/core/pubsub.py

@@ -22,6 +22,7 @@ from slixmpp.types import JidStr, OptJidStr
 
 from ..db.avatar import CachedAvatar, avatar_cache
 from ..db.store import ContactStore, SlidgeStore
+from ..util.types import URL
 from .mixins.lock import NamedLockMixin
 
 if TYPE_CHECKING:
@@ -135,6 +136,7 @@ class PubSubComponent(NamedLockMixin, BasePlugin):
 
         to = p.get_to()
 
+        contact = None
         # we don't want to push anything for contacts that are not in the user's roster
         if to != self.xmpp.boundjid.bare:
             session = self.xmpp.get_session_from_stanza(p)
@@ -170,14 +172,13 @@ class PubSubComponent(NamedLockMixin, BasePlugin):
             except XMPPError:
                 pass
             else:
-                if pep_avatar.metadata is None:
-                    raise XMPPError("internal-server-error", "Avatar but no metadata?")
-                await self.__broadcast(
-                    data=pep_avatar.metadata,
-                    from_=p.get_to(),
-                    to=from_,
-                    id=pep_avatar.metadata["info"]["id"],
-                )
+                if pep_avatar.metadata is not None:
+                    await self.__broadcast(
+                        data=pep_avatar.metadata,
+                        from_=p.get_to(),
+                        to=from_,
+                        id=pep_avatar.metadata["info"]["id"],
+                    )
         if UserNick.namespace + "+notify" in features:
             try:
                 pep_nick = await self._get_authorized_nick(p)
@@ -186,17 +187,19 @@ class PubSubComponent(NamedLockMixin, BasePlugin):
             else:
                 await self.__broadcast(data=pep_nick.nick, from_=p.get_to(), to=from_)
 
-        if VCARD4_NAMESPACE + "+notify" in features:
-            await self.broadcast_vcard_event(p.get_to(), to=from_)
+        if contact is not None and VCARD4_NAMESPACE + "+notify" in features:
+            await self.broadcast_vcard_event(
+                p.get_to(), from_, await contact.get_vcard()
+            )
 
-    async def broadcast_vcard_event(self, from_, to):
+    async def broadcast_vcard_event(self, from_: JID, to: JID, vcard: VCard4 | None):
         item = Item()
         item.namespace = VCARD4_NAMESPACE
         item["id"] = "current"
-        vcard: VCard4 = await self.xmpp["xep_0292_provider"].get_vcard(from_, to)
+        # vcard: VCard4 = await self.xmpp["xep_0292_provider"].get_vcard(from_, to)
         # The vcard content should NOT be in this event according to the spec:
         # https://xmpp.org/extensions/xep-0292.html#sect-idm45669698174224
-        # but movim expects it to be here, and I guess
+        # but movim expects it to be here, and I guess it does not hurt
 
         log.debug("Broadcast vcard4 event: %s", vcard)
         await self.__broadcast(
@@ -219,7 +222,9 @@ class PubSubComponent(NamedLockMixin, BasePlugin):
         item = PepAvatar()
         avatar_id = entity.avatar_id
         if avatar_id is not None:
-            stored = avatar_cache.get(str(avatar_id))
+            stored = avatar_cache.get(
+                avatar_id if isinstance(avatar_id, URL) else str(avatar_id)
+            )
             assert stored is not None
             item.set_avatar_from_cache(stored)
         return item
@@ -268,10 +273,9 @@ class PubSubComponent(NamedLockMixin, BasePlugin):
         # this is not the proper way that clients should retrieve VCards, but
         # gajim does it this way.
         # https://xmpp.org/extensions/xep-0292.html#sect-idm45669698174224
-        vcard: VCard4 = await self.xmpp["xep_0292_provider"].get_vcard(
-            iq.get_to().bare, iq.get_from().bare
-        )
-        log.debug("VCARD: %s -- %s -- %s", iq.get_to().bare, iq.get_from().bare, vcard)
+        session = self.xmpp.get_session_from_stanza(iq)
+        contact = await session.contacts.by_jid(iq.get_to())
+        vcard = await contact.get_vcard()
         if vcard is None:
             raise XMPPError("item-not-found")
         self._reply_with_payload(iq, vcard, "current", VCARD4_NAMESPACE)

slidge/db/alembic/old_user_store.py

@@ -0,0 +1,183 @@
+"""
+This module covers a backend for storing user data persistently and managing a
+pseudo-roster for the gateway component.
+"""
+
+import dataclasses
+import datetime
+import logging
+import os.path
+import shelve
+from io import BytesIO
+from os import PathLike
+from typing import Iterable, Optional, Union
+
+from pickle_secure import Pickler, Unpickler
+from slixmpp import JID, Iq, Message, Presence
+
+
+# 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
+    ):
+        super().__init__(str(filename), flag, protocol, writeback)
+        self.secret_key = key
+
+    def __getitem__(self, key):
+        try:
+            value = self.cache[key]
+        except KeyError:
+            f = BytesIO(self.dict[key.encode(self.keyencoding)])
+            value = Unpickler(f, key=self.secret_key).load()  # type:ignore
+            if self.writeback:
+                self.cache[key] = value
+        return value
+
+    def __setitem__(self, key, value):
+        if self.writeback:
+            self.cache[key] = value
+        f = BytesIO()
+        p = Pickler(f, self._protocol, key=self.secret_key)  # type:ignore
+        p.dump(value)
+        self.dict[key.encode(self.keyencoding)] = f.getvalue()
+
+
+@dataclasses.dataclass
+class GatewayUser:
+    """
+    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)
+
+    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:
+        """
+        The user's (bare) JID
+
+        :return:
+        """
+        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
+        # """
+        return self.registration_form.get(field, default)
+
+
+class UserStore:
+    """
+    Basic user store implementation using shelve from the python standard library
+
+    Set_file must be called before it is usable
+    """
+
+    def __init__(self):
+        self._users: shelve.Shelf[GatewayUser] = None  # type: ignore
+
+    def set_file(self, filename: PathLike, secret_key: Optional[str] = None):
+        """
+        Set the file to use to store user data
+
+        :param filename: Path to the shelf file
+        :param secret_key: Secret key to store files encrypted on disk
+        """
+        if self._users is not None:
+            raise RuntimeError("Shelf file already set!")
+        if os.path.exists(filename):
+            log.info("Using existing slidge DB: %s", filename)
+        else:
+            log.info("Creating a new slidge DB: %s", filename)
+        if secret_key:
+            self._users = EncryptedShelf(filename, key=secret_key)
+        else:
+            self._users = shelve.open(str(filename))
+        log.info("Registered users in the DB: %s", list(self._users.keys()))
+
+    def get_all(self) -> Iterable[GatewayUser]:
+        """
+        Get all users in the store
+
+        :return: An iterable of GatewayUsers
+        """
+        return self._users.values()
+
+    def commit(self, user: GatewayUser):
+        self._users[user.jid.bare] = 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 internal API
+
+        :param _gateway_jid:
+        :param _node:
+        :param ifrom:
+        :param iq:
+        :return:
+        """
+        if ifrom is None:  # bug in SliXMPP's XEP_0100 plugin
+            ifrom = iq["from"]
+        log.debug("Getting user %s", ifrom.bare)
+        return self._users.get(ifrom.bare)
+
+    def get_by_jid(self, jid: JID) -> Optional[GatewayUser]:
+        """
+        Convenience function to get a user from their JID.
+
+        :param jid: JID of the gateway user
+        :return:
+        """
+        return self._users.get(jid.bare)
+
+    def get_by_stanza(self, s: Union[Presence, Message, Iq]) -> Optional[GatewayUser]:
+        """
+        Convenience function to get a user from a stanza they sent.
+
+        :param s: A stanza sent by the gateway user
+        :return:
+        """
+        return self.get_by_jid(s.get_from())
+
+    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/db/alembic/versions/5bd48bfdffa2_lift_room_legacy_id_constraint.py

@@ -0,0 +1,44 @@
+"""Lift room legacy ID constraint
+
+Revision ID: 5bd48bfdffa2
+Revises: b64b1a793483
+Create Date: 2024-07-24 10:29:23.467851
+
+"""
+
+from typing import Sequence, Union
+
+from alembic import op
+
+from slidge.db.models import Room
+
+# revision identifiers, used by Alembic.
+revision: str = "5bd48bfdffa2"
+down_revision: Union[str, None] = "b64b1a793483"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    with op.batch_alter_table(
+        "room",
+        schema=None,
+        # without copy_from, the newly created table keeps the constraints
+        # we actually want to ditch.
+        copy_from=Room.__table__,  # type:ignore
+    ) as batch_op:
+        batch_op.create_unique_constraint(
+            "uq_room_user_account_id_jid", ["user_account_id", "jid"]
+        )
+        batch_op.create_unique_constraint(
+            "uq_room_user_account_id_legacy_id", ["user_account_id", "legacy_id"]
+        )
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table("room", schema=None) as batch_op:
+        batch_op.drop_constraint("uq_room_user_account_id_legacy_id", type_="unique")
+        batch_op.drop_constraint("uq_room_user_account_id_jid", type_="unique")
+
+    # ### end Alembic commands ###

slidge/db/alembic/versions/8b993243a536_add_vcard_content_to_contact_table.py

@@ -0,0 +1,43 @@
+"""Add vcard content to contact table
+
+Revision ID: 8b993243a536
+Revises: 5bd48bfdffa2
+Create Date: 2024-07-24 07:02:47.770894
+
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "8b993243a536"
+down_revision: Union[str, None] = "5bd48bfdffa2"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table("contact", schema=None) as batch_op:
+        batch_op.add_column(sa.Column("vcard", sa.String(), nullable=True))
+        batch_op.add_column(
+            sa.Column(
+                "vcard_fetched",
+                sa.Boolean(),
+                nullable=False,
+                server_default=sa.sql.true(),
+            )
+        )
+
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table("contact", schema=None) as batch_op:
+        batch_op.drop_column("vcard_fetched")
+        batch_op.drop_column("vcard")
+
+    # ### end Alembic commands ###