slidge 0.1.2__py3-none-any.whl → 0.2.0__py3-none-any.whl

slidge/core/dispatcher/session_dispatcher.py

@@ -0,0 +1,84 @@
+import logging
+from typing import TYPE_CHECKING
+
+from slixmpp import Message
+from slixmpp.exceptions import IqError
+from slixmpp.plugins.xep_0084.stanza import Info
+
+from ..session import BaseSession
+from .caps import CapsMixin
+from .disco import DiscoMixin
+from .message import MessageMixin
+from .muc import MucMixin
+from .presence import PresenceHandlerMixin
+from .registration import RegistrationMixin
+from .search import SearchMixin
+from .util import exceptions_to_xmpp_errors
+from .vcard import VCardMixin
+
+if TYPE_CHECKING:
+    from slidge.core.gateway import BaseGateway
+
+
+class SessionDispatcher(
+    CapsMixin,
+    DiscoMixin,
+    RegistrationMixin,
+    MessageMixin,
+    MucMixin,
+    PresenceHandlerMixin,
+    SearchMixin,
+    VCardMixin,
+):
+    def __init__(self, xmpp: "BaseGateway"):
+        super().__init__(xmpp)
+        xmpp.add_event_handler(
+            "avatar_metadata_publish", self.on_avatar_metadata_publish
+        )
+
+    @exceptions_to_xmpp_errors
+    async def on_avatar_metadata_publish(self, m: Message):
+        session = await self._get_session(m, timeout=None)
+        if not session.user.preferences.get("sync_avatar", False):
+            session.log.debug("User does not want to sync their avatar")
+            return
+        info = m["pubsub_event"]["items"]["item"]["avatar_metadata"]["info"]
+
+        await self.on_avatar_metadata_info(session, info)
+
+    async def on_avatar_metadata_info(self, session: BaseSession, info: Info):
+        hash_ = info["id"]
+
+        if session.user.avatar_hash == hash_:
+            session.log.debug("We already know this avatar hash")
+            return
+        self.xmpp.store.users.set_avatar_hash(session.user_pk, None)
+
+        if hash_:
+            try:
+                iq = await self.xmpp.plugin["xep_0084"].retrieve_avatar(
+                    session.user_jid, hash_, ifrom=self.xmpp.boundjid.bare
+                )
+            except IqError as e:
+                session.log.warning("Could not fetch the user's avatar: %s", e)
+                return
+            bytes_ = iq["pubsub"]["items"]["item"]["avatar_data"]["value"]
+            type_ = info["type"]
+            height = info["height"]
+            width = info["width"]
+        else:
+            bytes_ = type_ = height = width = hash_ = None
+        try:
+            await session.on_avatar(bytes_, hash_, type_, width, height)
+        except NotImplementedError:
+            pass
+        except Exception as e:
+            # If something goes wrong here, replying an error stanza will to the
+            # avatar update will likely not show in most clients, so let's send
+            # a normal message from the component to the user.
+            session.send_gateway_message(
+                f"Something went wrong trying to set your avatar: {e!r}"
+            )
+
+
+log = logging.getLogger(__name__)

slidge/core/dispatcher/util.py

