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

hat/event/server/engine_runner.py

@@ -0,0 +1,127 @@
+from collections.abc import Callable
+import asyncio
+import logging
+
+from hat import aio
+from hat import json
+
+from hat.event import common
+from hat.event.server.engine import create_engine
+from hat.event.server.eventer_client import SyncedState
+from hat.event.server.eventer_client_runner import EventerClientRunner
+from hat.event.server.eventer_server import EventerServer
+
+
+mlog: logging.Logger = logging.getLogger(__name__)
+"""Module logger"""
+
+
+class EngineRunner(aio.Resource):
+
+    def __init__(self,
+                 conf: json.Data,
+                 backend: common.Backend,
+                 eventer_server: EventerServer,
+                 eventer_client_runner: EventerClientRunner | None,
+                 reset_monitor_ready_cb: Callable[[], None]):
+        self._conf = conf
+        self._backend = backend
+        self._eventer_server = eventer_server
+        self._eventer_client_runner = eventer_client_runner
+        self._reset_monitor_ready_cb = reset_monitor_ready_cb
+        self._async_group = aio.Group()
+        self._engine = None
+        self._restart = asyncio.Event()
+
+        self.async_group.spawn(self._run)
+
+    @property
+    def async_group(self) -> aio.Group:
+        return self._async_group
+
+    async def set_synced(self,
+                         server_id: common.ServerId,
+                         state: SyncedState,
+                         count: int | None):
+        if not self._engine or not self._engine.is_open:
+            return
+
+        data = {'state': state.name}
+        if state == SyncedState.SYNCED:
+            data['count'] = count
+
+        source = common.Source(type=common.SourceType.SERVER, id=0)
+        event = common.RegisterEvent(
+            type=('event', str(self._conf['server_id']), 'synced',
+                  str(server_id)),
+            source_timestamp=None,
+            payload=common.EventPayloadJson(data))
+
+        await self._engine.register(source, [event])
+
+    async def _run(self):
+        try:
+            mlog.debug("staring engine runner loop")
+            while True:
+                await self._wait_while_remote_active()
+
+                self._restart.clear()
+
+                await self._eventer_server.set_status(common.Status.STARTING,
+                                                      None)
+
+                mlog.debug("creating engine")
+                self._engine = await create_engine(
+                    backend=self._backend,
+                    eventer_server=self._eventer_server,
+                    module_confs=self._conf['modules'],
+                    server_id=self._conf['server_id'],
+                    restart_cb=self._restart.set,
+                    reset_monitor_ready_cb=self._reset_monitor_ready_cb)
+                await self._eventer_server.set_status(
+                    common.Status.OPERATIONAL, self._engine)
+
+                async with self._async_group.create_subgroup() as subgroup:
+                    await asyncio.wait(
+                        [subgroup.spawn(self._engine.wait_closing),
+                         subgroup.spawn(self._restart.wait)],
+                        return_when=asyncio.FIRST_COMPLETED)
+
+                if not self._engine.is_open:
+                    break
+
+                await self._close()
+
+        except Exception as e:
+            mlog.error("engine runner loop error: %s", e, exc_info=e)
+
+        finally:
+            mlog.debug("closing engine runner loop")
+            self.close()
+            await aio.uncancellable(self._close())
+
+    async def _close(self):
+        if self._engine:
+            self._engine.close()
+
+        await self._eventer_server.set_status(common.Status.STOPPING, None)
+
+        if self._engine:
+            await self._engine.async_close()
+
+        await self._backend.flush()
+
+        # TODO not needed with _wait_while_remote_active
+        # await self._eventer_server.notify_events([], True, True)
+
+        await self._eventer_server.set_status(common.Status.STANDBY, None)
+
+    async def _wait_while_remote_active(self):
+        if not self._eventer_client_runner:
+            return
+
+        while self._eventer_client_runner.remote_active:
+            event = asyncio.Event()
+            with self._eventer_client_runner.register_remote_active_cb(
+                    lambda _: event.set()):
+                await event.wait()

hat/event/server/eventer_client.py

