slidge 0.1.0b2__py3-none-any.whl → 0.1.1__py3-none-any.whl

slidge/plugins/mattermost/websocket.py

@@ -1,252 +0,0 @@
-import asyncio
-import json
-import logging
-import pprint
-import ssl
-import time
-from dataclasses import dataclass
-from enum import Enum
-
-import aiohttp
-
-
-class EventType(str, Enum):
-    AddedToTeam = "added_to_team"
-    AuthenticationChallenge = "authentication_challenge"
-    ChannelConverted = "channel_converted"
-    ChannelCreated = "channel_created"
-    ChannelDeleted = "channel_deleted"
-    ChannelMemberUpdated = "channel_member_updated"
-    ChannelUpdated = "channel_updated"
-    ChannelViewed = "channel_viewed"
-    ConfigChanged = "config_changed"
-    DeleteTeam = "delete_team"
-    DirectAdded = "direct_added"
-    EmojiAdded = "emoji_added"
-    EphemeralMessage = "ephemeral_message"
-    GroupAdded = "group_added"
-    Hello = "hello"
-    LeaveTeam = "leave_team"
-    LicenseChanged = "license_changed"
-    MemberroleUpdated = "memberrole_updated"
-    NewUser = "new_user"
-    PluginDisabled = "plugin_disabled"
-    PluginEnabled = "plugin_enabled"
-    PluginStatusesChanged = "plugin_statuses_changed"
-    PostDeleted = "post_deleted"
-    PostEdited = "post_edited"
-    PostUnread = "post_unread"
-    Posted = "posted"
-    PreferenceChanged = "preference_changed"
-    PreferencesChanged = "preferences_changed"
-    PreferencesDeleted = "preferences_deleted"
-    ReactionAdded = "reaction_added"
-    ReactionRemoved = "reaction_removed"
-    Response = "response"
-    RoleUpdated = "role_updated"
-    StatusChange = "status_change"
-    Typing = "typing"
-    UpdateTeam = "update_team"
-    UserAdded = "user_added"
-    UserRemoved = "user_removed"
-    UserRoleUpdated = "user_role_updated"
-    UserUpdated = "user_updated"
-    DialogOpened = "dialog_opened"
-    ThreadUpdated = "thread_updated"
-    ThreadFollowChanged = "thread_follow_changed"
-    ThreadReadChanged = "thread_read_changed"
-
-    # not in the https://api.mattermost.com
-    SidebarCategoryUpdated = "sidebar_category_updated"
-
-    Unknown = "__unknown__"
-
-
-@dataclass
-class MattermostEvent:
-    type: EventType
-    data: dict
-    broadcast: dict
-    left: dict
-
-    def __str__(self):
-        return (
-            f"<{self.type}:"
-            f" \ndata: {pprint.pformat(self.data)}"
-            f" \nbroadcast: {pprint.pformat(self.broadcast)}"
-            f" \nleft: {pprint.pformat(self.left)}"
-            f">"
-        )
-
-
-class Websocket:
-    def __init__(self, url, token):
-        self.token = token
-        self.url = url
-
-        self._alive = False
-        self._last_msg = 0
-
-        self.ssl_verify = True
-        self.keep_alive = True
-        self.keep_alive_delay = 30
-        self.websocket: asyncio.Future[
-            aiohttp.ClientWebSocketResponse
-        ] = asyncio.get_event_loop().create_future()
-        self._futures: dict[int, asyncio.Future[dict]] = {}
-        self._seq_cursor = 0
-
-    async def connect(self, event_handler):
-        """
-        Connect to the websocket and authenticate it.
-        When the authentication has finished, start the loop listening for messages,
-        sending a ping to the server to keep the connection alive.
-        :param event_handler: Every websocket event will be passed there. Takes one argument.
-        :type event_handler: Function(message)
-        :return:
-        """
-        context = ssl.create_default_context(purpose=ssl.Purpose.CLIENT_AUTH)
-        if not self.ssl_verify:
-            context.verify_mode = ssl.CERT_NONE
-
-        url = self.url
-        self._alive = True
-
-        while True:
-            try:
-                kw_args = {}
-                async with aiohttp.ClientSession() as session:
-                    async with session.ws_connect(
-                        url,
-                        ssl=context,
-                        **kw_args,
-                    ) as websocket:
-                        self.websocket.set_result(websocket)
-                        await self._authenticate_websocket(websocket)
-                        while self._alive:
-                            try:
-                                await self._start_loop(websocket, event_handler)
-                            except aiohttp.ClientError:
-                                break
-                        if (not self.keep_alive) or (not self._alive):
-                            break
-            except Exception as e:
-                log.exception(
-                    f"Failed to establish websocket connection: {type(e)} thrown"
-                )
-                await asyncio.sleep(self.keep_alive_delay)
-
-    async def _start_loop(self, websocket, event_handler):
-        """
-        We will listen for websockets events, sending a heartbeats on a timer.
-        If we don't the webserver would close the idle connection,
-        forcing us to reconnect.
-        """
-        log.debug("Starting websocket loop")
-        keep_alive = asyncio.create_task(self._do_heartbeats(websocket))
-        log.debug("Waiting for messages on websocket")
-        while self._alive:
-            message = await websocket.receive_str()
-            d = json.loads(message)
-            self._last_msg = time.time()
-            if (seq := d.get("seq_reply")) is None:
-                await handle_event(d, event_handler)
-            else:
-                try:
-                    self._futures.pop(seq).set_result(d)
-                except KeyError:
-                    log.warning("Ignoring %s", d)
-        log.debug("cancelling heartbeat task")
-        keep_alive.cancel()
-        try:
-            await keep_alive
-        except asyncio.CancelledError:
-            pass
-
-    async def _do_heartbeats(self, websocket):
-        """
-        This is a little complicated, but we only need to pong the websocket if
-        we haven't received a message inside the timeout window.
-        Since messages can be received, while we are waiting we need to check
-        after sleep.
-        """
-        timeout = 30
-        while True:
-            since_last_msg = time.time() - self._last_msg
-            next_timeout = (
-                timeout - since_last_msg if since_last_msg <= timeout else timeout
-            )
-            await asyncio.sleep(next_timeout)
-            if time.time() - self._last_msg >= timeout:
-                log.debug("sending heartbeat...")
-                await websocket.pong()
-                self._last_msg = time.time()
-
-    def disconnect(self):
-        """Sets `self._alive` to False so the loop in `self._start_loop` will finish."""
-        log.info("Disconnecting websocket")
-        self._alive = False
-
-    async def _authenticate_websocket(self, websocket):
-        """
-        Sends an authentication challenge over a websocket.
-        This is not needed when we just send the cookie we got on login
-        when connecting to the websocket.
-        """
-        log.debug("Authenticating websocket")
-        json_data = json.dumps(
-            {
-                "seq": 1,
-                "action": "authentication_challenge",
-                "data": {"token": self.token},
-            }
-        )
-        await websocket.send_str(json_data)
-        while True:
-            message = await websocket.receive_str()
-            status = json.loads(message)
-            log.debug(status)
-            if ("event" in status and status["event"] == "hello") and (
-                "seq" in status and status["seq"] == 0
-            ):
-                log.info("Websocket authentication OK")
-                return True
-            log.error("Websocket authentication failed")
-
-    async def user_typing(self, channel_id):
-        seq = self._seq_cursor
-        self._seq_cursor += 1
-        f = self._futures[seq] = asyncio.get_event_loop().create_future()
-        payload = json.dumps(
-            {
-                "seq": seq,
-                "action": "user_typing",
-                "data": {"channel_id": channel_id},
-            }
-        )
-        log.debug("Sending %s", payload)
-        await (await self.websocket).send_str(payload)
-        r = await f
-        log.debug("Confirmation %s", r)
-
-
-async def handle_event(d, event_handler):
-    if "event" in d:
-        raw_data = d.pop("data")
-        data = {}
-
-        for k, v in raw_data.items():
-            try:
-                data[k] = json.loads(v)
-            except (json.JSONDecodeError, TypeError):
-                data[k] = v
-
-        try:
-            event = EventType(d.pop("event"))
-        except ValueError:
-            event = EventType.Unknown
-        bro = d.pop("broadcast")
-        await event_handler(MattermostEvent(event, data, bro, d))
-
-
-log = logging.getLogger(__name__)

