slidge 0.2.0a9__py3-none-any.whl → 0.2.0b0__py3-none-any.whl

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)
 
@@ -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:

slidge/core/{gateway/base.py → gateway.py}

@@ -8,16 +8,7 @@ import re
 import tempfile
 from copy import copy
 from datetime import datetime
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Callable,
-    Collection,
-    Mapping,
-    Optional,
-    Sequence,
-    Union,
-)
+from typing import TYPE_CHECKING, Any, Callable, Mapping, Optional, Sequence, Union
 
 import aiohttp
 import qrcode
@@ -27,40 +18,30 @@ from slixmpp.plugins.xep_0060.stanza import OwnerAffiliation
 from slixmpp.types import MessageTypes
 from slixmpp.xmlstream.xmlstream import NotConnectedError
 
-from ... import command  # noqa: F401
-from ...command.adhoc import AdhocProvider
-from ...command.admin import Exec
-from ...command.base import Command, FormField
-from ...command.chat_command import ChatCommandProvider
-from ...command.register import RegistrationType
-from ...db import GatewayUser, SlidgeStore
-from ...db.avatar import avatar_cache
-from ...slixfix.roster import RosterBackend
-from ...util import ABCSubclassableOnceAtMost
-from ...util.types import AvatarType, MessageOrPresenceTypeVar
-from ...util.util import timeit
-from .. import config
-from ..mixins import MessageMixin
-from ..pubsub import PubSubComponent
-from ..session import BaseSession
-from .caps import Caps
-from .delivery_receipt import DeliveryReceipt
-from .disco import Disco
-from .mam import Mam
-from .muc_admin import MucAdmin
-from .ping import Ping
-from .presence import PresenceHandlerMixin
-from .registration import Registration
-from .search import Search
-from .session_dispatcher import SessionDispatcher
-from .vcard_temp import VCardTemp
+from slidge import command  # noqa: F401
+from slidge.command.adhoc import AdhocProvider
+from slidge.command.admin import Exec
+from slidge.command.base import Command, FormField
+from slidge.command.chat_command import ChatCommandProvider
+from slidge.command.register import RegistrationType
+from slidge.core import config
+from slidge.core.dispatcher.session_dispatcher import SessionDispatcher
+from slidge.core.mixins import MessageMixin
+from slidge.core.pubsub import PubSubComponent
+from slidge.core.session import BaseSession
+from slidge.db import GatewayUser, SlidgeStore
+from slidge.db.avatar import avatar_cache
+from slidge.slixfix.delivery_receipt import DeliveryReceipt
+from slidge.slixfix.roster import RosterBackend
+from slidge.util import ABCSubclassableOnceAtMost
+from slidge.util.types import AvatarType, MessageOrPresenceTypeVar
+from slidge.util.util import timeit
 
 if TYPE_CHECKING:
-    from ...group.room import LegacyMUC
+    pass
 
 
 class BaseGateway(
-    PresenceHandlerMixin,
     ComponentXMPP,
     MessageMixin,
     metaclass=ABCSubclassableOnceAtMost,
@@ -118,7 +99,7 @@ class BaseGateway(
     Path, bytes or URL used by the component as an avatar.
     """
 
-    REGISTRATION_FIELDS: Collection[FormField] = [
+    REGISTRATION_FIELDS: Sequence[FormField] = [
         FormField(var="username", label="User name", required=True),
         FormField(var="password", label="Password", required=True, private=True),
     ]
@@ -315,7 +296,7 @@ class BaseGateway(
         self.session_cls: BaseSession = BaseSession.get_unique_subclass()
         self.session_cls.xmpp = self
 
-        from ...group.room import LegacyMUC
+        from ..group.room import LegacyMUC
 
         LegacyMUC.get_self_or_unique_subclass().xmpp = self
 
@@ -328,6 +309,7 @@ class BaseGateway(
 
         self.register_plugins()
         self.__register_slixmpp_events()
+        self.__register_slixmpp_api()
         self.roster.set_backend(RosterBackend(self))
 
         self.register_plugin("pubsub", {"component_name": self.COMPONENT_NAME})
@@ -355,21 +337,11 @@ class BaseGateway(
         # why does mypy need these type annotations? no idea
         self.__adhoc_handler: AdhocProvider = AdhocProvider(self)
         self.__chat_commands_handler: ChatCommandProvider = ChatCommandProvider(self)
-        self.__disco_handler = Disco(self)
-
-        self.__ping_handler = Ping(self)
-        self.__mam_handler = Mam(self)
-        self.__search_handler = Search(self)
-        self.__caps_handler = Caps(self)
-        self.__vcard_temp_handler = VCardTemp(self)
-        self.__muc_admin_handler = MucAdmin(self)
-        self.__registration = Registration(self)
+
         self.__dispatcher = SessionDispatcher(self)
 
         self.__register_commands()
 
-        self.__mam_cleanup_task = self.loop.create_task(self.__mam_cleanup())
-
         MessageMixin.__init__(self)  # ComponentXMPP does not call super().__init__()
 
     async def __set_http(self):
@@ -378,13 +350,6 @@ class BaseGateway(
             return
         avatar_cache.http = self.http
 
-    async def __mam_cleanup(self):
-        if not config.MAM_MAX_DAYS:
-            return
-        while True:
-            await asyncio.sleep(3600 * 6)
-            self.store.mam.nuke_older_than(config.MAM_MAX_DAYS)
-
     def __register_commands(self):
         for cls in Command.subclasses:
             if any(x is NotImplemented for x in [cls.CHAT_COMMAND, cls.NODE, cls.NAME]):
@@ -421,40 +386,27 @@ class BaseGateway(
             loop.stop()
 
     def __register_slixmpp_events(self):
+        self.del_event_handler("presence_subscribe", self._handle_subscribe)
+        self.del_event_handler("presence_unsubscribe", self._handle_unsubscribe)
+        self.del_event_handler("presence_subscribed", self._handle_subscribed)
+        self.del_event_handler("presence_unsubscribed", self._handle_unsubscribed)
+        self.del_event_handler(
+            "roster_subscription_request", self._handle_new_subscription
+        )
+        self.del_event_handler("presence_probe", self._handle_probe)
         self.add_event_handler("session_start", self.__on_session_start)
         self.add_event_handler("disconnected", self.connect)
-        self.add_event_handler("user_register", self._on_user_register)
-        self.add_event_handler("user_unregister", self._on_user_unregister)
-        self.add_event_handler("groupchat_message_error", self.__on_group_chat_error)
+
+    def __register_slixmpp_api(self) -> None:
+        self.plugin["xep_0231"].api.register(self.store.bob.get_bob, "get_bob")
+        self.plugin["xep_0231"].api.register(self.store.bob.set_bob, "set_bob")
+        self.plugin["xep_0231"].api.register(self.store.bob.del_bob, "del_bob")
 
     @property  # type: ignore
     def jid(self):
         # Override to avoid slixmpp deprecation warnings.
         return self.boundjid
 
-    async def __on_group_chat_error(self, msg: Message):
-        condition = msg["error"].get_condition()
-        if condition not in KICKABLE_ERRORS:
-            return
-
-        try:
-            muc = await self.get_muc_from_stanza(msg)
-        except XMPPError as e:
-            log.debug("Not removing resource", exc_info=e)
-            return
-        mfrom = msg.get_from()
-        resource = mfrom.resource
-        try:
-            muc.remove_user_resource(resource)
-        except KeyError:
-            # this actually happens quite frequently on for both beagle and monal
-            # (not sure why?), but is of no consequence
-            log.debug("%s was not in the resources of %s", resource, muc)
-        else:
-            log.info(
-                "Removed %s from the resources of %s because of error", resource, muc
-            )
-
     async def __on_session_start(self, event):
         log.debug("Gateway session start: %s", event)
 
@@ -490,7 +442,7 @@ class BaseGateway(
                 pto=user.jid.bare, ptype="probe"
             )  # ensure we get all resources for user
             session = self.session_cls.from_user(user)
-            session.create_task(self.__login_wrap(session))
+            session.create_task(self.login_wrap(session))
             if cached_avatar is not None:
                 await self.pubsub.broadcast_avatar(
                     self.boundjid.bare, session.user_jid, cached_avatar
@@ -551,7 +503,7 @@ class BaseGateway(
             )
 
     @timeit
-    async def __login_wrap(self, session: "BaseSession"):
+    async def login_wrap(self, session: "BaseSession"):
         session.send_gateway_status("Logging in…", show="dnd")
         try:
             status = await session.login()
@@ -612,21 +564,6 @@ class BaseGateway(
         stanza.send()
         return stanza
 
-    async def _on_user_register(self, iq: Iq):
-        session = self.get_session_from_stanza(iq)
-        for jid in config.ADMINS:
-            self.send_message(
-                mto=jid,
-                mbody=f"{iq.get_from()} has registered",
-                mtype="chat",
-                mfrom=self.boundjid.bare,
-            )
-        session.send_gateway_message(self.WELCOME_MESSAGE)
-        await self.__login_wrap(session)
-
-    async def _on_user_unregister(self, iq: Iq):
-        await self.session_cls.kill_by_jid(iq.get_from())
-
     def raise_if_not_allowed_jid(self, jid: JID):
         if not self.jid_validator.match(jid.bare):
             raise XMPPError(
@@ -665,26 +602,6 @@ class BaseGateway(
         except XMPPError:
             pass
 
-    async def get_muc_from_stanza(self, iq: Union[Iq, Message]) -> "LegacyMUC":
-        ito = iq.get_to()
-
-        if ito == self.boundjid.bare:
-            raise XMPPError(
-                text="No MAM on the component itself, use a JID with a resource"
-            )
-
-        ifrom = iq.get_from()
-        user = self.store.users.get(ifrom)
-        if user is None:
-            raise XMPPError("registration-required")
-
-        session = self.get_session_from_user(user)
-        session.raise_if_not_logged()
-
-        muc = await session.bookmarks.by_jid(ito)
-
-        return muc
-
     def exception(self, exception: Exception):
         # """
         # Called when a task created by slixmpp's internal (eg, on slix events) raises an Exception.
@@ -719,7 +636,7 @@ class BaseGateway(
         async def w():
             session.cancel_all_tasks()
             await session.logout()
-            await self.__login_wrap(session)
+            await self.login_wrap(session)
 
         session.create_task(w())
 
@@ -949,20 +866,6 @@ class BaseGateway(
         return tasks
 
 
-KICKABLE_ERRORS = {
-    "gone",
-    "internal-server-error",
-    "item-not-found",
-    "jid-malformed",
-    "recipient-unavailable",
-    "redirect",
-    "remote-server-not-found",
-    "remote-server-timeout",
-    "service-unavailable",
-    "malformed error",
-}
-
-
 SLIXMPP_PLUGINS = [
     "link_preview",  # https://wiki.soprani.ca/CheogramApp/LinkPreviews
     "xep_0030",  # Service discovery
@@ -972,6 +875,7 @@ SLIXMPP_PLUGINS = [
     "xep_0055",  # Jabber search
     "xep_0059",  # Result Set Management
     "xep_0066",  # Out of Band Data
+    "xep_0071",  # XHTML-IM (for stickers and custom emojis maybe later)
     "xep_0077",  # In-band registration
     "xep_0084",  # User Avatar
     "xep_0085",  # Chat state notifications
@@ -984,6 +888,7 @@ SLIXMPP_PLUGINS = [
     "xep_0184",  # Message Delivery Receipts
     "xep_0199",  # XMPP Ping
     "xep_0221",  # Data Forms Media Element
+    "xep_0231",  # Bits of Binary (for stickers and custom emojis maybe later)
     "xep_0249",  # Direct MUC Invitations
     "xep_0264",  # Jingle Content Thumbnails
     "xep_0280",  # Carbons

slidge/core/mixins/attachment.py

@@ -33,17 +33,14 @@ from ...util.types import (
 )
 from ...util.util import fix_suffix
 from .. import config
-from .message_maker import MessageMaker
+from .message_text import TextMessageMixin
 
 
-class AttachmentMixin(MessageMaker):
+class AttachmentMixin(TextMessageMixin):
     def __init__(self, *a, **kw):
         super().__init__(*a, **kw)
         self.__store = self.xmpp.store.attachments
 
-    def send_text(self, *_, **k) -> Optional[Message]:
-        raise NotImplementedError
-
     async def __upload(
         self,
         file_path: Path,
@@ -261,7 +258,7 @@ class AttachmentMixin(MessageMaker):
                 thumbnail["width"] = x
                 thumbnail["height"] = y
                 thumbnail["media-type"] = "image/thumbhash"
-                thumbnail["uri"] = "data:image/thumbhash," + urlquote(h)
+                thumbnail["uri"] = "data:image/thumbhash;base64," + urlquote(h)
 
         self.__store.set_sims(uploaded_url, str(ref))
 
@@ -304,6 +301,7 @@ class AttachmentMixin(MessageMaker):
         caption: Optional[str] = None,
         carbon=False,
         when: Optional[datetime] = None,
+        correction=False,
         **kwargs,
     ) -> list[Message]:
         msg["oob"]["url"] = uploaded_url
@@ -311,11 +309,19 @@ class AttachmentMixin(MessageMaker):
         if caption:
             m1 = self._send(msg, carbon=carbon, **kwargs)
             m2 = self.send_text(
-                caption, legacy_msg_id=legacy_msg_id, when=when, carbon=carbon, **kwargs
+                caption,
+                legacy_msg_id=legacy_msg_id,
+                when=when,
+                carbon=carbon,
+                correction=correction,
+                **kwargs,
             )
             return [m1, m2] if m2 else [m1]
         else:
-            self._set_msg_id(msg, legacy_msg_id)
+            if correction:
+                msg["replace"]["id"] = self._replace_id(legacy_msg_id)
+            else:
+                self._set_msg_id(msg, legacy_msg_id)
             return [self._send(msg, carbon=carbon, **kwargs)]
 
     async def send_file(
@@ -358,6 +364,16 @@ class AttachmentMixin(MessageMaker):
         carbon = kwargs.pop("carbon", False)
         mto = kwargs.pop("mto", None)
         store_multi = kwargs.pop("store_multi", True)
+        correction = kwargs.get("correction", False)
+        if correction and (original_xmpp_id := self._legacy_to_xmpp(legacy_msg_id)):
+            xmpp_ids = self.xmpp.store.multi.get_xmpp_ids(
+                self.session.user_pk, original_xmpp_id
+            )
+
+            for xmpp_id in xmpp_ids:
+                if xmpp_id == original_xmpp_id:
+                    continue
+                self.retract(xmpp_id, thread)
         msg = self._make_message(
             when=when,
             reply_to=reply_to,

slidge/core/mixins/base.py

@@ -6,8 +6,8 @@ from slixmpp import JID
 from ...util.types import MessageOrPresenceTypeVar
 
 if TYPE_CHECKING:
-    from slidge.core.gateway import BaseGateway
-    from slidge.core.session import BaseSession
+    from ..gateway import BaseGateway
+    from ..session import BaseSession
 
 
 class MetaBase(ABCMeta):

slidge/core/mixins/lock.py

@@ -15,14 +15,16 @@ class NamedLockMixin:
         locks = self.__locks
         if not locks.get(id_):
             locks[id_] = asyncio.Lock()
-        async with locks[id_]:
-            log.trace("acquired %s", id_)  # type:ignore
-            yield
-        log.trace("releasing %s", id_)  # type:ignore
-        waiters = locks[id_]._waiters  # type:ignore
-        if not waiters:
-            del locks[id_]
-            log.trace("erasing %s", id_)  # type:ignore
+        try:
+            async with locks[id_]:
+                log.trace("acquired %s", id_)  # type:ignore
+                yield
+        finally:
+            log.trace("releasing %s", id_)  # type:ignore
+            waiters = locks[id_]._waiters  # type:ignore
+            if not waiters:
+                del locks[id_]
+                log.trace("erasing %s", id_)  # type:ignore
 
     def get_lock(self, id_: Hashable):
         return self.__locks.get(id_)