@@ -0,0 +1,205 @@
+import collections
+import contextlib
+import enum
+import logging
+import typing
+
+from hat import aio
+from hat.drivers import tcp
+
+from hat.event import common
+from hat.event import eventer
+
+
+mlog: logging.Logger = logging.getLogger(__name__)
+"""Module logger"""
+
+
+class SyncedState(enum.Enum):
+    """Synced state"""
+    CONNECTED = 0
+    SYNCING = 1
+    SYNCED = 2
+
+
+StatusCb: typing.TypeAlias = aio.AsyncCallable[[common.Status], None]
+"""Status callback"""
+
+SyncedCb: typing.TypeAlias = aio.AsyncCallable[[SyncedState, int | None], None]
+"""Synced callback"""
+
+
+async def create_eventer_client(addr: tcp.Address,
+                                client_name: str,
+                                local_server_id: common.ServerId,
+                                remote_server_id: common.ServerId,
+                                backend: common.Backend,
+                                *,
+                                client_token: str | None = None,
+                                status_cb: StatusCb | None = None,
+                                synced_cb: SyncedCb | None = None,
+                                **kwargs
+                                ) -> 'EventerClient':
+    """Create eventer client"""
+    client = EventerClient()
+    client._local_server_id = local_server_id
+    client._remote_server_id = remote_server_id
+    client._backend = backend
+    client._status_cb = status_cb
+    client._synced_cb = synced_cb
+    client._synced = None
+    client._events_queue = collections.deque()
+
+    client._client = await eventer.connect(addr=addr,
+                                           client_name=client_name,
+                                           client_token=client_token,
+                                           subscriptions=[('*', )],
+                                           server_id=remote_server_id,
+                                           persisted=True,
+                                           status_cb=client._on_status,
+                                           events_cb=client._on_events,
+                                           **kwargs)
+
+    try:
+        client.async_group.spawn(client._synchronize)
+
+    except BaseException:
+        await aio.uncancellable(client.async_close())
+        raise
+
+    return client
+
+
+class EventerClient(aio.Resource):
+    """Eventer client
+
+    For creating new client see `create_eventer_client` coroutine.
+
+    """
+
+    @property
+    def async_group(self) -> aio.Group:
+        """Async group"""
+        return self._client.async_group
+
+    @property
+    def status(self) -> common.Status:
+        """Status"""
+        return self._client.status
+
+    @property
+    def synced(self) -> SyncedState | None:
+        """Synced state"""
+        return self._synced
+
+    async def _on_status(self, client, status):
+        if status == common.Status.OPERATIONAL and self._synced:
+            data = {'state': self._synced.name}
+            if self._synced == SyncedState.SYNCED:
+                data['count'] = None
+
+            with contextlib.suppress(Exception):
+                await self._client.register([
+                    common.RegisterEvent(
+                        type=('event', str(self._local_server_id), 'synced',
+                              str(self._remote_server_id)),
+                        source_timestamp=None,
+                        payload=common.EventPayloadJson(data))])
+
+        if not self._status_cb:
+            return
+
+        await aio.call(self._status_cb, status)
+
+    async def _on_events(self, client, events):
+        mlog.debug("received %s notify events", len(events))
+
+        if self._events_queue is not None:
+            self._events_queue.append(events)
+            return
+
+        await self._backend.register(events)
+
+    async def _synchronize(self):
+        mlog.debug("starting synchronization")
+
+        try:
+            last_event_id = await self._backend.get_last_event_id(
+                self._remote_server_id)
+            events = collections.deque()
+            result = common.QueryResult([], True)
+            synced_counter = 0
+
+            await self._set_synced(SyncedState.CONNECTED, None)
+
+            while result.more_follows:
+                params = common.QueryServerParams(
+                    server_id=self._remote_server_id,
+                    persisted=True,
+                    last_event_id=last_event_id)
+                result = await self._client.query(params)
+
+                mlog.debug("received %s query events", len(result.events))
+                events.extend(result.events)
+
+                if result.events and synced_counter == 0:
+                    await self._set_synced(SyncedState.SYNCING, None)
+
+                synced_counter += len(result.events)
+                if not events:
+                    continue
+
+                last_event_id = events[-1].id
+
+                while events[0].id.session != events[-1].id.session:
+                    session_id = events[0].id.session
+                    session_events = collections.deque()
+
+                    while events[0].id.session == session_id:
+                        session_events.append(events.popleft())
+
+                    await self._backend.register(session_events)
+
+            if events:
+                await self._backend.register(events)
+
+            mlog.debug("processing cached notify events")
+            while self._events_queue:
+                events = [event for event in self._events_queue.popleft()
+                          if event.id > last_event_id]
+                if not events:
+                    continue
+
+                await self._backend.register(events)
+
+            self._events_queue = None
+
+            mlog.debug("synchronized %s events", synced_counter)
+            await self._set_synced(SyncedState.SYNCED, synced_counter)
+
+        except ConnectionError:
+            mlog.debug("connection closed")
+            self.close()
+
+        except Exception as e:
+            mlog.error("synchronization error: %s", e, exc_info=e)
+            self.close()
+
+    async def _set_synced(self, state, count):
+        self._synced = state
+
+        data = {'state': state.name}
+        if state == SyncedState.SYNCED:
+            data['count'] = count
+
+        await self._client.register([
+            common.RegisterEvent(
+                type=('event', str(self._local_server_id), 'synced',
+                      str(self._remote_server_id)),
+                source_timestamp=None,
+                payload=common.EventPayloadJson(data))])
+
+        if not self._synced_cb:
+            return
+
+        await aio.call(self._synced_cb, state, count)

