slidge 0.2.0a8__py3-none-any.whl → 0.2.0a10__py3-none-any.whl

slidge/core/{gateway → dispatcher}/registration.py

@@ -7,13 +7,16 @@ from slixmpp import JID, Iq
 from slixmpp.exceptions import XMPPError
 
 from ...db import GatewayUser
+from .. import config
+from .util import DispatcherMixin
 
 if TYPE_CHECKING:
-    from .base import BaseGateway
+    from slidge.core.gateway import BaseGateway
 
 
-class Registration:
+class RegistrationMixin(DispatcherMixin):
     def __init__(self, xmpp: "BaseGateway"):
+        super().__init__(xmpp)
         self.xmpp = xmpp
         xmpp["xep_0077"].api.register(
             self.xmpp.make_registration_form, "make_registration_form"
@@ -25,6 +28,9 @@ class Registration:
         # TODO: either fully use slixmpp internal API or rewrite registration without it at all
         xmpp["xep_0077"].api.register(lambda *a: None, "user_remove")
 
+        xmpp.add_event_handler("user_register", self._on_user_register)
+        xmpp.add_event_handler("user_unregister", self._on_user_unregister)
+
     def get_user(self, jid: JID) -> GatewayUser | None:
         return self.xmpp.store.users.get(jid)
 
@@ -60,5 +66,20 @@ class Registration:
         user.legacy_module_data.update(form_dict)
         self.xmpp.store.users.update(user)
 
+    async def _on_user_register(self, iq: Iq):
+        session = await self._get_session(iq, wait_for_ready=False)
+        for jid in config.ADMINS:
+            self.xmpp.send_message(
+                mto=jid,
+                mbody=f"{iq.get_from()} has registered",
+                mtype="chat",
+                mfrom=self.xmpp.boundjid.bare,
+            )
+        session.send_gateway_message(self.xmpp.WELCOME_MESSAGE)
+        await self.xmpp.login_wrap(session)
+
+    async def _on_user_unregister(self, iq: Iq):
+        await self.xmpp.session_cls.kill_by_jid(iq.get_from())
+
 
 log = logging.getLogger(__name__)

slidge/core/{gateway → dispatcher}/search.py

@@ -3,13 +3,15 @@ from typing import TYPE_CHECKING
 from slixmpp import JID, CoroutineCallback, Iq, StanzaPath
 from slixmpp.exceptions import XMPPError
 
+from .util import DispatcherMixin, exceptions_to_xmpp_errors
+
 if TYPE_CHECKING:
-    from .base import BaseGateway
+    from slidge.core.gateway import BaseGateway
 
 
-class Search:
+class SearchMixin(DispatcherMixin):
     def __init__(self, xmpp: "BaseGateway"):
-        self.xmpp = xmpp
+        super().__init__(xmpp)
 
         xmpp["xep_0055"].api.register(self.search_get_form, "search_get_form")
         xmpp["xep_0055"].api.register(self._search_query, "search_query")
@@ -45,13 +47,9 @@ class Search:
         """
         Handles a search request
         """
-        user = self.xmpp.store.users.get(ifrom)
-        if user is None:
-            raise XMPPError(text="Search is only allowed for registered users")
+        session = await self._get_session(iq)
 
-        result = await self.xmpp.get_session_from_stanza(iq).on_search(
-            iq["search"]["form"].get_values()
-        )
+        result = await session.on_search(iq["search"]["form"].get_values())
 
         if not result:
             raise XMPPError("item-not-found", text="Nothing was found")
@@ -64,19 +62,17 @@ class Search:
             form.add_item(item)
         return reply
 
+    @exceptions_to_xmpp_errors
     async def _handle_gateway_iq(self, iq: Iq):
         if iq.get_to() != self.xmpp.boundjid.bare:
             raise XMPPError("bad-request", "This can only be used on the component JID")
 
-        user = self.xmpp.store.users.get(iq.get_from())
-        if user is None:
-            raise XMPPError("not-authorized", "Register to the gateway first")
-
         if len(self.xmpp.SEARCH_FIELDS) > 1:
             raise XMPPError(
                 "feature-not-implemented", "Use jabber search for this gateway"
             )
 
+        session = await self._get_session(iq)
         field = self.xmpp.SEARCH_FIELDS[0]
 
         reply = iq.reply()
@@ -85,7 +81,6 @@ class Search:
             reply["gateway"]["prompt"] = field.label
         elif iq["type"] == "set":
             prompt = iq["gateway"]["prompt"]
-            session = self.xmpp.session_cls.from_user(user)
             result = await session.on_search({field.var: prompt})
             if result is None or not result.items:
                 raise XMPPError(

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 _xmpp_to_legacy_thread(session, msg, e)
+        return session, e, 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 _xmpp_to_legacy_thread(
+    session: "BaseSession", msg: Message, recipient: RecipientType
+):
+    xmpp_thread = msg["thread"]
+    if not xmpp_thread:
+        return
+
+    if session.MESSAGE_IDS_ARE_THREAD_IDS:
+        return session.xmpp.store.sent.get_legacy_thread(session.user_pk, xmpp_thread)
+
+    async with session.thread_creation_lock:
+        legacy_thread_str = session.xmpp.store.sent.get_legacy_thread(
+            session.user_pk, xmpp_thread
+        )
+        if legacy_thread_str is None:
+            legacy_thread = str(await recipient.create_thread(xmpp_thread))
+            session.xmpp.store.sent.set_thread(
+                session.user_pk, xmpp_thread, legacy_thread
+            )
+    return session.xmpp.LEGACY_MSG_ID_TYPE(legacy_thread)
+
+
+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)
 
@@ -105,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: