hat-event 0.9.27__cp310.cp311.cp312.cp313-abi3-win_amd64.whl

hat/event/eventer/client.py

@@ -0,0 +1,260 @@
+"""Eventer Client"""
+
+from collections.abc import Collection, Iterable
+import asyncio
+import logging
+import typing
+
+from hat import aio
+from hat.drivers import chatter
+from hat.drivers import tcp
+
+from hat.event.eventer import common
+
+
+mlog: logging.Logger = logging.getLogger(__name__)
+"""Module logger"""
+
+StatusCb: typing.TypeAlias = aio.AsyncCallable[['Client', common.Status],
+                                               None]
+"""Status callback"""
+
+EventsCb: typing.TypeAlias = aio.AsyncCallable[['Client',
+                                                Collection[common.Event]],
+                                               None]
+"""Events callback"""
+
+
+class EventerInitError(Exception):
+    """Eventer initialization error"""
+
+
+async def connect(addr: tcp.Address,
+                  client_name: str,
+                  *,
+                  client_token: str | None = None,
+                  subscriptions: Iterable[common.EventType] = [],
+                  server_id: common.ServerId | None = None,
+                  persisted: bool = False,
+                  status_cb: StatusCb | None = None,
+                  events_cb: EventsCb | None = None,
+                  **kwargs
+                  ) -> 'Client':
+    """Connect to Eventer Server
+
+    Arguments `client_name` and optional `client_token` identifies eventer
+    client.
+
+    According to Event Server specification, each subscription is event
+    type identifier which can contain special subtypes ``?`` and ``*``.
+    Subtype ``?`` can occur at any position inside event type identifier
+    and is used as replacement for any single subtype. Subtype ``*`` is valid
+    only as last subtype in event type identifier and is used as replacement
+    for zero or more arbitrary subtypes.
+
+    If `subscriptions` is empty list, client doesn't subscribe for any events
+    and will not receive server's notifications.
+
+    If `server_id` is ``None``, client will receive all event notifications,
+    in accordance to `subscriptions`, regardless of event's server id. If
+    `server_id` is set, Eventer Server will only send events notifications
+    for events with provided server id.
+
+    If `persisted` is set to ``True``, Eventer Server will notify events
+    after they are persisted (flushed to disk). Otherwise, events are
+    notified immediately after registration.
+
+    Additional arguments are passed to `hat.chatter.connect` coroutine.
+
+    """
+    client = Client()
+    client._status_cb = status_cb
+    client._events_cb = events_cb
+    client._loop = asyncio.get_running_loop()
+    client._conv_futures = {}
+    client._status = common.Status.STANDBY
+
+    client._conn = await chatter.connect(addr, **kwargs)
+
+    try:
+        req_data = {'clientName': client_name,
+                    'clientToken': _optional_to_sbs(client_token),
+                    'subscriptions': [list(i) for i in subscriptions],
+                    'serverId': _optional_to_sbs(server_id),
+                    'persisted': persisted}
+        conv = await common.send_msg(conn=client._conn,
+                                     msg_type='HatEventer.MsgInitReq',
+                                     msg_data=req_data,
+                                     last=False)
+
+        res, res_type, res_data = await common.receive_msg(client._conn)
+        if res_type != 'HatEventer.MsgInitRes' or res.conv != conv:
+            raise Exception('invalid init response')
+
+        if res_data[0] == 'success':
+            client._status = common.Status(common.status_from_sbs(res_data[1]))
+
+        elif res_data[0] == 'error':
+            raise EventerInitError(res_data[1])
+
+        else:
+            raise ValueError('unsupported init response')
+
+        client.async_group.spawn(client._receive_loop)
+
+    except BaseException:
+        await aio.uncancellable(client.async_close())
+        raise
+
+    return client
+
+
+class Client(aio.Resource):
+    """Eventer client
+
+    For creating new client see `connect` coroutine.
+
+    """
+
+    @property
+    def async_group(self) -> aio.Group:
+        """Async group"""
+        return self._conn.async_group
+
+    @property
+    def status(self) -> common.Status:
+        """Status"""
+        return self._status
+
+    async def register(self,
+                       events: Collection[common.RegisterEvent],
+                       with_response: bool = False
+                       ) -> Collection[common.Event] | None:
+        """Register events and optionally wait for response
+
+        If `with_response` is ``True``, this coroutine returns list of events
+        or ``None`` if registration failure occurred.
+
+        """
+        msg_data = [common.register_event_to_sbs(i) for i in events]
+        conv = await common.send_msg(conn=self._conn,
+                                     msg_type='HatEventer.MsgRegisterReq',
+                                     msg_data=msg_data,
+                                     last=not with_response)
+
+        if with_response:
+            return await self._wait_conv_res(conv)
+
+    async def query(self,
+                    params: common.QueryParams
+                    ) -> common.QueryResult:
+        """Query events from server"""
+        msg_data = common.query_params_to_sbs(params)
+        conv = await common.send_msg(conn=self._conn,
+                                     msg_type='HatEventer.MsgQueryReq',
+                                     msg_data=msg_data,
+                                     last=False)
+
+        return await self._wait_conv_res(conv)
+
+    async def _receive_loop(self):
+        mlog.debug("starting receive loop")
+        try:
+            while True:
+                mlog.debug("waiting for incoming message")
+                msg, msg_type, msg_data = await common.receive_msg(self._conn)
+
+                if msg_type == 'HatEventer.MsgStatusNotify':
+                    mlog.debug("received status notification")
+                    await self._process_msg_status_notify(msg, msg_data)
+
+                elif msg_type == 'HatEventer.MsgEventsNotify':
+                    mlog.debug("received events notification")
+                    await self._process_msg_events_notify(msg, msg_data)
+
+                elif msg_type == 'HatEventer.MsgRegisterRes':
+                    mlog.debug("received register response")
+                    await self._process_msg_register_res(msg, msg_data)
+
+                elif msg_type == 'HatEventer.MsgQueryRes':
+                    mlog.debug("received query response")
+                    await self._process_msg_query_res(msg, msg_data)
+
+                else:
+                    raise Exception("unsupported message type")
+
+        except ConnectionError:
+            pass
+
+        except Exception as e:
+            mlog.error("read loop error: %s", e, exc_info=e)
+
+        finally:
+            mlog.debug("stopping receive loop")
+            self.close()
+
+            for future in self._conv_futures.values():
+                if not future.done():
+                    future.set_exception(ConnectionError())
+
+    async def _wait_conv_res(self, conv):
+        if not self.is_open:
+            raise ConnectionError()
+
+        future = self._loop.create_future()
+        self._conv_futures[conv] = future
+
+        try:
+            return await future
+
+        finally:
+            self._conv_futures.pop(conv, None)
+
+    async def _process_msg_status_notify(self, msg, msg_data):
+        self._status = common.status_from_sbs(msg_data)
+
+        if self._status_cb:
+            await aio.call(self._status_cb, self, self._status)
+
+    async def _process_msg_events_notify(self, msg, msg_data):
+        events = [common.event_from_sbs(event) for event in msg_data]
+
+        if self._events_cb:
+            await aio.call(self._events_cb, self, events)
+
+        if msg.last:
+            return
+
+        await common.send_msg(conn=self._conn,
+                              msg_type='HatEventer.MsgEventsAck',
+                              msg_data=None,
+                              conv=msg.conv)
+
+    async def _process_msg_register_res(self, msg, msg_data):
+        if msg_data[0] == 'events':
+            result = [common.event_from_sbs(event) for event in msg_data[1]]
+
+        elif msg_data[0] == 'failure':
+            result = None
+
+        else:
+            raise ValueError('unsupported register response')
+
+        future = self._conv_futures.get(msg.conv)
+        if not future or future.done():
+            return
+
+        future.set_result(result)
+
+    async def _process_msg_query_res(self, msg, msg_data):
+        result = common.query_result_from_sbs(msg_data)
+
+        future = self._conv_futures.get(msg.conv)
+        if not future or future.done():
+            return
+
+        future.set_result(result)
+
+
+def _optional_to_sbs(value):
+    return ('value', value) if value is not None else ('none', None)