hat/event/server/eventer_client_runner.py

@@ -0,0 +1,152 @@
+from collections.abc import Callable
+import asyncio
+import functools
+import logging
+import types
+import typing
+
+from hat import aio
+from hat import json
+from hat import util
+from hat.drivers import tcp
+import hat.monitor.component
+
+from hat.event import common
+from hat.event.server.eventer_client import (SyncedState,
+                                             create_eventer_client)
+
+
+mlog: logging.Logger = logging.getLogger(__name__)
+"""Module logger"""
+
+
+SyncedCb: typing.TypeAlias = aio.AsyncCallable[
+    [common.ServerId, SyncedState, int | None],
+    None]
+
+
+class EventerServerData(typing.NamedTuple):
+    server_id: common.ServerId
+    addr: tcp.Address
+
+
+class EventerClientRunner(aio.Resource):
+
+    def __init__(self,
+                 conf: json.Data,
+                 backend: common.Backend,
+                 synced_cb: SyncedCb,
+                 reconnect_delay: float = 5):
+        self._conf = conf
+        self._backend = backend
+        self._synced_cb = synced_cb
+        self._reconnect_delay = reconnect_delay
+        self._async_group = aio.Group()
+        self._remote_active = False
+        self._remote_active_cbs = util.CallbackRegistry()
+        self._valid_server_data = set()
+        self._connecting_server_data = set()
+        self._remote_active_server_data = set()
+
+    @property
+    def async_group(self) -> aio.Group:
+        return self._async_group
+
+    @property
+    def remote_active(self) -> bool:
+        return self._remote_active
+
+    def register_remote_active_cb(self,
+                                  cb: Callable[[bool], None]
+                                  ) -> util.RegisterCallbackHandle:
+        return self._remote_active_cbs.register(cb)
+
+    def set_monitor_state(self, state: hat.monitor.component.State):
+        self._valid_server_data = set(_get_eventer_server_data(
+            group=self._conf['monitor_component']['group'],
+            server_token=self._conf.get('server_token'),
+            state=state))
+
+        for server_data in self._valid_server_data:
+            if server_data in self._connecting_server_data:
+                continue
+
+            self.async_group.spawn(self._client_loop, server_data)
+            self._connecting_server_data.add(server_data)
+
+    async def _client_loop(self, server_data):
+        try:
+            mlog.debug("staring eventer client runner loop")
+            while server_data in self._valid_server_data:
+                self._set_client_status(server_data, None)
+
+                try:
+                    mlog.debug("creating eventer client")
+                    eventer_client = await create_eventer_client(
+                        addr=server_data.addr,
+                        client_name=f"event/{self._conf['name']}",
+                        local_server_id=self._conf['server_id'],
+                        remote_server_id=server_data.server_id,
+                        backend=self._backend,
+                        client_token=self._conf.get('server_token'),
+                        status_cb=functools.partial(self._set_client_status,
+                                                    server_data),
+                        synced_cb=functools.partial(self._synced_cb,
+                                                    server_data.server_id))
+
+                except Exception:
+                    await asyncio.sleep(self._reconnect_delay)
+                    continue
+
+                self._set_client_status(server_data, eventer_client.status)
+
+                try:
+                    await eventer_client.wait_closing()
+
+                finally:
+                    await aio.uncancellable(eventer_client.async_close())
+
+        except Exception as e:
+            mlog.error("eventer client runner loop error: %s", e, exc_info=e)
+            self.close()
+
+        finally:
+            mlog.debug("closing eventer client runner loop")
+            self._connecting_server_data.remove(server_data)
+            self._set_client_status(server_data, None)
+
+    def _set_client_status(self, server_data, status):
+        if status is None or status == common.Status.STANDBY:
+            self._remote_active_server_data.discard(server_data)
+
+        else:
+            self._remote_active_server_data.add(server_data)
+
+        remote_active = bool(self._remote_active_server_data)
+        if remote_active == self._remote_active:
+            return
+
+        self._remote_active = remote_active
+        self._remote_active_cbs.notify(remote_active)
+
+
+def _get_eventer_server_data(group, server_token, state):
+    for info in state.components:
+        if info == state.info or info.group != group:
+            continue
+
+        server_id = json.get(info.data, 'server_id')
+        host = json.get(info.data, ['eventer_server', 'host'])
+        port = json.get(info.data, ['eventer_server', 'port'])
+        token = json.get(info.data, 'server_token')
+        if (not isinstance(server_id, int) or
+                not isinstance(host, str) or
+                not isinstance(port, int) or
+                not isinstance(token, (str, types.NoneType))):
+            continue
+
+        if server_token is not None and token != server_token:
+            continue
+
+        yield EventerServerData(server_id=server_id,
+                                addr=tcp.Address(host, port))