@@ -0,0 +1,174 @@
+import logging
+from functools import wraps
+from typing import TYPE_CHECKING, Any, Awaitable, Callable, TypeVar
+
+from slixmpp import JID, Iq, Message, Presence
+from slixmpp.exceptions import XMPPError
+from slixmpp.xmlstream import StanzaBase
+
+from ...util.types import Recipient, RecipientType
+from ..session import BaseSession
+
+if TYPE_CHECKING:
+    from slidge import BaseGateway
+    from slidge.group import LegacyMUC
+
+
+class Ignore(BaseException):
+    pass
+
+
+class DispatcherMixin:
+    def __init__(self, xmpp: "BaseGateway"):
+        self.xmpp = xmpp
+
+    async def _get_session(
+        self,
+        stanza: Message | Presence | Iq,
+        timeout: int | None = 10,
+        wait_for_ready=True,
+        logged=False,
+    ) -> BaseSession:
+        xmpp = self.xmpp
+        if stanza.get_from().server == xmpp.boundjid.bare:
+            log.debug("Ignoring echo")
+            raise Ignore
+        if (
+            isinstance(stanza, Message)
+            and stanza.get_type() == "chat"
+            and stanza.get_to() == xmpp.boundjid.bare
+        ):
+            log.debug("Ignoring message to component")
+            raise Ignore
+        session = await self._get_session_from_jid(
+            stanza.get_from(), timeout, wait_for_ready, logged
+        )
+        if isinstance(stanza, Message) and _ignore(session, stanza):
+            raise Ignore
+        return session
+
+    async def _get_session_from_jid(
+        self,
+        jid: JID,
+        timeout: int | None = 10,
+        wait_for_ready=True,
+        logged=False,
+    ) -> BaseSession:
+        session = self.xmpp.get_session_from_jid(jid)
+        if session is None:
+            raise XMPPError("registration-required")
+        if logged:
+            session.raise_if_not_logged()
+        if wait_for_ready:
+            await session.wait_for_ready(timeout)
+        return session
+
+    async def get_muc_from_stanza(self, iq: Iq | Message | Presence) -> "LegacyMUC":
+        ito = iq.get_to()
+        if ito == self.xmpp.boundjid.bare:
+            raise XMPPError("bad-request", text="This is only handled for MUCs")
+
+        session = await self._get_session(iq, logged=True)
+        muc = await session.bookmarks.by_jid(ito)
+        return muc
+
+    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:
+            return self.xmpp.LEGACY_MSG_ID_TYPE(sent)
+
+        multi = self.xmpp.store.multi.get_legacy_id(session.user_pk, xmpp_id)
+        if multi:
+            return self.xmpp.LEGACY_MSG_ID_TYPE(multi)
+
+        try:
+            return session.xmpp_to_legacy_msg_id(xmpp_id)
+        except XMPPError:
+            raise
+        except Exception as e:
+            log.debug("Couldn't convert xmpp msg ID to legacy ID.", exc_info=e)
+            raise XMPPError(
+                "internal-server-error", "Couldn't convert xmpp msg ID to legacy ID."
+            )
+
+    async def _get_session_entity_thread(
+        self, msg: Message
+    ) -> tuple["BaseSession", Recipient, int | str]:
+        session = await self._get_session(msg)
+        e: Recipient = await _get_entity(session, msg)
+        legacy_thread = await self._xmpp_to_legacy_thread(session, msg, e)
+        return session, e, legacy_thread
+
+    async def _xmpp_to_legacy_thread(
+        self, session: "BaseSession", msg: Message, recipient: RecipientType
+    ):
+        xmpp_thread = msg["thread"]
+        if not xmpp_thread:
+            return None
+
+        if session.MESSAGE_IDS_ARE_THREAD_IDS:
+            return self._xmpp_msg_id_to_legacy(session, xmpp_thread)
+
+        legacy_thread_str = session.xmpp.store.sent.get_legacy_thread(
+            session.user_pk, xmpp_thread
+        )
+        if legacy_thread_str is not None:
+            return session.xmpp.LEGACY_MSG_ID_TYPE(legacy_thread_str)
+        async with session.thread_creation_lock:
+            legacy_thread = await recipient.create_thread(xmpp_thread)
+            session.xmpp.store.sent.set_thread(
+                session.user_pk, str(legacy_thread), xmpp_thread
+            )
+            return legacy_thread
+
+
+def _ignore(session: "BaseSession", msg: Message):
+    i = msg.get_id()
+    if i.startswith("slidge-carbon-"):
+        return True
+    if i not in session.ignore_messages:
+        return False
+    session.log.debug("Ignored sent carbon: %s", i)
+    session.ignore_messages.remove(i)
+    return True
+
+
+async def _get_entity(session: "BaseSession", m: Message) -> RecipientType:
+    session.raise_if_not_logged()
+    if m.get_type() == "groupchat":
+        muc = await session.bookmarks.by_jid(m.get_to())
+        r = m.get_from().resource
+        if r not in muc.get_user_resources():
+            session.create_task(muc.kick_resource(r))
+            raise XMPPError("not-acceptable", "You are not connected to this chat")
+        return muc
+    else:
+        return await session.contacts.by_jid(m.get_to())
+
+
+StanzaType = TypeVar("StanzaType", bound=StanzaBase)
+HandlerType = Callable[[Any, StanzaType], Awaitable[None]]
+
+
+def exceptions_to_xmpp_errors(cb: HandlerType) -> HandlerType:
+    @wraps(cb)
+    async def wrapped(*args):
+        try:
+            await cb(*args)
+        except Ignore:
+            pass
+        except XMPPError:
+            raise
+        except NotImplementedError:
+            log.debug("NotImplementedError raised in %s", cb)
+            raise XMPPError(
+                "feature-not-implemented", "Not implemented by the legacy module"
+            )
+        except Exception as e:
+            log.error("Failed to handle incoming stanza: %s", args, exc_info=e)
+            raise XMPPError("internal-server-error", str(e))
+
+    return wrapped
+
+
+log = logging.getLogger(__name__)

