slidge 0.2.12__py3-none-any.whl → 0.3.0a0__py3-none-any.whl

slidge/core/gateway.py

@@ -8,17 +8,19 @@ import re
 import tempfile
 from copy import copy
 from datetime import datetime
-from typing import TYPE_CHECKING, Any, Callable, Mapping, Optional, Sequence, Union
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Callable, Optional, Sequence, Type, Union, cast
 
 import aiohttp
 import qrcode
 from slixmpp import JID, ComponentXMPP, Iq, Message, Presence
 from slixmpp.exceptions import IqError, IqTimeout, XMPPError
+from slixmpp.plugins.xep_0004 import Form
 from slixmpp.plugins.xep_0060.stanza import OwnerAffiliation
 from slixmpp.types import MessageTypes
 from slixmpp.xmlstream.xmlstream import NotConnectedError
 
-from slidge import command  # noqa: F401
+from slidge import LegacyContact, command  # noqa: F401
 from slidge.command.adhoc import AdhocProvider
 from slidge.command.admin import Exec
 from slidge.command.base import Command, FormField
@@ -27,15 +29,17 @@ 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.mixins.avatar import convert_avatar
 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.db.avatar import CachedAvatar, avatar_cache
+from slidge.db.meta import JSONSerializable
 from slidge.slixfix import PrivilegedIqError
 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.types import Avatar, MessageOrPresenceTypeVar
 from slidge.util.util import timeit
 
 if TYPE_CHECKING:
@@ -95,7 +99,7 @@ class BaseGateway(
     """Name of the component, as seen in service discovery by XMPP clients"""
     COMPONENT_TYPE: str = ""
     """Type of the gateway, should follow https://xmpp.org/registrar/disco-categories.html"""
-    COMPONENT_AVATAR: Optional[AvatarType] = None
+    COMPONENT_AVATAR: Optional[Avatar | Path | str] = None
     """
     Path, bytes or URL used by the component as an avatar.
     """
@@ -147,6 +151,27 @@ class BaseGateway(
             required=True,
             type="boolean",
         ),
+        FormField(
+            var="always_invite_when_adding_bookmarks",
+            label="Send an invitation to join MUCs after adding them to the bookmarks.",
+            value="true",
+            required=True,
+            type="boolean",
+        ),
+        FormField(
+            var="last_seen_fallback",
+            label="Use contact presence status message to show when they were last seen.",
+            value="true",
+            required=True,
+            type="boolean",
+        ),
+        FormField(
+            var="roster_push",
+            label="Add contacts to your roster.",
+            value="true",
+            required=True,
+            type="boolean",
+        ),
     ]
 
     ROSTER_GROUP: str = "slidge"