hat/event/eventer/common.py

@@ -0,0 +1,27 @@
+from hat.event.common import *  # NOQA
+
+import typing
+
+from hat import sbs
+from hat.drivers import chatter
+
+from hat.event.common import sbs_repo
+
+
+MsgType: typing.TypeAlias = str
+
+
+async def send_msg(conn: chatter.Connection,
+                   msg_type: MsgType,
+                   msg_data: sbs.Data,
+                   **kwargs
+                   ) -> chatter.Conversation:
+    msg = sbs_repo.encode(msg_type, msg_data)
+    return await conn.send(chatter.Data(msg_type, msg), **kwargs)
+
+
+async def receive_msg(conn: chatter.Connection
+                      ) -> tuple[chatter.Msg, MsgType, sbs.Data]:
+    msg = await conn.receive()
+    msg_data = sbs_repo.decode(msg.data.type, msg.data.data)
+    return msg, msg.data.type, msg_data

hat/event/eventer/server.py

@@ -0,0 +1,286 @@
+from collections.abc import Collection
+import asyncio
+import collections
+import contextlib
+import itertools
+import logging
+import typing
+
+from hat import aio
+from hat.drivers import chatter
+from hat.drivers import tcp
+
+from hat.event.eventer import common
+
+
+mlog: logging.Logger = logging.getLogger(__name__)
+"""Module logger"""
+
+ConnectionId: typing.TypeAlias = int
+"""Connection identifier"""
+
+
+class ConnectionInfo(typing.NamedTuple):
+    id: ConnectionId
+    client_name: str
+    client_token: str | None
+    subscription: common.Subscription
+    server_id: int | None
+    persisted: bool
+
+
+ConnectionCb: typing.TypeAlias = aio.AsyncCallable[[ConnectionInfo], None]
+"""Connected/disconnected callback"""
+
+RegisterCb: typing.TypeAlias = aio.AsyncCallable[
+    [ConnectionInfo, Collection[common.RegisterEvent]],
+    Collection[common.Event] | None]
+"""Register callback"""
+
+QueryCb: typing.TypeAlias = aio.AsyncCallable[
+    [ConnectionInfo, common.QueryParams],
+    common.QueryResult]
+"""Query callback"""
+
+
+async def listen(addr: tcp.Address,
+                 *,
+                 status: common.Status = common.Status.STANDBY,
+                 connected_cb: ConnectionCb | None = None,
+                 disconnected_cb: ConnectionCb | None = None,
+                 register_cb: RegisterCb | None = None,
+                 query_cb: QueryCb | None = None,
+                 close_timeout: float = 0.5,
+                 **kwargs
+                 ) -> 'Server':
+    """Create listening Eventer Server instance"""
+    server = Server()
+    server._status = status
+    server._connected_cb = connected_cb
+    server._disconnected_cb = disconnected_cb
+    server._register_cb = register_cb
+    server._query_cb = query_cb
+    server._close_timeout = close_timeout
+    server._loop = asyncio.get_running_loop()
+    server._next_conn_ids = itertools.count(1)
+    server._conn_infos = {}
+    server._conn_conv_futures = {}
+
+    server._srv = await chatter.listen(server._connection_loop, addr, **kwargs)
+    mlog.debug("listening on %s", addr)
+
+    return server
+
+
+class Server(aio.Resource):
+
+    @property
+    def async_group(self) -> aio.Group:
+        """Async group"""
+        return self._srv.async_group
+
+    def get_conn_infos(self) -> list[ConnectionInfo]:
+        """Get connection infos"""
+        return list(self._conn_infos.values())
+
+    async def set_status(self, status: common.Status):
+        """Set status"""
+        if self._status == status:
+            return
+
+        self._status = status
+
+        for conn in list(self._conn_infos.keys()):
+            await self._notify_status(conn)
+
+    async def notify_events(self,
+                            events: Collection[common.Event],
+                            persisted: bool,
+                            with_ack: bool = False):
+        """Notify events to clients"""
+        conn_conn_events = collections.deque()
+
+        for conn, info in self._conn_infos.items():
+            if info.persisted != persisted:
+                continue
+
+            conn_events = collections.deque(
+                event for event in events
+                if (info.subscription.matches(event.type) and
+                    (info.server_id is None or
+                     info.server_id == event.id.server)))
+            if not conn_events:
+                continue
+
+            conn_conn_events.append((conn, conn_events))
+
+        if not conn_conn_events:
+            return
+
+        if with_ack:
+            await asyncio.wait([
+                self.async_group.spawn(self._notify_events, conn, conn_events,
+                                       True)
+                for conn, conn_events in conn_conn_events])
+
+        else:
+            for conn, conn_events in conn_conn_events:
+                await self._notify_events(conn, conn_events, False)
+
+    async def _connection_loop(self, conn):
+        mlog.debug("starting connection loop")
+        conn_id = next(self._next_conn_ids)
+        info = None
+
+        try:
+            req, req_type, req_data = await common.receive_msg(conn)
+            if req_type != 'HatEventer.MsgInitReq':
+                raise Exception('invalid init request type')
+
+            try:
+                info = ConnectionInfo(
+                    id=conn_id,
+                    client_name=req_data['clientName'],
+                    client_token=_optional_from_sbs(req_data['clientToken']),
+                    subscription=common.create_subscription(
+                        tuple(i) for i in req_data['subscriptions']),
+                    server_id=_optional_from_sbs(req_data['serverId']),
+                    persisted=req_data['persisted'])
+
+                if self._connected_cb:
+                    await aio.call(self._connected_cb, info)
+
+                res_data = 'success', common.status_to_sbs(self._status)
+                self._conn_infos[conn] = info
+
+            except Exception as e:
+                info = None
+                res_data = 'error', str(e)
+
+            mlog.debug("sending init response %s", res_data[0])
+            await common.send_msg(conn, 'HatEventer.MsgInitRes', res_data,
+                                  conv=req.conv)
+
+            if res_data[0] != 'success':
+                with contextlib.suppress(asyncio.TimeoutError):
+                    await aio.wait_for(conn.wait_closing(),
+                                       self._close_timeout)
+                return
+
+            while True:
+                mlog.debug("waiting for incomming messages")
+                msg, msg_type, msg_data = await common.receive_msg(conn)
+
+                if msg_type == 'HatEventer.MsgEventsAck':
+                    mlog.debug("received events ack")
+                    future = self._conn_conv_futures.get((conn, msg.conv))
+                    if future and not future.done():
+                        future.set_result(None)
+
+                elif msg_type == 'HatEventer.MsgRegisterReq':
+                    mlog.debug("received register request")
+                    await self._process_msg_register(conn, info, msg, msg_data)
+
+                elif msg_type == 'HatEventer.MsgQueryReq':
+                    mlog.debug("received query request")
+                    await self._process_msg_query(conn, info, msg, msg_data)
+
+                else:
+                    raise Exception('unsupported message type')
+
+        except ConnectionError:
+            pass
+
+        except Exception as e:
+            mlog.error("on connection error: %s", e, exc_info=e)
+
+        finally:
+            mlog.debug("stopping connection loop")
+            conn.close()
+            self._conn_infos.pop(conn, None)
+
+            for future in self._conn_conv_futures.values():
+                if not future.done():
+                    future.set_exception(ConnectionError())
+
+            if self._disconnected_cb and info:
+                with contextlib.suppress(Exception):
+                    await aio.call(self._disconnected_cb, info)
+
+    async def _process_msg_register(self, conn, info, req, req_data):
+        register_events = [common.register_event_from_sbs(i)
+                           for i in req_data]
+
+        if self._register_cb:
+            events = await aio.call(self._register_cb, info, register_events)
+
+        else:
+            events = None
+
+        if req.last:
+            return
+
+        if events is not None:
+            res_data = 'events', [common.event_to_sbs(event)
+                                  for event in events]
+
+        else:
+            res_data = 'failure', None
+
+        await common.send_msg(conn, 'HatEventer.MsgRegisterRes', res_data,
+                              conv=req.conv)
+
+    async def _process_msg_query(self, conn, info, req, req_data):
+        params = common.query_params_from_sbs(req_data)
+
+        if self._query_cb:
+            result = await aio.call(self._query_cb, info, params)
+
+        else:
+            result = common.QueryResult(events=[],
+                                        more_follows=False)
+
+        res_data = common.query_result_to_sbs(result)
+        await common.send_msg(conn, 'HatEventer.MsgQueryRes', res_data,
+                              conv=req.conv)
+
+    async def _notify_status(self, conn):
+        try:
+            msg_data = common.status_to_sbs(self._status)
+            await common.send_msg(conn, 'HatEventer.MsgStatusNotify', msg_data)
+
+        except ConnectionError:
+            pass
+
+        except Exception as e:
+            mlog.error("notify status error: %s", e, exc_info=e)
+
+    async def _notify_events(self, conn, events, with_ack):
+        try:
+            msg_data = [common.event_to_sbs(event) for event in events]
+            conv = await common.send_msg(conn,
+                                         'HatEventer.MsgEventsNotify',
+                                         msg_data,
+                                         last=not with_ack)
+
+            if not with_ack:
+                return
+
+            future = self._loop.create_future()
+            self._conn_conv_futures[(conn, conv)] = future
+
+            try:
+                await future
+
+            finally:
+                self._conn_conv_futures.pop((conn, conv))
+
+        except ConnectionError:
+            pass
+
+        except Exception as e:
+            mlog.error("notify events error: %s", e, exc_info=e)
+
+
+def _optional_from_sbs(data):
+    return data[1] if data[0] == 'value' else None

