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

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

@@ -8,7 +8,7 @@ import re
 import tempfile
 from copy import copy
 from datetime import datetime
-from typing import TYPE_CHECKING, Callable, Collection, Optional, Sequence, Union
+from typing import TYPE_CHECKING, Any, Callable, Mapping, Optional, Sequence, Union
 
 import aiohttp
 import qrcode
@@ -18,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 ...slixfix.roster import RosterBackend
-from ...slixfix.xep_0292.vcard4 import VCard4Provider
-from ...util import ABCSubclassableOnceAtMost
-from ...util.db import GatewayUser, user_store
-from ...util.sql import db
-from ...util.types import AvatarType, MessageOrPresenceTypeVar
-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,
@@ -109,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),
     ]
@@ -141,6 +131,23 @@ class BaseGateway(
     )
     REGISTRATION_QR_INSTRUCTIONS = "Flash this code or follow this link"
 
+    PREFERENCES = [
+        FormField(
+            var="sync_presence",
+            label="Propagate your XMPP presence to the legacy network.",
+            value="true",
+            required=True,
+            type="boolean",
+        ),
+        FormField(
+            var="sync_avatar",
+            label="Propagate your XMPP avatar to the legacy network.",
+            value="true",
+            required=True,
+            type="boolean",
+        ),
+    ]
+
     ROSTER_GROUP: str = "slidge"
     """
     Name of the group assigned to a :class:`.LegacyContact` automagically
@@ -202,8 +209,52 @@ class BaseGateway(
     mtype: MessageTypes = "chat"
     is_group = False
     _can_send_carbon = False
+    store: SlidgeStore
+    avatar_pk: int
+
+    AVATAR_ID_TYPE: Callable[[str], Any] = str
+    """
+    Modify this if the legacy network uses unique avatar IDs that are not strings.
+
+    This is required because we store those IDs as TEXT in the persistent SQL DB.
+    The callable specified here will receive is responsible for converting the
+    serialised-as-text version of the avatar unique ID back to the proper type.
+    Common example: ``int``.
+    """
+    # FIXME: do we really need this since we have session.xmpp_to_legacy_msg_id?
+    #        (maybe we do)
+    LEGACY_MSG_ID_TYPE: Callable[[str], Any] = str
+    """
+    Modify this if the legacy network uses unique message IDs that are not strings.
+
+    This is required because we store those IDs as TEXT in the persistent SQL DB.
+    The callable specified here will receive is responsible for converting the
+    serialised-as-text version of the message unique ID back to the proper type.
+    Common example: ``int``.
+    """
+    LEGACY_CONTACT_ID_TYPE: Callable[[str], Any] = str
+    """
+    Modify this if the legacy network uses unique contact IDs that are not strings.
+
+    This is required because we store those IDs as TEXT in the persistent SQL DB.
+    The callable specified here is responsible for converting the
+    serialised-as-text version of the contact unique ID back to the proper type.
+    Common example: ``int``.
+    """
+    LEGACY_ROOM_ID_TYPE: Callable[[str], Any] = str
+    """
+    Modify this if the legacy network uses unique room IDs that are not strings.
+
+    This is required because we store those IDs as TEXT in the persistent SQL DB.
+    The callable specified here is responsible for converting the
+    serialised-as-text version of the room unique ID back to the proper type.
+    Common example: ``int``.
+    """
+
+    http: aiohttp.ClientSession
 
     def __init__(self):
+        self.log = log
         self.datetime_started = datetime.now()
         self.xmpp = self  # ugly hack to work with the BaseSender mixin :/
         self.default_ns = "jabber:component:accept"
@@ -222,7 +273,6 @@ class BaseGateway(
                 },
                 "xep_0100": {
                     "component_name": self.COMPONENT_NAME,
-                    "user_store": user_store,
                     "type": self.COMPONENT_TYPE,
                 },
                 "xep_0184": {
@@ -236,16 +286,20 @@ class BaseGateway(
             fix_error_ns=True,
         )
         self.loop.set_exception_handler(self.__exception_handler)
-        self.http: aiohttp.ClientSession = aiohttp.ClientSession()
+        self.loop.create_task(self.__set_http())
         self.has_crashed: bool = False
         self.use_origin_id = False
 
         self.jid_validator: re.Pattern = re.compile(config.USER_JID_VALIDATOR)
-        self.qr_pending_registrations = dict[str, asyncio.Future[bool]]()
+        self.qr_pending_registrations = dict[str, asyncio.Future[Optional[dict]]]()
 
         self.session_cls: BaseSession = BaseSession.get_unique_subclass()
         self.session_cls.xmpp = self
 
+        from ..group.room import LegacyMUC
+
+        LegacyMUC.get_self_or_unique_subclass().xmpp = self
+
         self.get_session_from_stanza: Callable[
             [Union[Message, Presence, Iq]], BaseSession
         ] = self.session_cls.from_stanza  # type: ignore
@@ -255,16 +309,18 @@ class BaseGateway(
 
         self.register_plugins()
         self.__register_slixmpp_events()
-        self.roster.set_backend(RosterBackend)
+        self.__register_slixmpp_api()
+        self.roster.set_backend(RosterBackend(self))
 
         self.register_plugin("pubsub", {"component_name": self.COMPONENT_NAME})
         self.pubsub: PubSubComponent = self["pubsub"]
-        self.vcard: VCard4Provider = self["xep_0292_provider"]
         self.delivery_receipt: DeliveryReceipt = DeliveryReceipt(self)
 
         # with this we receive user avatar updates
         self.plugin["xep_0030"].add_feature("urn:xmpp:avatar:metadata+notify")
 
+        self.plugin["xep_0030"].add_feature("urn:xmpp:chat-markers:0")
+
         if self.GROUPS:
             self.plugin["xep_0030"].add_feature("http://jabber.org/protocol/muc")
             self.plugin["xep_0030"].add_feature("urn:xmpp:mam:2")
@@ -281,20 +337,18 @@ 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()
 
-        db.mam_launch_cleanup_task(self.loop)
+        MessageMixin.__init__(self)  # ComponentXMPP does not call super().__init__()
+
+    async def __set_http(self):
+        self.http = aiohttp.ClientSession()
+        if getattr(self, "_test_mode", False):
+            return
+        avatar_cache.http = self.http
 
     def __register_commands(self):
         for cls in Command.subclasses:
@@ -303,7 +357,7 @@ class BaseGateway(
                 continue
             if cls is Exec:
                 if config.DEV_MODE:
-                    log.warning("/!\ DEV MODE ENABLED /!\\")
+                    log.warning(r"/!\ DEV MODE ENABLED /!\\")
                 else:
                     continue
             c = cls(self)
@@ -322,7 +376,7 @@ class BaseGateway(
         log.debug("Context in the exception handler: %s", context)
         exc = context.get("exception")
         if exc is None:
-            log.warning("No exception in this context: %s", context)
+            log.debug("No exception in this context: %s", context)
         elif isinstance(exc, SystemExit):
             log.debug("SystemExit called in an asyncio task")
         else:
@@ -332,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.user_resources.remove(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)
 
@@ -374,11 +415,13 @@ class BaseGateway(
         await disco.del_feature(feature="urn:xmpp:http:upload:0", jid=self.boundjid)
         await self.plugin["xep_0115"].update_caps(jid=self.boundjid)
 
-        await self.pubsub.set_avatar(
-            jid=self.boundjid.bare, avatar=self.COMPONENT_AVATAR
-        )
+        if self.COMPONENT_AVATAR is not None:
+            cached_avatar = await avatar_cache.convert_or_get(self.COMPONENT_AVATAR)
+            self.avatar_pk = cached_avatar.pk
+        else:
+            cached_avatar = None
 
-        for user in user_store.get_all():
+        for user in self.store.users.get_all():
             # TODO: before this, we should check if the user has removed us from their roster
             #       while we were offline and trigger unregister from there. Presence probe does not seem
             #       to work in this case, there must be another way. privileged entity could be used
@@ -396,10 +439,14 @@ class BaseGateway(
                 )
                 continue
             self.send_presence(
-                pto=user.bare_jid, ptype="probe"
+                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
+                )
 
         log.info("Slidge has successfully started")
 
@@ -455,12 +502,13 @@ class BaseGateway(
                 exc_info=e,
             )
 
-    async def __login_wrap(self, session: "BaseSession"):
+    @timeit
+    async def login_wrap(self, session: "BaseSession"):
         session.send_gateway_status("Logging in…", show="dnd")
         try:
             status = await session.login()
         except Exception as e:
-            log.warning("Login problem for %s", session.user, exc_info=e)
+            log.warning("Login problem for %s", session.user_jid, exc_info=e)
             log.exception(e)
             session.send_gateway_status(f"Could not login: {e}", show="busy")
             session.send_gateway_message(
@@ -469,10 +517,10 @@ class BaseGateway(
             )
             return
 
-        log.info("Login success for %s", session.user)
+        log.info("Login success for %s", session.user_jid)
         session.logged = True
         session.send_gateway_status("Syncing contacts…", show="dnd")
-        await session.contacts.fill()
+        await session.contacts._fill()
         if not (r := session.contacts.ready).done():
             r.set_result(True)
         if self.GROUPS:
@@ -483,24 +531,25 @@ class BaseGateway(
         for c in session.contacts:
             # we need to receive presences directed at the contacts, in
             # order to send pubsub events for their +notify features
-            self.send_presence(pfrom=c.jid, pto=session.user.bare_jid, ptype="probe")
+            self.send_presence(pfrom=c.jid, pto=session.user_jid.bare, ptype="probe")
         if status is None:
             session.send_gateway_status("Logged in", show="chat")
         else:
             session.send_gateway_status(status, show="chat")
-        # If we stored users avatars (or their hash) persistently across slidge
-        # restarts, we would not need to fetch it on startup
-        session.create_task(self.__fetch_user_avatar(session))
+        if session.user.preferences.get("sync_avatar", False):
+            session.create_task(self.fetch_user_avatar(session))
+        else:
+            self.xmpp.store.users.set_avatar_hash(session.user_pk, None)
 
-    async def __fetch_user_avatar(self, session: BaseSession):
+    async def fetch_user_avatar(self, session: BaseSession):
         try:
             iq = await self.xmpp.plugin["xep_0060"].get_items(
-                session.user.bare_jid,
+                session.user_jid.bare,
                 self.xmpp.plugin["xep_0084"].stanza.MetaData.namespace,
                 ifrom=self.boundjid.bare,
             )
-        except IqError as e:
-            session.log.debug("Failed to retrieve avatar: %r", e)
+        except IqError:
+            self.xmpp.store.users.set_avatar_hash(session.user_pk, None)
             return
         await self.__dispatcher.on_avatar_metadata_info(
             session, iq["pubsub"]["items"]["item"]["avatar_metadata"]["info"]
@@ -515,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(
@@ -568,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 = user_store.get_by_jid(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.
@@ -622,14 +636,14 @@ 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())
 
     async def make_registration_form(self, _jid, _node, _ifrom, iq: Iq):
         self.raise_if_not_allowed_jid(iq.get_from())
         reg = iq["register"]
-        user = user_store.get_by_stanza(iq)
+        user = self.store.users.get_by_stanza(iq)
         log.debug("User found: %s", user)
 
         form = reg["form"]
@@ -675,18 +689,20 @@ class BaseGateway(
         reply.set_payload(reg)
         return reply
 
-    async def user_prevalidate(self, ifrom: JID, form_dict: dict[str, Optional[str]]):
+    async def user_prevalidate(
+        self, ifrom: JID, form_dict: dict[str, Optional[str]]
+    ) -> Optional[Mapping]:
         # Pre validate a registration form using the content of self.REGISTRATION_FIELDS
         # before passing it to the plugin custom validation logic.
         for field in self.REGISTRATION_FIELDS:
             if field.required and not form_dict.get(field.var):
                 raise ValueError(f"Missing field: '{field.label}'")
 
-        await self.validate(ifrom, form_dict)
+        return await self.validate(ifrom, form_dict)
 
     async def validate(
         self, user_jid: JID, registration_form: dict[str, Optional[str]]
-    ):
+    ) -> Optional[Mapping]:
         """
         Validate a user's initial registration form.
 