slidge/core/{gateway/vcard_temp.py → dispatcher/vcard.py}

@@ -1,5 +1,4 @@
 from copy import copy
-from typing import TYPE_CHECKING
 
 from slixmpp import CoroutineCallback, Iq, StanzaPath, register_stanza_plugin
 from slixmpp.exceptions import XMPPError
@@ -9,21 +8,23 @@ from slixmpp.plugins.xep_0292.stanza import NS as VCard4NS
 from ...contact import LegacyContact
 from ...core.session import BaseSession
 from ...group import LegacyParticipant
+from .util import DispatcherMixin, exceptions_to_xmpp_errors
 
-if TYPE_CHECKING:
-    from .base import BaseGateway
 
-
-class VCardTemp:
-    def __init__(self, xmpp: "BaseGateway"):
-        self.xmpp = xmpp
-        # remove slixmpp's default handler to replace with our own
-        self.xmpp.remove_handler("VCardTemp")
+class VCardMixin(DispatcherMixin):
+    def __init__(self, xmpp):
+        super().__init__(xmpp)
+        xmpp.register_handler(
+            CoroutineCallback(
+                "get_vcard", StanzaPath("iq@type=get/vcard"), self.on_get_vcard
+            )
+        )
+        xmpp.remove_handler("VCardTemp")
         xmpp.register_handler(
             CoroutineCallback(
                 "VCardTemp",
                 StanzaPath("iq/vcard_temp"),
-                self.__handler,  # type:ignore
+                self.__vcard_temp_handler,
             )
         )
         # TODO: MR to slixmpp adding this to XEP-0084
@@ -32,7 +33,20 @@ class VCardTemp:
             MetaData,
         )
 
-    async def __handler(self, iq: Iq):
+    @exceptions_to_xmpp_errors
+    async def on_get_vcard(self, iq: Iq):
+        session = await self._get_session(iq, logged=True)
+        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()
+
+    @exceptions_to_xmpp_errors
+    async def __vcard_temp_handler(self, iq: Iq):
         if iq["type"] == "get":
             return await self.__handle_get_vcard_temp(iq)
 
@@ -40,11 +54,13 @@ class VCardTemp:
             return await self.__handle_set_vcard_temp(iq)
 
     async def __fetch_user_avatar(self, session: BaseSession):
-        hash_ = session.avatar_hash
+        hash_ = session.user.avatar_hash
         if not hash_:
-            raise XMPPError("item-not-found", "This participant has no contact")
+            raise XMPPError(
+                "item-not-found", "The slidge user does not have any avatar set"
+            )
         meta_iq = await self.xmpp.plugin["xep_0060"].get_item(
-            session.user.jid,
+            session.user_jid,
             MetaData.namespace,
             hash_,
             ifrom=self.xmpp.boundjid.bare,
@@ -52,14 +68,14 @@ class VCardTemp:
         info = meta_iq["pubsub"]["items"]["item"]["avatar_metadata"]["info"]
         type_ = info["type"]
         data_iq = await self.xmpp.plugin["xep_0084"].retrieve_avatar(
-            session.user.jid, hash_, ifrom=self.xmpp.boundjid.bare
+            session.user_jid, hash_, ifrom=self.xmpp.boundjid.bare
         )
         bytes_ = data_iq["pubsub"]["items"]["item"]["avatar_data"]["value"]
         return bytes_, type_
 
     async def __handle_get_vcard_temp(self, iq: Iq):
         session = self.xmpp.get_session_from_stanza(iq)
-        entity = await session.get_contact_or_group_or_participant(iq.get_to())
+        entity = await session.get_contact_or_group_or_participant(iq.get_to(), False)
         if not entity:
             raise XMPPError("item-not-found")
 
@@ -77,14 +93,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()
@@ -103,7 +119,7 @@ class VCardTemp:
         reply.send()
 
     async def __handle_set_vcard_temp(self, iq: Iq):
-        muc = await self.xmpp.get_muc_from_stanza(iq)
+        muc = await self.get_muc_from_stanza(iq)
         to = iq.get_to()
 
         if to.resource: