slidge 0.2.0a3__tar.gz → 0.2.0a4__tar.gz

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

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

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

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

{slidge-0.2.0a3 → 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.0alpha3"
+__version__ = "0.2.0alpha4"

{slidge-0.2.0a3 → 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.0a3 → slidge-0.2.0a4}/slidge/contact/contact.py

@@ -129,8 +129,8 @@ class LegacyContact(
         self._vcard_fetched = False
         self._vcard: str | None = None
 
-    async def get_vcard(self) -> VCard4 | None:
-        if not self._vcard_fetched:
+    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

{slidge-0.2.0a3 → 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.0a3 → slidge-0.2.0a4}/slidge/core/gateway/base.py

@@ -315,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

{slidge-0.2.0a3 → slidge-0.2.0a4}/slidge/core/gateway/vcard_temp.py

@@ -86,7 +86,7 @@ class VCardTemp:
             avatar = entity.get_avatar()
             type_ = "image/png"
             if isinstance(entity, LegacyContact):
-                vcard = await entity.get_vcard()
+                vcard = await entity.get_vcard(fetch=False)
             else:
                 vcard = None
         v = self.xmpp.plugin["xep_0054"].make_vcard()

{slidge-0.2.0a3 → 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:
@@ -171,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)
@@ -222,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

{slidge-0.2.0a3 → 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.0a3 → slidge-0.2.0a4}/slidge/db/store.py

@@ -162,12 +162,20 @@ class AvatarStore(EngineMixin):
 class SentStore(EngineMixin):
     def set_message(self, user_pk: int, legacy_id: str, xmpp_id: str) -> None:
         with self.session() as session:
-            msg = XmppToLegacyIds(
-                user_account_id=user_pk,
-                legacy_id=legacy_id,
-                xmpp_id=xmpp_id,
-                type=XmppToLegacyEnum.DM,
+            msg = (
+                session.query(XmppToLegacyIds)
+                .filter(XmppToLegacyIds.user_account_id == user_pk)
+                .filter(XmppToLegacyIds.legacy_id == legacy_id)
+                .filter(XmppToLegacyIds.xmpp_id == xmpp_id)
+                .scalar()
             )
+            if msg is None:
+                msg = XmppToLegacyIds(user_account_id=user_pk)
+            else:
+                log.debug("Resetting a DM from sent store")
+            msg.legacy_id = legacy_id
+            msg.xmpp_id = xmpp_id
+            msg.type = XmppToLegacyEnum.DM
             session.add(msg)
             session.commit()
 
@@ -625,6 +633,7 @@ class MAMStore(EngineMixin):
         with self.session() as session:
             after_timestamp = (
                 session.query(ArchivedMessage.timestamp)
+                .filter(ArchivedMessage.room_id == room_pk)
                 .filter(ArchivedMessage.legacy_id == after_id)
                 .scalar()
             )
@@ -778,7 +787,10 @@ class RoomStore(UpdatedMixin):
         with self.session() as session:
             session.execute(
                 update(Room).values(
-                    subject_setter=None, user_resources=None, history_filled=False
+                    subject_setter=None,
+                    user_resources=None,
+                    history_filled=False,
+                    participants_filled=False,
                 )
             )
             session.commit()
@@ -890,6 +902,13 @@ class RoomStore(UpdatedMixin):
             )
             session.commit()
 
+    def update_user_nick(self, room_pk, nick: str) -> None:
+        with self.session() as session:
+            session.execute(
+                update(Room).where(Room.id == room_pk).values(user_nick=nick)
+            )
+            session.commit()
+
     def delete(self, room_pk: int) -> None:
         with self.session() as session:
             session.execute(delete(Room).where(Room.id == room_pk))

{slidge-0.2.0a3 → slidge-0.2.0a4}/slidge/group/bookmarks.py

@@ -8,6 +8,7 @@ from slixmpp.jid import _unescape_node
 
 from ..contact.roster import ESCAPE_TABLE
 from ..core.mixins.lock import NamedLockMixin
+from ..db.models import Room
 from ..util import SubclassableOnce
 from ..util.types import LegacyGroupIdType, LegacyMUCType
 from .archive import MessageArchive
@@ -57,29 +58,6 @@ class LegacyBookmarks(
     def __repr__(self):
         return f"<Bookmarks of {self.user_jid}>"
 
-    async def __finish_init_muc(self, legacy_id: LegacyGroupIdType, jid: JID):
-        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._muc_class.from_store(self.session, stored)
-                muc = self._muc_class(self.session, legacy_id=legacy_id, jid=jid)
-                muc.pk = stored.id
-            else:
-                muc = self._muc_class(self.session, legacy_id=legacy_id, jid=jid)
-
-            try:
-                with muc.updating_info():
-                    await muc.avatar_wrap_update_info()
-            except Exception as e:
-                raise XMPPError("internal-server-error", str(e))
-            if not muc.user_nick:
-                muc.user_nick = self._user_nick
-            self.log.debug("MUC created: %r", muc)
-            muc.pk = self.__store.update(muc)
-            muc.archive = MessageArchive(muc.pk, self.xmpp.store.mam)
-        return muc
-
     async def legacy_id_to_jid_local_part(self, legacy_id: LegacyGroupIdType):
         return await self.legacy_id_to_jid_username(legacy_id)
 
@@ -110,24 +88,16 @@ class LegacyBookmarks(
     async def by_jid(self, jid: JID) -> LegacyMUCType:
         if jid.resource:
             jid = JID(jid.bare)
-        bare = jid.bare
-        async with self.lock(("bare", bare)):
-            assert isinstance(jid.username, str)
-            legacy_id = await self.jid_local_part_to_legacy_id(jid.username)
+        async with self.lock(("bare", jid.bare)):
+            assert isinstance(jid.local, str)
+            legacy_id = await self.jid_local_part_to_legacy_id(jid.local)
             if self.get_lock(("legacy_id", legacy_id)):
                 self.log.debug("Not instantiating %s after all", jid)
                 return await self.by_legacy_id(legacy_id)
 
             with self.__store.session():
                 stored = self.__store.get_by_jid(self.session.user_pk, jid)
-                if stored is not None and stored.updated:
-                    return self._muc_class.from_store(self.session, stored)
-
-            self.log.debug("Attempting to instantiate a new MUC for JID %s", jid)
-            local_part = jid.node
-
-            self.log.debug("%r is group %r", local_part, legacy_id)
-            return await self.__finish_init_muc(legacy_id, JID(bare))
+                return await self.__update_muc(stored, legacy_id, jid)
 
     def by_jid_only_if_exists(self, jid: JID) -> Optional[LegacyMUCType]:
         with self.__store.session():
@@ -138,22 +108,39 @@ class LegacyBookmarks(
 
     async def by_legacy_id(self, legacy_id: LegacyGroupIdType) -> LegacyMUCType:
         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._muc_class.from_store(self.session, stored)
-            self.log.debug("Create new MUC instance for legacy ID %s", legacy_id)
             local = await self.legacy_id_to_jid_local_part(legacy_id)
-            bare = f"{local}@{self.xmpp.boundjid}"
-            jid = JID(bare)
-            if self.get_lock(("bare", bare)):
+            jid = JID(f"{local}@{self.xmpp.boundjid}")
+            if self.get_lock(("bare", jid.bare)):
                 self.log.debug("Not instantiating %s after all", legacy_id)
                 return await self.by_jid(jid)
-            muc = await self.__finish_init_muc(legacy_id, jid)
 
-            return muc
+            with self.__store.session():
+                stored = self.__store.get_by_legacy_id(
+                    self.session.user_pk, str(legacy_id)
+                )
+                return await self.__update_muc(stored, legacy_id, jid)
+
+    async def __update_muc(
+        self, stored: Room | None, legacy_id: LegacyGroupIdType, jid: JID
+    ):
+        if stored is None:
+            muc = self._muc_class(self.session, legacy_id=legacy_id, jid=jid)
+        else:
+            muc = self._muc_class.from_store(self.session, stored)
+            if stored.updated:
+                return muc
+
+        try:
+            with muc.updating_info():
+                await muc.avatar_wrap_update_info()
+        except Exception as e:
+            raise XMPPError("internal-server-error", str(e))
+        if not muc.user_nick:
+            muc.user_nick = self._user_nick
+        self.log.debug("MUC created: %r", muc)
+        muc.pk = self.__store.update(muc)
+        muc.archive = MessageArchive(muc.pk, self.xmpp.store.mam)
+        return muc
 
     @abc.abstractmethod
     async def fill(self):

{slidge-0.2.0a3 → slidge-0.2.0a4}/slidge/group/participant.py

@@ -450,13 +450,21 @@ class LegacyParticipant(
         return super().get_disco_info()
 
     def moderate(self, legacy_msg_id: LegacyMessageType, reason: Optional[str] = None):
-        m = self.muc.get_system_participant()._make_message()
-        m["apply_to"]["id"] = self._legacy_to_xmpp(legacy_msg_id)
-        m["apply_to"]["moderated"].enable("retract")
-        m["apply_to"]["moderated"]["by"] = self.jid
-        if reason:
-            m["apply_to"]["moderated"]["reason"] = reason
-        self._send(m)
+        xmpp_id = self._legacy_to_xmpp(legacy_msg_id)
+        multi = self.xmpp.store.multi.get_xmpp_ids(self.session.user_pk, xmpp_id)
+        if multi is None:
+            msg_ids = [xmpp_id]
+        else:
+            msg_ids = multi + [xmpp_id]
+
+        for i in msg_ids:
+            m = self.muc.get_system_participant()._make_message()
+            m["apply_to"]["id"] = i
+            m["apply_to"]["moderated"].enable("retract")
+            m["apply_to"]["moderated"]["by"] = self.jid
+            if reason:
+                m["apply_to"]["moderated"]["reason"] = reason
+            self._send(m)
 
     def set_room_subject(
         self,

{slidge-0.2.0a3 → slidge-0.2.0a4}/slidge/group/room.py

@@ -206,6 +206,8 @@ class LegacyMUC(
     @user_nick.setter
     def user_nick(self, nick: str):
         self._user_nick = nick
+        if not self._updating_info:
+            self.__store.update_user_nick(self.pk, nick)
 
     def add_user_resource(self, resource: str) -> None:
         self._user_resources.add(resource)
@@ -1195,7 +1197,7 @@ class LegacyMUC(
         )
         muc.pk = stored.id
         muc.type = stored.muc_type  # type: ignore
-        muc.user_nick = stored.user_nick
+        muc._user_nick = stored.user_nick
         if stored.name:
             muc.DISCO_NAME = stored.name
         if stored.description:

slidge-0.2.0a4/slidge/util/db.py

@@ -0,0 +1,5 @@
+# here to allow migration of the user store from v0.1
+# since it relies on shelf, which relies on pickle, we need to keep objects
+# importable where they were when the shelf was written
+
+from ..db.alembic.old_user_store import *  # noqa:F403