slidge/plugins/signal/__init__.py

@@ -1,3 +0,0 @@
-from .contact import Contact, Roster
-from .gateway import Gateway
-from .session import Session

slidge/plugins/signal/contact.py

@@ -1,106 +0,0 @@
-import functools
-import logging
-from datetime import datetime
-from mimetypes import guess_extension
-from pathlib import Path
-from typing import TYPE_CHECKING, Optional
-
-import aiosignald.exc as sigexc
-import aiosignald.generated as sigapi
-from slixmpp.exceptions import XMPPError
-
-from slidge import *
-
-if TYPE_CHECKING:
-    from .session import Session
-
-
-class Contact(LegacyContact["Session"]):
-    CORRECTION = False
-
-    def __init__(self, *a, **k):
-        super().__init__(*a, **k)
-        # keys = msg timestamp; vals = single character emoji
-        self.user_reactions = dict[int, str]()
-
-    @functools.cached_property
-    def signal_address(self):
-        return sigapi.JsonAddressv1(uuid=self.legacy_id)
-
-    async def get_identities(self):
-        s = await self.session.signal
-        log.debug("%s, %s", type(self.session.phone), type(self.signal_address))
-        try:
-            r = await s.get_identities(
-                account=self.session.phone,
-                address=self.signal_address,
-            )
-        except sigexc.UnregisteredUserError:
-            raise XMPPError("not-found")
-        identities = r.identities
-        self.session.send_gateway_message(str(identities))
-
-    async def send_attachments(
-        self,
-        attachments: list[sigapi.JsonAttachmentv1],
-        /,
-        legacy_msg_id: int,
-        reply_to_msg_id: int,
-        when: Optional[datetime] = None,
-    ):
-        for attachment in attachments:
-            filename = get_filename(attachment)
-            with open(attachment.storedFilename, "rb") as f:
-                await self.send_file(
-                    filename=filename,
-                    input_file=f,
-                    content_type=attachment.contentType,
-                    legacy_msg_id=legacy_msg_id,
-                    reply_to_msg_id=reply_to_msg_id,
-                    when=when,
-                )
-
-    async def update_info(self, profile: Optional[sigapi.Profilev1] = None):
-        if profile is None:
-            profile = await (await self.session.signal).get_profile(
-                account=self.session.phone, address=self.signal_address
-            )
-        nick = profile.name or profile.profile_name
-        if nick is not None:
-            nick = nick.replace("\u0000", "")
-            self.name = nick
-        if profile.avatar is not None:
-            self.avatar = Path(profile.avatar)
-
-        address = await (await self.session.signal).resolve_address(
-            account=self.session.phone,
-            partial=sigapi.JsonAddressv1(uuid=self.legacy_id),
-        )
-
-        self.set_vcard(full_name=nick, phone=address.number, note=profile.about)
-
-    async def update_and_add(self):
-        await self.update_info()
-        await self.add_to_roster()
-
-
-def get_filename(attachment: sigapi.JsonAttachmentv1):
-    if f := attachment.customFilename:
-        return f
-    else:
-        filename = attachment.id or "unnamed"
-        ext = guess_extension(attachment.contentType)
-        if ext is not None:
-            filename += ext
-        return filename
-
-
-class Roster(LegacyRoster[Contact, "Session"]):
-    def by_json_address(self, address: sigapi.JsonAddressv1):
-        c = self.by_legacy_id(address.uuid)
-        if not c.added_to_roster:
-            self.session.xmpp.loop.create_task(c.update_and_add())
-        return c
-
-
-log = logging.getLogger(__name__)

