slidge 0.2.0a0__py3-none-any.whl → 0.2.0a1__py3-none-any.whl

slidge/group/room.py

@@ -5,7 +5,7 @@ import string
 import warnings
 from copy import copy
 from datetime import datetime, timedelta, timezone
-from typing import TYPE_CHECKING, Generic, Optional, Self, Union
+from typing import TYPE_CHECKING, AsyncIterator, Generic, Optional, Self, Union
 from uuid import uuid4
 
 from slixmpp import JID, Iq, Message, Presence
@@ -21,12 +21,14 @@ from ..contact.roster import ContactIsUser
 from ..core import config
 from ..core.mixins import StoredAttributeMixin
 from ..core.mixins.avatar import AvatarMixin
+from ..core.mixins.db import UpdateInfoMixin
 from ..core.mixins.disco import ChatterDiscoMixin
 from ..core.mixins.lock import NamedLockMixin
 from ..core.mixins.recipient import ReactionRecipientMixin, ThreadRecipientMixin
 from ..db.models import Room
 from ..util import ABCSubclassableOnceAtMost
 from ..util.types import (
+    HoleBound,
     LegacyGroupIdType,
     LegacyMessageType,
     LegacyParticipantType,
@@ -35,7 +37,7 @@ from ..util.types import (
     MucAffiliation,
     MucType,
 )
-from ..util.util import deprecated
+from ..util.util import deprecated, timeit, with_session
 from .archive import MessageArchive
 from .participant import LegacyParticipant
 
@@ -45,11 +47,14 @@ if TYPE_CHECKING:
 
 ADMIN_NS = "http://jabber.org/protocol/muc#admin"
 
+SubjectSetterType = Union[str, None, "LegacyContact", "LegacyParticipant"]
+
 
 class LegacyMUC(
     Generic[
         LegacyGroupIdType, LegacyMessageType, LegacyParticipantType, LegacyUserIdType
     ],
+    UpdateInfoMixin,
     StoredAttributeMixin,
     AvatarMixin,
     NamedLockMixin,
@@ -120,7 +125,6 @@ class LegacyMUC(
     tries to set the room subject.
     """
 
-    _avatar_pubsub_broadcast = False
     _avatar_bare_jid = True
     archive: MessageArchive
 
@@ -137,15 +141,13 @@ class LegacyMUC(
         self.Participant = LegacyParticipant.get_self_or_unique_subclass()
 
         self._subject = ""
-        self._subject_setter: Union[str, None, "LegacyContact", "LegacyParticipant"] = (
-            None
-        )
+        self._subject_setter: Optional[str] = None
 
         self.pk: Optional[int] = None
         self._user_nick: Optional[str] = None
 
         self._participants_filled = False
-        self.__history_filled = False
+        self._history_filled = False
         self._description = ""
         self._subject_date: Optional[datetime] = None
 
@@ -165,6 +167,8 @@ class LegacyMUC(
         if self._n_participants == n_participants:
             return
         self._n_participants = n_participants
+        if self._updating_info:
+            return
         assert self.pk is not None
         self.__store.update_n_participants(self.pk, n_participants)
 
@@ -182,6 +186,8 @@ class LegacyMUC(
     @subject_date.setter
     def subject_date(self, when: Optional[datetime]) -> None:
         self._subject_date = when
+        if self._updating_info:
+            return
         assert self.pk is not None
         self.__store.update_subject_date(self.pk, when)
 
@@ -211,39 +217,66 @@ class LegacyMUC(
         self.__store.set_resource(self.pk, self._user_resources)
 
     async def __fill_participants(self):
+        if self._participants_filled:
+            return
+        assert self.pk is not None
         async with self.lock("fill participants"):
-            if self._participants_filled:
-                return
             self._participants_filled = True
-            try:
-                await self.fill_participants()
-            except NotImplementedError:
-                pass
+            async for p in self.fill_participants():
+                self.__participants_store.update(p)
+                self.__store.set_participants_filled(self.pk)
+
+    async def get_participants(self) -> AsyncIterator[LegacyParticipant]:
+        assert self.pk is not None
+        if self._participants_filled:
+            for db_participant in self.xmpp.store.participants.get_all(
+                self.pk, user_included=True
+            ):
+                participant = self.Participant.from_store(self.session, db_participant)
+                yield participant
+            return
+
+        async with self.lock("fill participants"):
+            self._participants_filled = True
+            # We only fill the participants list if/when the MUC is first
+            # joined by an XMPP client. But we may have instantiated
+            resources = set[str]()
+            for db_participant in self.xmpp.store.participants.get_all(
+                self.pk, user_included=True
+            ):
+                participant = self.Participant.from_store(self.session, db_participant)
+                resources.add(participant.jid.resource)
+                yield participant
+            async for p in self.fill_participants():
+                if p.jid.resource not in resources:
+                    yield p
+            self.__store.set_participants_filled(self.pk)
+            return
 
     async def __fill_history(self):
         async with self.lock("fill history"):
-            if self.__history_filled:
+            if self._history_filled:
                 log.debug("History has already been fetched %s", self)
                 return
             log.debug("Fetching history for %s", self)
-            for msg in self.archive:
-                try:
-                    legacy_id = self.session.xmpp_to_legacy_msg_id(msg.id)
-                    oldest_date = msg.when
-                except Exception as e:
-                    # not all archived stanzas have a valid legacy msg ID, eg
-                    # reactions, corrections, message with multiple attachments…
-                    self.log.debug(f"Could not convert during history back-filling {e}")
-                else:
-                    break
-            else:
-                legacy_id = None
-                oldest_date = None
             try:
-                await self.backfill(legacy_id, oldest_date)
+                before, after = self.archive.get_hole_bounds()
+                if before is not None:
+                    before = before._replace(
+                        id=self.xmpp.LEGACY_MSG_ID_TYPE(before.id)  # type:ignore
+                    )
+                if after is not None:
+                    after = after._replace(
+                        id=self.xmpp.LEGACY_MSG_ID_TYPE(after.id)  # type:ignore
+                    )
+                await self.backfill(before, after)
             except NotImplementedError:
                 return
-            self.__history_filled = True
+            except Exception as e:
+                log.exception("Could not backfill: %s", e)
+            assert self.pk is not None
+            self.__store.set_history_filled(self.pk, True)
+            self._history_filled = True
 
     @property
     def name(self):
@@ -255,6 +288,10 @@ class LegacyMUC(
             return
         self.DISCO_NAME = n
         self.__send_configuration_change((104,))
+        if self._updating_info:
+            return
+        assert self.pk is not None
+        self.__store.update_name(self.pk, n)
 
     @property
     def description(self):
@@ -265,9 +302,11 @@ class LegacyMUC(
         if self._description == d:
             return
         self._description = d
+        self.__send_configuration_change((104,))
+        if self._updating_info:
+            return
         assert self.pk is not None
         self.__store.update_description(self.pk, d)
-        self.__send_configuration_change((104,))
 
     def on_presence_unavailable(self, p: Presence):
         pto = p.get_to()
@@ -307,27 +346,35 @@ class LegacyMUC(
 
     async def backfill(
         self,
-        oldest_message_id: Optional[LegacyMessageType] = None,
-        oldest_message_date: Optional[datetime] = None,
+        after: Optional[HoleBound] = None,
+        before: Optional[HoleBound] = None,
     ):
         """
-        Override this if the legacy network provide server-side archive.
-        In it, send history messages using ``self.get_participant().send*``,
-        with the ``archive_only=True`` kwarg.
-
-        You only need to fetch messages older than ``oldest_message_id``.
-
-        :param oldest_message_id: The oldest message ID already present in the archive
-        :param oldest_message_date: The oldest message date already present in the archive
+        Override this if the legacy network provide server-side group archives.
+
+        In it, send history messages using ``self.get_participant(xxx).send_xxxx``,
+        with the ``archive_only=True`` kwarg. This is only called once per slidge
+        run for a given group.
+
+        :param after: Fetch messages after this one. If ``None``, it's up to you
+            to decide how far you want to go in the archive. If it's not ``None``,
+            it means slidge has some messages in this archive and you should really try
+            to complete it to avoid "holes" in the history of this group.
+        :param before: Fetch messages before this one. If ``None``, fetch all messages
+            up to the most recent one
         """
         raise NotImplementedError
 
-    async def fill_participants(self):
+    async def fill_participants(self) -> AsyncIterator[LegacyParticipant]:
         """
-        In here, call self.get_participant(), self.get_participant_by_contact(),
-        of self.get_user_participant() to make an initial list of participants.
+        This method should yield the list of all members of this group.
+
+        Typically, use ``participant = self.get_participant()``, self.get_participant_by_contact(),
+        of self.get_user_participant(), and update their affiliation, hats, etc.
+        before yielding them.
         """
-        raise NotImplementedError
+        return
+        yield
 
     @property
     def subject(self):
@@ -337,14 +384,13 @@ class LegacyMUC(
     def subject(self, s: str):
         if s == self._subject:
             return
-        self.session.create_task(
-            self.__get_subject_setter_participant()
-        ).add_done_callback(
-            lambda task: task.result().set_room_subject(
-                s, None, self.subject_date, False
-            )
+        self.__get_subject_setter_participant().set_room_subject(
+            s, None, self.subject_date, False
         )
+
         self._subject = s
+        if self._updating_info:
+            return
         assert self.pk is not None
         self.__store.update_subject(self.pk, s)
 
@@ -353,25 +399,29 @@ class LegacyMUC(
         return self.type == MucType.CHANNEL
 
     @property
-    def subject_setter(self):
+    def subject_setter(self) -> Optional[str]:
         return self._subject_setter
 
     @subject_setter.setter
-    def subject_setter(self, subject_setter):
-        self._subject_setter = subject_setter
-        self.__store.update(self)
+    def subject_setter(self, subject_setter: SubjectSetterType) -> None:
+        if isinstance(subject_setter, LegacyContact):
+            subject_setter = subject_setter.name
+        elif isinstance(subject_setter, LegacyParticipant):
+            subject_setter = subject_setter.nickname
 
-    async def __get_subject_setter_participant(self):
-        who = self.subject_setter
+        if subject_setter == self._subject_setter:
+            return
+        assert isinstance(subject_setter, str)
+        self._subject_setter = subject_setter
+        if self._updating_info:
+            return
+        assert self.pk is not None
+        self.__store.update_subject_setter(self.pk, subject_setter)
 
-        if isinstance(who, LegacyParticipant):
-            return who
-        elif isinstance(who, str):
-            return await self.get_participant(who, store=False)
-        elif isinstance(self.subject_setter, LegacyContact):
-            return await self.get_participant_by_contact(who)
-        else:
+    def __get_subject_setter_participant(self) -> LegacyParticipant:
+        if self._subject_setter is None:
             return self.get_system_participant()
+        return self.Participant(self, self._subject_setter)
 
     def features(self):
         features = [
@@ -410,7 +460,8 @@ class LegacyMUC(
         form.add_field("muc#roominfo_subjectmod", "boolean", value=False)
 
         if self._ALL_INFO_FILLED_ON_STARTUP or self._participants_filled:
-            n: Optional[int] = len(await self.get_participants())
+            assert self.pk is not None
+            n: Optional[int] = self.__participants_store.get_count(self.pk)
         else:
             n = self._n_participants
         if n is not None:
@@ -504,12 +555,14 @@ class LegacyMUC(
             msg.send()
 
     def _get_cached_avatar_id(self):
-        assert self.pk is not None
+        if self.pk is None:
+            return None
         return self.xmpp.store.rooms.get_avatar_legacy_id(self.pk)
 
     def _post_avatar_update(self) -> None:
-        if self.pk is None or self._avatar_pk is None:
+        if self.pk is None:
             return
+        assert self.pk is not None
         self.xmpp.store.rooms.set_avatar(self.pk, self._avatar_pk)
         self.__send_configuration_change((104,))
         self._send_room_presence()
@@ -527,6 +580,8 @@ class LegacyMUC(
                 p["vcard_temp_update"]["photo"] = ""
             p.send()
 
+    @timeit
+    @with_session
     async def join(self, join_presence: Presence):
         user_full_jid = join_presence.get_from()
         requested_nickname = join_presence.get_to().resource
@@ -548,17 +603,16 @@ class LegacyMUC(
             requested_nickname,
         )
 
-        await self.__fill_participants()
-
-        assert self.pk is not None
-        for db_participant in self.xmpp.store.participants.get_all(
-            self.pk, user_included=False
-        ):
-            participant = self.Participant.from_store(self.session, db_participant)
+        user_nick = self.user_nick
+        user_participant = None
+        async for participant in self.get_participants():
+            if participant.is_user:
+                user_participant = participant
+                continue
             participant.send_initial_presence(full_jid=user_full_jid)
 
-        user_nick = self.user_nick
-        user_participant = await self.get_user_participant()
+        if user_participant is None:
+            user_participant = await self.get_user_participant()
         if not user_participant.is_user:  # type:ignore
             self.log.warning("is_user flag not set participant on user_participant")
             user_participant.is_user = True  # type:ignore
@@ -589,7 +643,7 @@ class LegacyMUC(
                 maxstanzas=maxstanzas,
                 since=since,
             )
-        (await self.__get_subject_setter_participant()).set_room_subject(
+        self.__get_subject_setter_participant().set_room_subject(
             self._subject if self.HAS_SUBJECT else (self.description or self.name),
             user_full_jid,
             self.subject_date,
@@ -643,20 +697,21 @@ class LegacyMUC(
             construction (optional)
         :return:
         """
-        if fill_first:
-            await self.__fill_participants()
-        assert self.pk is not None
-        with self.xmpp.store.session():
-            stored = self.__participants_store.get_by_nickname(
-                self.pk, nickname
-            ) or self.__participants_store.get_by_resource(self.pk, nickname)
-            if stored is not None:
-                return self.Participant.from_store(self.session, stored)
+        if fill_first and not self._participants_filled:
+            async for _ in self.get_participants():
+                pass
+        if self.pk is not None:
+            with self.xmpp.store.session():
+                stored = self.__participants_store.get_by_nickname(
+                    self.pk, nickname
+                ) or self.__participants_store.get_by_resource(self.pk, nickname)
+                if stored is not None:
+                    return self.Participant.from_store(self.session, stored)
 
         if raise_if_not_found:
             raise XMPPError("item-not-found")
         p = self.Participant(self, nickname, **kwargs)
-        if store:
+        if store and not self._updating_info:
             self.__store_participant(p)
         if (
             not self.get_lock("fill participants")
@@ -694,29 +749,43 @@ class LegacyMUC(
         :return:
         """
         await self.session.contacts.ready
-        assert self.pk is not None
-        assert c.contact_pk is not None
-        with self.__store.session():
-            stored = self.__participants_store.get_by_contact(self.pk, c.contact_pk)
-            if stored is not None:
-                return self.Participant.from_store(
-                    self.session, stored, muc=self, contact=c
-                )
+
+        if self.pk is not None:
+            assert c.contact_pk is not None
+            with self.__store.session():
+                stored = self.__participants_store.get_by_contact(self.pk, c.contact_pk)
+                if stored is not None:
+                    return self.Participant.from_store(
+                        self.session, stored, muc=self, contact=c
+                    )
 
         nickname = c.name or _unescape_node(c.jid_username)
-        if not self.__store.nickname_is_available(self.pk, nickname):
+
+        if self.pk is None:
+            nick_available = True
+        else:
+            nick_available = self.__store.nickname_is_available(self.pk, nickname)
+
+        if not nick_available:
             self.log.debug("Nickname conflict")
             nickname = f"{nickname} ({c.jid_username})"
         p = self.Participant(self, nickname, **kwargs)
         p.contact = c
 
+        if self._updating_info:
+            return p
+
+        self.__store_participant(p)
         # FIXME: this is not great but given the current design,
         #        during participants fill and history backfill we do not
-        #        want to send presence, because we might update affiliation
+        #        want to send presence, because we might :update affiliation
         #        and role afterwards.
         # We need a refactor of the MUC class… later™
-        self.__store_participant(p)
-        if not self.get_lock("fill participants") and not self.get_lock("fill history"):
+        if (
+            self._participants_filled
+            and not self.get_lock("fill participants")
+            and not self.get_lock("fill history")
+        ):
             p.send_last_presence(force=True, no_cache_online=True)
         return p
 
@@ -729,21 +798,6 @@ class LegacyMUC(
             return await self.get_user_participant(**kwargs)
         return await self.get_participant_by_contact(c, **kwargs)
 
-    async def get_participants(self, fill_first=True):
-        """
-        Get all known participants of the group, ensure :meth:`.LegacyMUC.fill_participants`
-        has been awaited once before. Plugins should not use that, internal
-        slidge use only.
-        :return:
-        """
-        if fill_first:
-            await self.__fill_participants()
-        assert self.pk is not None
-        return [
-            self.Participant.from_store(self.session, s)
-            for s in self.__participants_store.get_all(self.pk)
-        ]
-
     def remove_participant(self, p: "LegacyParticipantType", kick=False, ban=False):
         """
         Call this when a participant leaves the room
@@ -1029,10 +1083,9 @@ class LegacyMUC(
     ):
         """
         Triggered when the user requests changing the affiliation of a contact
-        for this group,
+        for this group.
 
-        Examples: promotion them to moderator, kick (affiliation=none),
-        ban (affiliation=outcast).
+        Examples: promotion them to moderator, ban (affiliation=outcast).
 
         :param contact: The contact whose affiliation change is requested
         :param affiliation: The new affiliation
@@ -1041,6 +1094,16 @@ class LegacyMUC(
         """
         raise NotImplementedError
 
+    async def on_kick(self, contact: "LegacyContact", reason: Optional[str]):
+        """
+        Triggered when the user requests changing the role of a contact
+        to "none" for this group. Action commonly known as "kick".
+
+        :param contact: Contact to be kicked
+        :param reason: A reason for this kick
+        """
+        raise NotImplementedError
+
     async def on_set_config(
         self,
         name: Optional[str],
@@ -1127,6 +1190,7 @@ class LegacyMUC(
         )
         muc.pk = stored.id
         muc.type = stored.muc_type  # type: ignore
+        muc.user_nick = stored.user_nick
         if stored.name:
             muc.DISCO_NAME = stored.name
         if stored.description:
@@ -1137,17 +1201,11 @@ class LegacyMUC(
         if stored.subject_date is not None:
             muc._subject_date = stored.subject_date.replace(tzinfo=timezone.utc)
         muc._participants_filled = stored.participants_filled
-        muc.__history_filled = True
+        muc._n_participants = stored.n_participants
+        muc._history_filled = stored.history_filled
         if stored.user_resources is not None:
             muc._user_resources = set(json.loads(stored.user_resources))
-        if stored.subject_setter is not None:
-            muc.subject_setter = (
-                LegacyParticipant.get_self_or_unique_subclass().from_store(
-                    session,
-                    stored.subject_setter,
-                    muc=muc,
-                )
-            )
+        muc._subject_setter = stored.subject_setter
         muc.archive = MessageArchive(muc.pk, session.xmpp.store.mam)
         muc._set_avatar_from_store(stored)
         return muc

slidge/main.py

@@ -17,6 +17,7 @@ import asyncio
 import importlib
 import logging
 import os
+import re
 import signal
 from pathlib import Path
 
@@ -49,7 +50,7 @@ class MainConfig(ConfigModule):
             args.home_dir = Path("/var/lib/slidge") / str(args.jid)
 
         if args.user_jid_validator is None:
-            args.user_jid_validator = ".*@" + args.server
+            args.user_jid_validator = ".*@" + re.escape(args.server)
 
         if args.db_url is None:
             args.db_url = f"sqlite:///{args.home_dir}/slidge.sqlite"
@@ -116,8 +117,6 @@ def configure():
     db_file = config.HOME_DIR / "slidge.db"
     user_store.set_file(db_file, args.secret_key)
 
-    avatar_cache.set_dir(h / "slidge_avatars_v3")
-
     config.UPLOAD_REQUESTER = config.UPLOAD_REQUESTER or config.JID.bare
 
     return unknown_argv
@@ -161,6 +160,7 @@ def main():
     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

slidge/slixfix/xep_0292/vcard4.py

@@ -57,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)
         )