@@ -211,7 +236,6 @@ class BaseGateway(
     is_group = False
     _can_send_carbon = False
     store: SlidgeStore
-    avatar_pk: int
 
     AVATAR_ID_TYPE: Callable[[str], Any] = str
     """
@@ -253,8 +277,9 @@ class BaseGateway(
     """
 
     http: aiohttp.ClientSession
+    avatar: CachedAvatar | None = None
 
-    def __init__(self):
+    def __init__(self) -> None:
         if config.COMPONENT_NAME:
             self.COMPONENT_NAME = config.COMPONENT_NAME
         if config.WELCOME_MESSAGE:
@@ -298,18 +323,13 @@ class BaseGateway(
         self.jid_validator: re.Pattern = re.compile(config.USER_JID_VALIDATOR)
         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.__setup_legacy_module_subclasses()
 
         self.get_session_from_stanza: Callable[
             [Union[Message, Presence, Iq]], BaseSession
-        ] = self.session_cls.from_stanza  # type: ignore
+        ] = self._session_cls.from_stanza
         self.get_session_from_user: Callable[[GatewayUser], BaseSession] = (
-            self.session_cls.from_user
+            self._session_cls.from_user
         )
 
         self.register_plugins()
@@ -349,13 +369,41 @@ class BaseGateway(
 
         MessageMixin.__init__(self)  # ComponentXMPP does not call super().__init__()
 
-    async def __set_http(self):
+    def __setup_legacy_module_subclasses(self):
+        from ..contact.roster import LegacyRoster
+        from ..group.bookmarks import LegacyBookmarks
+        from ..group.room import LegacyMUC, LegacyParticipant
+
+        session_cls: Type[BaseSession] = cast(
+            Type[BaseSession], BaseSession.get_unique_subclass()
+        )
+        contact_cls = LegacyContact.get_self_or_unique_subclass()
+        muc_cls = LegacyMUC.get_self_or_unique_subclass()
+        participant_cls = LegacyParticipant.get_self_or_unique_subclass()
+        bookmarks_cls = LegacyBookmarks.get_self_or_unique_subclass()
+        roster_cls = LegacyRoster.get_self_or_unique_subclass()
+
+        session_cls.xmpp = self  # type:ignore[attr-defined]
+        contact_cls.xmpp = self  # type:ignore[attr-defined]
+        muc_cls.xmpp = self  # type:ignore[attr-defined]
+
+        self._session_cls = session_cls
+        session_cls._bookmarks_cls = bookmarks_cls  # type:ignore[misc,assignment]
+        session_cls._roster_cls = roster_cls  # type:ignore[misc,assignment]
+        LegacyRoster._contact_cls = contact_cls  # type:ignore[misc]
+        LegacyBookmarks._muc_cls = muc_cls  # type:ignore[misc]
+        LegacyMUC._participant_cls = participant_cls  # type:ignore[misc]
+
+    async def kill_session(self, jid: JID) -> None:
+        await self._session_cls.kill_by_jid(jid)
+
+    async def __set_http(self) -> None:
         self.http = aiohttp.ClientSession()
         if getattr(self, "_test_mode", False):
             return
         avatar_cache.http = self.http
 
-    def __register_commands(self):
+    def __register_commands(self) -> None:
         for cls in Command.subclasses:
             if any(x is NotImplemented for x in [cls.CHAT_COMMAND, cls.NODE, cls.NAME]):
                 log.debug("Not adding command '%s' because it looks abstract", cls)
@@ -370,7 +418,7 @@ class BaseGateway(
             self.__adhoc_handler.register(c)
             self.__chat_commands_handler.register(c)
 
-    def __exception_handler(self, loop: asyncio.AbstractEventLoop, context):
+    def __exception_handler(self, loop: asyncio.AbstractEventLoop, context) -> None:
         """
         Called when a task created by loop.create_task() raises an Exception
 
@@ -390,7 +438,7 @@ class BaseGateway(
             self.has_crashed = True
             loop.stop()
 
-    def __register_slixmpp_events(self):
+    def __register_slixmpp_events(self) -> None:
         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)
@@ -403,16 +451,32 @@ class BaseGateway(
         self.add_event_handler("disconnected", self.connect)
 
     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")
+        def with_session(func, commit: bool = True):
+            def wrapped(*a, **kw):
+                with self.store.session() as orm:
+                    res = func(orm, *a, **kw)
+                    if commit:
+                        orm.commit()
+                    return res
+
+            return wrapped
+
+        self.plugin["xep_0231"].api.register(
+            with_session(self.store.bob.get_bob, False), "get_bob"
+        )
+        self.plugin["xep_0231"].api.register(
+            with_session(self.store.bob.set_bob), "set_bob"
+        )
+        self.plugin["xep_0231"].api.register(
+            with_session(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_session_start(self, event):
+    async def __on_session_start(self, event) -> None:
         log.debug("Gateway session start: %s", event)
 
         # prevents XMPP clients from considering the gateway as an HTTP upload
@@ -421,47 +485,48 @@ class BaseGateway(
         await self.plugin["xep_0115"].update_caps(jid=self.boundjid)
 
         if self.COMPONENT_AVATAR is not None:
+            log.debug("Setting gateway avatar…")
+            avatar = convert_avatar(self.COMPONENT_AVATAR, "!!---slidge---special---")
+            assert avatar is not None
             try:
-                cached_avatar = await avatar_cache.convert_or_get(self.COMPONENT_AVATAR)
+                cached_avatar = await avatar_cache.convert_or_get(avatar)
             except Exception as e:
                 log.exception("Could not set the component avatar.", exc_info=e)
                 cached_avatar = None
             else:
                 assert cached_avatar is not None
-                self.avatar_pk = cached_avatar.pk
+                self.avatar = cached_avatar
         else:
             cached_avatar = None
 
-        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
-            #       as last resort.
-            try:
-                await self["xep_0100"].add_component_to_roster(user.jid)
-                await self.__add_component_to_mds_whitelist(user.jid)
-            except (IqError, IqTimeout) as e:
-                # TODO: remove the user when this happens? or at least
-                # this can happen when the user has unsubscribed from the XMPP server
-                log.warning(
-                    "Error with user %s, not logging them automatically",
-                    user,
-                    exc_info=e,
-                )
-                continue
-            self.send_presence(
-                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))
-            if cached_avatar is not None:
-                await self.pubsub.broadcast_avatar(
-                    self.boundjid.bare, session.user_jid, cached_avatar
-                )
+        with self.store.session() as orm:
+            for user in orm.query(GatewayUser).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
+                #       as last resort.
+                try:
+                    await self["xep_0100"].add_component_to_roster(user.jid)
+                    await self.__add_component_to_mds_whitelist(user.jid)
+                except (IqError, IqTimeout) as e:
+                    # TODO: remove the user when this happens? or at least
+                    # this can happen when the user has unsubscribed from the XMPP server
+                    log.warning(
+                        "Error with user %s, not logging them automatically",
+                        user,
+                        exc_info=e,
+                    )
+                    continue
+                session = self._session_cls.from_user(user)
+                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")
 
-    async def __add_component_to_mds_whitelist(self, user_jid: JID):
+    async def __add_component_to_mds_whitelist(self, user_jid: JID) -> None:
         # Uses privileged entity to add ourselves to the whitelist of the PEP
         # MDS node so we receive MDS events
         iq_creation = Iq(sto=user_jid.bare, sfrom=user_jid, stype="set")
@@ -515,7 +580,7 @@ class BaseGateway(
             )
 
     @timeit
-    async def login_wrap(self, session: "BaseSession"):
+    async def login_wrap(self, session: "BaseSession") -> None:
         session.send_gateway_status("Logging in…", show="dnd")
         session.is_logging_in = True
         try:
@@ -534,7 +599,8 @@ class BaseGateway(
         log.info("Login success for %s", session.user_jid)
         session.logged = True
         session.send_gateway_status("Syncing contacts…", show="dnd")
-        await session.contacts._fill()
+        with self.store.session() as orm:
+            await session.contacts._fill(orm)
         if not (r := session.contacts.ready).done():
             r.set_result(True)
         if self.GROUPS:
@@ -542,10 +608,7 @@ class BaseGateway(
             await session.bookmarks.fill()
             if not (r := session.bookmarks.ready).done():
                 r.set_result(True)
-        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_jid.bare, ptype="probe")
+        self.send_presence(pto=session.user.jid.bare, ptype="probe")
         if status is None:
             session.send_gateway_status("Logged in", show="chat")
         else:
@@ -553,9 +616,12 @@ class BaseGateway(
         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)
+            with self.store.session(expire_on_commit=False) as orm:
+                session.user.avatar_hash = None
+                orm.add(session.user)
+                orm.commit()
 
-    async def fetch_user_avatar(self, session: BaseSession):
+    async def fetch_user_avatar(self, session: BaseSession) -> None:
         try:
             iq = await self.xmpp.plugin["xep_0060"].get_items(
                 session.user_jid.bare,
@@ -573,7 +639,10 @@ class BaseGateway(
                 except NotImplementedError:
                     pass
                 else:
-                    self.xmpp.store.users.set_avatar_hash(session.user_pk, None)
+                    with self.store.session(expire_on_commit=False) as orm:
+                        session.user.avatar_hash = None
+                        orm.add(session.user)
+                        orm.commit()
             return
         await self.__dispatcher.on_avatar_metadata_info(
             session, iq["pubsub"]["items"]["item"]["avatar_metadata"]["info"]
@@ -622,11 +691,11 @@ class BaseGateway(
 
     def get_session_from_jid(self, j: JID):
         try:
-            return self.session_cls.from_jid(j)
+            return self._session_cls.from_jid(j)
         except XMPPError:
             pass
 
-    def exception(self, exception: Exception):
+    def exception(self, exception: Exception) -> None:
         # """
         # Called when a task created by slixmpp's internal (eg, on slix events) raises an Exception.
         #
@@ -656,18 +725,26 @@ class BaseGateway(
             self.loop.stop()
             exit(1)
 
-    def re_login(self, session: "BaseSession"):
-        async def w():
+    def re_login(self, session: "BaseSession") -> None:
+        async def w() -> None:
             session.cancel_all_tasks()
-            await session.logout()
+            try:
+                await session.logout()
+            except NotImplementedError:
+                pass
             await self.login_wrap(session)
 
         session.create_task(w())
 
-    async def make_registration_form(self, _jid, _node, _ifrom, iq: Iq):
+    async def make_registration_form(
+        self, _jid: JID, _node: str, _ifrom: JID, iq: Iq
+    ) -> Form:
         self.raise_if_not_allowed_jid(iq.get_from())
         reg = iq["register"]
-        user = self.store.users.get_by_stanza(iq)
+        with self.store.session() as orm:
+            user = (
+                orm.query(GatewayUser).filter_by(jid=iq.get_from().bare).one_or_none()
+            )
         log.debug("User found: %s", user)
 
         form = reg["form"]
@@ -715,7 +792,7 @@ class BaseGateway(
 
     async def user_prevalidate(
         self, ifrom: JID, form_dict: dict[str, Optional[str]]
-    ) -> Optional[Mapping]:
+    ) -> JSONSerializable | None:
         # 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:
@@ -726,7 +803,7 @@ class BaseGateway(
 
     async def validate(
         self, user_jid: JID, registration_form: dict[str, Optional[str]]
-    ) -> Optional[Mapping]:
+    ) -> JSONSerializable | None:
         """
         Validate a user's initial registration form.
 
@@ -758,7 +835,7 @@ class BaseGateway(
 
     async def validate_two_factor_code(
         self, user: GatewayUser, code: str
-    ) -> Optional[dict]:
+    ) -> JSONSerializable | None:
         """
         Called when the user enters their 2FA code.
 
@@ -798,8 +875,8 @@ class BaseGateway(
         self,
         user_bare_jid: str,
         exception: Optional[Exception] = None,
-        legacy_data: Optional[dict] = None,
-    ):
+        legacy_data: Optional[JSONSerializable] = None,
+    ) -> None:
         """
         This method is meant to be called to finalize QR code-based registration
         flows, once the legacy service confirms the QR flashing.
@@ -820,16 +897,16 @@ class BaseGateway(
         else:
             fut.set_exception(exception)
 
-    async def unregister_user(self, user: GatewayUser):
+    async def unregister_user(self, user: GatewayUser) -> None:
         self.send_presence(
             pshow="dnd",
             pstatus="You unregistered from this gateway.",
             pto=user.jid,
         )
         await self.xmpp.plugin["xep_0077"].api["user_remove"](None, None, user.jid)
-        await self.xmpp.session_cls.kill_by_jid(user.jid)
+        await self.xmpp._session_cls.kill_by_jid(user.jid)
 
-    async def unregister(self, user: GatewayUser):
+    async def unregister(self, user: GatewayUser) -> None:
         """
         Optionally override this if you need to clean additional
         stuff after a user has been removed from the persistent user store.
@@ -845,7 +922,11 @@ class BaseGateway(
             pass
 
     async def input(
-        self, jid: JID, text=None, mtype: MessageTypes = "chat", **msg_kwargs
+        self,
+        jid: JID,
+        text: str | None = None,
+        mtype: MessageTypes = "chat",
+        **input_kwargs: Any,
     ) -> str:
         """
         Request arbitrary user input using a simple chat message, and await the result.
@@ -858,9 +939,11 @@ class BaseGateway(
         :param mtype: Message type
         :return: The user's reply
         """
-        return await self.__chat_commands_handler.input(jid, text, mtype, **msg_kwargs)
+        return await self.__chat_commands_handler.input(
+            jid, text, mtype=mtype, **input_kwargs
+        )
 
-    async def send_qr(self, text: str, **msg_kwargs):
+    async def send_qr(self, text: str, **msg_kwargs: Any) -> None:
         """
         Sends a QR Code to a JID
 
@@ -877,9 +960,9 @@ class BaseGateway(
             suffix=".png", delete=config.NO_UPLOAD_METHOD != "move"
         ) as f:
             qr.save(f.name)
-            await self.send_file(f.name, **msg_kwargs)
+            await self.send_file(Path(f.name), **msg_kwargs)
 
-    def shutdown(self) -> list[asyncio.Task]:
+    def shutdown(self) -> list[asyncio.Task[None]]:
         # """
         # Called by the slidge entrypoint on normal exit.
         #
@@ -889,9 +972,10 @@ class BaseGateway(
         # """
         log.debug("Shutting down")
         tasks = []
-        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)
+        with self.store.session() as orm:
+            for user in orm.query(GatewayUser).all():
+                tasks.append(self._session_cls.from_jid(user.jid).shutdown())
+                self.send_presence(ptype="unavailable", pto=user.jid)
         return tasks
 
 

slidge/core/mixins/__init__.py

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