@@ -706,11 +722,19 @@ class BaseGateway(
 
         :param user_jid: JID of the user that has just registered
         :param registration_form: A dict where keys are the :attr:`.FormField.var` attributes
-         of the :attr:`.BaseGateway.REGISTRATION_FIELDS` iterable
+            of the :attr:`.BaseGateway.REGISTRATION_FIELDS` iterable.
+            This dict can be modified and will be accessible as the ``legacy_module_data``
+            of the
+
+        :return : A dict that will be stored as the persistent "legacy_module_data"
+            for this user. If you don't return anything here, the whole registration_form
+            content will be stored.
         """
         raise NotImplementedError
 
-    async def validate_two_factor_code(self, user: GatewayUser, code: str):
+    async def validate_two_factor_code(
+        self, user: GatewayUser, code: str
+    ) -> Optional[dict]:
         """
         Called when the user enters their 2FA code.
 
@@ -725,6 +749,9 @@ class BaseGateway(
             :attr:`.registration_form` attributes to get what you need.
         :param code: The code they entered, either via "chatbot" message or
             adhoc command
+
+        :return : A dict which keys and values will be added to the persistent "legacy_module_data"
+            for this user.
         """
         raise NotImplementedError
 
@@ -744,7 +771,10 @@ class BaseGateway(
         raise NotImplementedError
 
     async def confirm_qr(
-        self, user_bare_jid: str, exception: Optional[Exception] = None
+        self,
+        user_bare_jid: str,
+        exception: Optional[Exception] = None,
+        legacy_data: Optional[dict] = None,
     ):
         """
         This method is meant to be called to finalize QR code-based registration
@@ -757,10 +787,12 @@ class BaseGateway(
             :class:`GatewayUser` instance
         :param exception: Optionally, an XMPPError to be raised to **not** confirm
             QR code flashing.
+        :param legacy_data: dict which keys and values will be added to the persistent
+            "legacy_module_data" for this user.
         """
         fut = self.qr_pending_registrations[user_bare_jid]
         if exception is None:
-            fut.set_result(True)
+            fut.set_result(legacy_data)
         else:
             fut.set_exception(exception)
 
@@ -771,14 +803,17 @@ class BaseGateway(
     async def unregister(self, user: GatewayUser):
         """
         Optionally override this if you need to clean additional
-        stuff after a user has been removed from the permanent user_store.
+        stuff after a user has been removed from the persistent user store.
 
         By default, this just calls :meth:`BaseSession.logout`.
 
         :param user:
         """
         session = self.get_session_from_user(user)
-        await session.logout()
+        try:
+            await session.logout()
+        except NotImplementedError:
+            pass
 
     async def input(
         self, jid: JID, text=None, mtype: MessageTypes = "chat", **msg_kwargs
@@ -825,26 +860,12 @@ class BaseGateway(
         # """
         log.debug("Shutting down")
         tasks = []
-        for user in user_store.get_all():
+        for user in self.store.users.get_all():
             tasks.append(self.session_cls.from_jid(user.jid).shutdown())
             self.send_presence(ptype="unavailable", pto=user.jid)
         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
@@ -854,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
@@ -866,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/__init__.py

@@ -2,6 +2,8 @@
 Mixins
 """
 
+from typing import Optional
+
 from .avatar import AvatarMixin
 from .disco import ChatterDiscoMixin
 from .message import MessageCarbonMixin, MessageMixin
@@ -16,4 +18,12 @@ class FullCarbonMixin(ChatterDiscoMixin, MessageCarbonMixin, PresenceMixin):
     pass
 
 
-__all__ = ("AvatarMixin",)
+class StoredAttributeMixin:
+    def serialize_extra_attributes(self) -> Optional[dict]:
+        return None
+
+    def deserialize_extra_attributes(self, data: dict) -> None:
+        pass
+
+
+__all__ = ("AvatarMixin", "FullCarbonMixin", "StoredAttributeMixin")