slidge 0.2.0a2__tar.gz → 0.2.0a4__tar.gz

{slidge-0.2.0a2 → slidge-0.2.0a4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: slidge
-Version: 0.2.0a2
+Version: 0.2.0a4
 Summary: XMPP bridging framework
 Home-page: https://sr.ht/~nicoco/slidge/
 License: AGPL-3.0-or-later

{slidge-0.2.0a2 → slidge-0.2.0a4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "slidge"
-version = "0.2.0alpha2"
+version = "0.2.0alpha4"
 description = "XMPP bridging framework"
 authors = ["Nicolas Cedilnik <nicoco@nicoco.fr>"]
 readme = "README.md"

{slidge-0.2.0a2 → slidge-0.2.0a4}/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-0.2.0a2 → slidge-0.2.0a4}/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-0.2.0a2 → slidge-0.2.0a4}/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-0.2.0a2 → slidge-0.2.0a4}/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-0.2.0a2 → slidge-0.2.0a4}/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-0.2.0a2 → slidge-0.2.0a4}/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-0.2.0a2 → slidge-0.2.0a4}/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-0.2.0a2 → slidge-0.2.0a4}/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-0.2.0a4/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-0.2.0a4/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 ###

{slidge-0.2.0a2 → slidge-0.2.0a4}/slidge/db/alembic/versions/aa9d82a7f6ef_db_creation.py

@@ -58,10 +58,19 @@ def downgrade() -> None:
 
 
 def migrate_from_shelf(accounts: sa.Table) -> None:
+    from slidge import global_config
+
+    db_file = global_config.HOME_DIR / "slidge.db"
+    if not db_file.exists():
+        return
+
     try:
-        from slidge.util.db import user_store
+        from slidge.db.alembic.old_user_store import user_store
     except ImportError:
         return
+
+    user_store.set_file(db_file, global_config.SECRET_KEY)
+
     try:
         users = list(user_store.get_all())
     except AttributeError:
@@ -83,3 +92,6 @@ def migrate_from_shelf(accounts: sa.Table) -> None:
             for user in users
         ],
     )
+
+    user_store.close()
+    db_file.unlink()

{slidge-0.2.0a2 → slidge-0.2.0a4}/slidge/db/avatar.py

@@ -206,6 +206,11 @@ class AvatarCache:
             stored = orm.execute(select(Avatar).where(Avatar.hash == hash_)).scalar()
 
             if stored is not None:
+                if unique_id is not None:
+                    log.warning("Updating 'unique' IDs of a known avatar.")
+                    stored.legacy_id = str(unique_id)
+                    orm.add(stored)
+                    orm.commit()
                 return CachedAvatar.from_store(stored, self.dir)
 
             stored = Avatar(

{slidge-0.2.0a2 → slidge-0.2.0a4}/slidge/db/meta.py

@@ -58,6 +58,13 @@ JSONSerializable = dict[str, JSONSerializableTypes]
 
 class Base(sa.orm.DeclarativeBase):
     type_annotation_map = {JSONSerializable: JSONEncodedDict, JID: JIDType}
+    naming_convention = {
+        "ix": "ix_%(column_0_label)s",
+        "uq": "uq_%(table_name)s_%(column_0_name)s",
+        "ck": "ck_%(table_name)s_`%(constraint_name)s`",
+        "fk": "fk_%(table_name)s_%(column_0_name)s_%(referred_table_name)s",
+        "pk": "pk_%(table_name)s",
+    }
 
 
 def get_engine(path: str) -> sa.Engine:

{slidge-0.2.0a2 → slidge-0.2.0a4}/slidge/db/models.py

@@ -166,6 +166,9 @@ class Contact(Base):
     )
     updated: Mapped[bool] = mapped_column(default=False)
 
+    vcard: Mapped[Optional[str]] = mapped_column()
+    vcard_fetched: Mapped[bool] = mapped_column(default=False)
+
     participants: Mapped[list["Participant"]] = relationship(back_populates="contact")
 
 
@@ -191,13 +194,20 @@ class Room(Base):
     Legacy room
     """
 
+    __table_args__ = (
+        UniqueConstraint(
+            "user_account_id", "legacy_id", name="uq_room_user_account_id_legacy_id"
+        ),
+        UniqueConstraint("user_account_id", "jid", name="uq_room_user_account_id_jid"),
+    )
+
     __tablename__ = "room"
     id: Mapped[int] = mapped_column(primary_key=True)
     user_account_id: Mapped[int] = mapped_column(ForeignKey("user_account.id"))
     user: Mapped[GatewayUser] = relationship(back_populates="rooms")
-    legacy_id: Mapped[str] = mapped_column(unique=True, nullable=False)
+    legacy_id: Mapped[str] = mapped_column(nullable=False)
 
-    jid: Mapped[JID] = mapped_column(unique=True)
+    jid: Mapped[JID] = mapped_column(nullable=False)
 
     avatar_id: Mapped[int] = mapped_column(ForeignKey("avatar.id"), nullable=True)
     avatar: Mapped[Avatar] = relationship(back_populates="rooms")