hat/event/server/eventer_server.py

@@ -0,0 +1,119 @@
+"""Eventer server"""
+
+from collections.abc import Collection, Iterable
+import logging
+
+from hat import aio
+from hat.drivers import tcp
+
+from hat.event import common
+from hat.event import eventer
+
+
+mlog: logging.Logger = logging.getLogger(__name__)
+"""Module logger"""
+
+
+async def create_eventer_server(addr: tcp.Address,
+                                backend: common.Backend,
+                                server_id: int,
+                                *,
+                                server_token: str | None = None,
+                                **kwargs
+                                ) -> 'EventerServer':
+    """Create eventer server"""
+    server = EventerServer()
+    server._backend = backend
+    server._server_id = server_id
+    server._server_token = server_token
+    server._engine = None
+
+    server._srv = await eventer.listen(addr,
+                                       connected_cb=server._on_connected,
+                                       disconnected_cb=server._on_disconnected,
+                                       register_cb=server._on_register,
+                                       query_cb=server._on_query,
+                                       **kwargs)
+
+    return server
+
+
+class EventerServer(aio.Resource):
+    """Eventer server
+
+    For creating new server see `create_eventer_server` coroutine.
+
+    """
+
+    @property
+    def async_group(self) -> aio.Group:
+        """Async group"""
+        return self._srv.async_group
+
+    def get_client_names(self) -> Iterable[tuple[common.Source, str]]:
+        """Get client names"""
+        for info in self._srv.get_conn_infos():
+            yield _get_source(info.id), info.client_name
+
+    async def set_status(self,
+                         status: common.Status,
+                         engine: common.Engine | None):
+        """Set status"""
+        if status == common.Status.OPERATIONAL:
+            if not engine:
+                raise ValueError('invalid status/engine')
+
+        else:
+            if engine:
+                raise ValueError('invalid status/engine')
+
+        self._engine = engine
+        await self._srv.set_status(status)
+
+    async def notify_events(self,
+                            events: Collection[common.Event],
+                            persisted: bool,
+                            with_ack: bool = False):
+        """Notify events"""
+        await self._srv.notify_events(events, persisted, with_ack)
+
+    async def _on_connected(self, info):
+        if (info.client_token is not None and
+                info.client_token != self._server_token):
+            raise Exception('invalid client token')
+
+        if not self._engine or not self._engine.is_open:
+            return
+
+        source = _get_source(info.id)
+        register_event = self._create_eventer_event(info, 'CONNECTED')
+        await self._engine.register(source, [register_event])
+
+    async def _on_disconnected(self, info):
+        if not self._engine or not self._engine.is_open:
+            return
+
+        source = _get_source(info.id)
+        register_event = self._create_eventer_event(info, 'DISCONNECTED')
+        await self._engine.register(source, [register_event])
+
+    async def _on_register(self, info, register_events):
+        if not self._engine:
+            return
+
+        source = _get_source(info.id)
+        return await self._engine.register(source, register_events)
+
+    async def _on_query(self, info, params):
+        return await self._backend.query(params)
+
+    def _create_eventer_event(self, info, status):
+        return common.RegisterEvent(
+            type=('event', str(self._server_id), 'eventer', info.client_name),
+            source_timestamp=None,
+            payload=common.EventPayloadJson(status))
+
+
+def _get_source(source_id):
+    return common.Source(type=common.SourceType.EVENTER,
+                         id=source_id)