slidge/plugins/signal/gateway.py

@@ -1,282 +0,0 @@
-import asyncio
-import functools
-import logging
-from argparse import ArgumentParser
-from datetime import datetime
-from typing import TYPE_CHECKING, Any, Optional
-
-import aiosignald.exc as sigexc
-import aiosignald.generated as sigapi
-from aiosignald import SignaldAPI
-from slixmpp import JID, Iq, Message
-from slixmpp.exceptions import XMPPError
-from slixmpp.plugins.xep_0004 import Form
-
-from slidge import *
-from slidge.util import is_valid_phone_number
-
-if TYPE_CHECKING:
-    from .session import Session
-
-from . import txt
-
-
-class Gateway(BaseGateway):
-    COMPONENT_NAME = "Signal (slidge)"
-    COMPONENT_TYPE = "signal"
-    COMPONENT_AVATAR = (
-        "https://upload.wikimedia.org/wikipedia/commons/5/56/Logo_Signal..png"
-    )
-    REGISTRATION_INSTRUCTIONS = txt.REGISTRATION_INSTRUCTIONS
-    REGISTRATION_FIELDS = txt.REGISTRATION_FIELDS
-
-    ROSTER_GROUP = "Signal"
-
-    SEARCH_FIELDS = [
-        FormField(var="phone", label="Phone number", required=True),
-    ]
-
-    signal: asyncio.Future["Signal"]
-    signal_socket: str
-    sessions_by_phone: dict[str, "Session"] = {}
-
-    CHAT_COMMANDS = {
-        "add_device": "_chat_command_add_device",
-        "get_identities": "_chat_command_get_identities",
-    }
-
-    def __init__(self, args):
-        super(Gateway, self).__init__(args)
-        self.signal: asyncio.Future[Signal] = self.loop.create_future()
-
-    def config(self, argv: list[str]):
-        args = get_parser().parse_args(argv)
-        self.signal_socket = socket = args.socket
-        self.loop.create_task(self.connect_signal(socket))
-
-    async def connect_signal(self, socket: str):
-        """
-        Establish connection to the signald socker
-        """
-        log.debug("Connecting to signald...")
-        _, signal = await self.loop.create_unix_connection(
-            functools.partial(Signal, self), socket
-        )
-        self.signal.set_result(signal)
-        await signal.on_con_lost
-        log.error("Signald UNIX socket connection lost!")
-        raise RuntimeError("Signald socket connection lost")
-
-    def add_adhoc_commands(self):
-        self["xep_0050"].add_command(
-            node="linked_devices",
-            name="Get linked devices",
-            handler=self._handle_linked_devices,
-        )
-        self["xep_0050"].add_command(
-            node="add_device",
-            name="Link a new device",
-            handler=self._handle_add_device1,
-        )
-
-    async def _handle_linked_devices(self, iq: Iq, adhoc_session: dict[str, Any]):
-        user = user_store.get_by_stanza(iq)
-        if user is None:
-            raise XMPPError("subscription-required")
-
-        devices = await (await self.signal).get_linked_devices(
-            account=user.registration_form["phone"]
-        )
-
-        # TODO: uncomment this when https://dev.gajim.org/gajim/gajim/-/issues/10857 is fixed
-        # There are probably other clients that handle this just fine and this would make more sense
-        # to use this, but I think targeting gajim compatibility when there are easy workarounds
-        # is OK
-        # form = self["xep_0004"].make_form("result", "Linked devices")
-        # form.add_reported("id", label="ID", type="fixed")
-        # form.add_reported("name", label="Name", type="fixed")
-        # form.add_reported("created", label="Created", type="fixed")
-        # form.add_reported("last_seen", label="Last seen", type="fixed")
-        # for d in devices.devices:
-        #     form.add_item(
-        #         {
-        #             "name": d.name,
-        #             "id": str(d.id),
-        #             "created": datetime.fromtimestamp(d.created / 1000).isoformat(),
-        #             "last_seen": datetime.fromtimestamp(d.lastSeen / 1000).isoformat(),
-        #         }
-        #     )
-        #
-        # adhoc_session["payload"] = form
-        adhoc_session["notes"] = [
-            (
-                "info",
-                f"Name: {d.name} / "
-                f"ID: {d.id} / "
-                f"Created: {datetime.fromtimestamp(d.created / 1000).isoformat()} / "
-                f"Last seen: {datetime.fromtimestamp(d.lastSeen / 1000).isoformat()}",
-            )
-            for d in devices.devices
-        ]
-        adhoc_session["has_next"] = False
-
-        return adhoc_session
-
-    async def _handle_add_device1(self, iq: Iq, adhoc_session: dict[str, Any]):
-        user = user_store.get_by_stanza(iq)
-        if user is None:
-            raise XMPPError("subscription-required")
-
-        form = self["xep_0004"].make_form(
-            "form", "Link a new device to your signal account"
-        )
-        form.add_field(
-            var="uri",
-            ftype="text-single",
-            label="Linking URI. Use a QR code reader app to get it from official signal clients.",
-            required=True,
-        )
-
-        adhoc_session["payload"] = form
-        adhoc_session["has_next"] = True
-        adhoc_session["next"] = self._handle_add_device2
-
-        return adhoc_session
-
-    async def _handle_add_device2(self, stanza: Form, adhoc_session: dict[str, Any]):
-        user = user_store.get_by_jid(adhoc_session["from"])
-        if user is None:
-            raise XMPPError("subscription-required")
-
-        values = stanza.get_values()
-        uri = values.get("uri")
-
-        await (await self.signal).add_device(
-            account=user.registration_form["phone"], uri=uri
-        )
-
-        adhoc_session["notes"] = [
-            (
-                "info",
-                "Your new device is now correctly linked to your signal account",
-            )
-        ]
-        adhoc_session["has_next"] = False
-
-        return adhoc_session
-
-    @staticmethod
-    async def _chat_command_add_device(
-        *args, msg: Message, session: Optional["Session"] = None
-    ):
-        if session is None:
-            msg.reply("I don't know you, so don't talk to me").send()
-            return
-        if len(args) == 0:
-            uri = await session.input("URI?")
-        elif len(args) > 1:
-            msg.reply("Syntax error! Use 'add_device [LINKING_URI]'").send()
-            return
-        else:
-            uri = args[0]
-        await session.add_device(uri)
-
-    @staticmethod
-    async def _chat_command_get_identities(
-        *args, msg: Message, session: Optional["Session"] = None
-    ):
-        if session is None:
-            msg.reply("I don't know you, so don't talk to me").send()
-            return
-        if len(args) == 0:
-            uuid = await session.input("UUID?")
-        elif len(args) > 1:
-            msg.reply("Syntax error! Use 'get_identities [UUID]'").send()
-            return
-        else:
-            uuid = args[0]
-        await session.contacts.by_legacy_id(uuid).get_identities()
-
-    async def validate(
-        self, user_jid: JID, registration_form: dict[str, Optional[str]]
-    ):
-        phone = registration_form.get("phone")
-        if not is_valid_phone_number(phone):
-            raise ValueError("Not a valid phone number")
-        for u in user_store.get_all():
-            if u.registration_form.get("phone") == phone:
-                raise XMPPError(
-                    "not-allowed",
-                    text="Someone is already using this phone number on this server.\n",
-                )
-        if registration_form.get("device") == "primary" and not registration_form.get(
-            "name"
-        ):
-            raise ValueError(txt.NAME_REQUIRED)
-
-    async def unregister(self, user: GatewayUser):
-        try:
-            await (await self.signal).delete_account(
-                account=user.registration_form.get("phone"), server=False
-            )
-        except sigexc.NoSuchAccountError:
-            # if user unregisters before completing the registration process,
-            # NoSuchAccountError is raised by signald
-            pass
-
-        log.info("Removed user: %s", user)
-
-
-# noinspection PyPep8Naming,GrazieInspection
-class Signal(SignaldAPI):
-    """
-    Extends :class:`.SignaldAPI` with handlers for events we are interested in.
-    """
-
-    def __init__(self, xmpp: Gateway):
-        super().__init__()
-        self.sessions_by_phone = xmpp.sessions_by_phone
-
-    async def handle_WebSocketConnectionState(
-        self, state: sigapi.WebSocketConnectionStatev1, payload
-    ):
-        """
-        We should not care much about this since
-
-        :param state:
-        :param payload:
-        """
-        session = self.sessions_by_phone[payload["account"]]
-        await session.on_websocket_connection_state(state)
-
-    async def handle_ListenerState(self, state: sigapi.ListenerStatev1, payload):
-        """
-        Deprecated in signald and replaced by WebSocketConnectionState
-        Just here to avoid cluttering logs with unhandled events warnings
-
-        :param state:
-        :param payload:
-        """
-        pass
-
-    async def handle_IncomingMessage(self, msg: sigapi.IncomingMessagev1, _payload):
-        """
-        Dispatch a signald message to the proper session.
-
-        Can be a lot of other things than an actual message, still need to figure
-        things out to cover all cases.
-
-        :param msg: the data!
-        :param _payload:
-        """
-        session = self.sessions_by_phone[msg.account]
-        await session.on_signal_message(msg)
-
-
-def get_parser():
-    parser = ArgumentParser()
-    parser.add_argument("--socket", default="/signald/signald.sock")
-    return parser
-
-
-log = logging.getLogger(__name__)