hat/event/manager/__main__.py

@@ -0,0 +1,8 @@
+import sys
+
+from hat.event.manager.main import main
+
+
+if __name__ == '__main__':
+    sys.argv[0] = 'hat-event-manager'
+    sys.exit(main())

hat/event/manager/common.py

@@ -0,0 +1,48 @@
+from hat.event.common import *  # NOQA
+
+from hat import json
+
+from hat.event.common import (Event,
+                              QueryResult,
+                              EventPayloadBinary,
+                              EventPayloadJson)
+
+
+def event_to_json(event: Event) -> json.Data:
+    return {
+        'id': _event_id_to_json(event.id),
+        'type': list(event.type),
+        'timestamp': _timestamp_to_json(event.timestamp),
+        'source_timestamp': (_timestamp_to_json(event.source_timestamp)
+                             if event.source_timestamp else None),
+        'payload': (_event_payload_to_json(event.payload)
+                    if event.payload else None)}
+
+
+def query_result_to_json(result: QueryResult) -> json.Data:
+    return {'events': [event_to_json(event) for event in result.events],
+            'more_follows': result.more_follows}
+
+
+def _event_id_to_json(event_id):
+    return {'server': event_id.server,
+            'session': event_id.session,
+            'instance': event_id.instance}
+
+
+def _timestamp_to_json(timestamp):
+    return {'s': timestamp.s,
+            'us': timestamp.us}
+
+
+def _event_payload_to_json(payload):
+    if isinstance(payload, EventPayloadBinary):
+        return {'data_type': 'binary',
+                'binary_type': payload.type,
+                'data': bytes(payload.data).hex()}
+
+    if isinstance(payload, EventPayloadJson):
+        return {'data_type': 'json',
+                'data': payload.data}
+
+    raise ValueError('unuspported payload type')