hat/event/server/main.py

@@ -0,0 +1,84 @@
+"""Event server main"""
+
+from pathlib import Path
+import argparse
+import asyncio
+import contextlib
+import logging.config
+import sys
+
+import appdirs
+
+from hat import aio
+from hat import json
+
+from hat.event import common
+from hat.event.server.main_runner import MainRunner
+
+
+mlog: logging.Logger = logging.getLogger('hat.event.server.main')
+"""Module logger"""
+
+user_conf_dir: Path = Path(appdirs.user_config_dir('hat'))
+"""User configuration directory path"""
+
+
+def create_argument_parser() -> argparse.ArgumentParser:
+    """Create argument parser"""
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        '--conf', metavar='PATH', type=Path, default=None,
+        help="configuration defined by hat-event://server.yaml "
+             "(default $XDG_CONFIG_HOME/hat/event.{yaml|yml|toml|json})")
+    return parser
+
+
+def main():
+    """Event Server"""
+    parser = create_argument_parser()
+    args = parser.parse_args()
+    conf = json.read_conf(args.conf, user_conf_dir / 'event')
+    sync_main(conf)
+
+
+def sync_main(conf: json.Data):
+    """Sync main entry point"""
+    aio.init_asyncio()
+
+    common.json_schema_repo.validate('hat-event://server.yaml', conf)
+
+    info = common.import_backend_info(conf['backend']['module'])
+    if info.json_schema_repo and info.json_schema_id:
+        info.json_schema_repo.validate(info.json_schema_id, conf['backend'])
+
+    for module_conf in conf['modules']:
+        info = common.import_module_info(module_conf['module'])
+        if info.json_schema_repo and info.json_schema_id:
+            info.json_schema_repo.validate(info.json_schema_id, module_conf)
+
+    log_conf = conf.get('log')
+    if log_conf:
+        logging.config.dictConfig(log_conf)
+
+    with contextlib.suppress(asyncio.CancelledError):
+        aio.run_asyncio(async_main(conf))
+
+
+async def async_main(conf: json.Data):
+    """Async main entry point"""
+    main_runner = MainRunner(conf)
+
+    async def cleanup():
+        await main_runner.async_close()
+        await asyncio.sleep(0.1)
+
+    try:
+        await main_runner.wait_closing()
+
+    finally:
+        await aio.uncancellable(cleanup())
+
+
+if __name__ == '__main__':
+    sys.argv[0] = 'hat-event-server'
+    sys.exit(main())