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

hat/event/common/subscription/common.py

@@ -0,0 +1,145 @@
+from collections.abc import Iterable
+import abc
+import itertools
+import typing
+
+from hat.event.common.common import EventTypeSegment, EventType
+
+
+class Subscription(abc.ABC):
+    """Subscription defined by query event types"""
+
+    @abc.abstractmethod
+    def __init__(self, query_types: Iterable[EventType]):
+        """Create subscription instance"""
+
+    @abc.abstractmethod
+    def get_query_types(self) -> Iterable[EventType]:
+        """Calculate sanitized query event types"""
+
+    @abc.abstractmethod
+    def matches(self, event_type: EventType) -> bool:
+        """Does `event_type` match subscription"""
+
+    @abc.abstractmethod
+    def union(self, *others: 'Subscription') -> 'Subscription':
+        """Create new subscription including event types from this and
+        other subscriptions."""
+
+    @abc.abstractmethod
+    def intersection(self, *others: 'Subscription') -> 'Subscription':
+        """Create new subscription containing event types in common with
+        other subscriptions."""
+
+    @abc.abstractmethod
+    def isdisjoint(self, other: 'Subscription') -> bool:
+        """Return ``True`` if this subscription has no event types in common
+        with other subscription."""
+
+
+class Node(typing.NamedTuple):
+    """Subscription tree node"""
+    is_leaf: bool
+    children: typing.Dict[EventTypeSegment, 'Node']
+
+
+def node_from_query_types(query_types: Iterable[EventType]) -> Node:
+    node = Node(False, {})
+
+    for query_type in query_types:
+        node = _add_query_type(node, query_type)
+
+    return node
+
+
+def node_to_query_types(node: Node) -> Iterable[EventType]:
+    is_leaf, children = node
+
+    if is_leaf and '*' not in children:
+        yield ()
+
+    for head, child in children.items():
+        for rest in node_to_query_types(child):
+            yield (head, *rest)
+
+
+def union(first: Node, second: Node) -> Node:
+    is_leaf = first.is_leaf or second.is_leaf
+
+    if '*' in first.children or '*' in second.children:
+        return Node(is_leaf, {'*': (True, {})})
+
+    children = {}
+
+    for name, child in itertools.chain(first.children.items(),
+                                       second.children.items()):
+        prev_child = children.get(name)
+        children[name] = union(prev_child, child) if prev_child else child
+
+    return Node(is_leaf, children)
+
+
+def intersection(first: Node, second: Node) -> Node:
+    is_leaf = first.is_leaf and second.is_leaf
+
+    if '*' in first.children:
+        children = second.children
+
+    elif '*' in second.children:
+        children = first.children
+
+    else:
+        children = {}
+
+        for name, child, other_children in itertools.chain(
+                ((name, child, second.children)
+                 for name, child in first.children.items()),
+                ((name, child, first.children)
+                 for name, child in second.children.items())):
+
+            if name == '?':
+                candidates = other_children
+
+            else:
+                candidates = {}
+                other_child = other_children.get(name)
+                if other_child:
+                    candidates[name] = other_child
+                other_child = other_children.get('?')
+                if other_child:
+                    candidates['?'] = other_child
+
+            for other_name, other_child in candidates.items():
+                result_name = name if name != '?' else other_name
+                result_children = intersection(child, other_child)
+                prev_result_children = children.get(result_name)
+                children[result_name] = (
+                    union(prev_result_children, result_children)
+                    if prev_result_children else result_children)
+
+    return Node(is_leaf, children)
+
+
+def _add_query_type(node, query_type):
+    is_leaf, children = node
+
+    if '*' in children:
+        return node
+
+    if not query_type:
+        return Node(True, children)
+
+    head, rest = query_type[0], query_type[1:]
+
+    if head == '*':
+        if rest:
+            raise ValueError('invalid query event type')
+        children.clear()
+        children['*'] = Node(True, {})
+
+    else:
+        child = children.get(head) or Node(False, {})
+        child = _add_query_type(child, rest)
+        children[head] = child
+
+    return node

hat/event/common/subscription/csubscription.py

@@ -0,0 +1,47 @@
+from hat.event.common.subscription import common
+
+from hat.event.common.subscription import _csubscription
+
+
+class CSubscription(common.Subscription):
+    """C implementation of Subscription"""
+
+    def __init__(self, query_types):
+        self._subscription = _csubscription.Subscription(query_types)
+
+    def get_query_types(self):
+        return self._subscription.get_query_types()
+
+    def matches(self, event_type):
+        return self._subscription.matches(event_type)
+
+    def union(self, *others):
+        node = common.node_from_query_types(
+            self._subscription.get_query_types())
+
+        for other in others:
+            other_node = common.node_from_query_types(other.get_query_types())
+            node = common.union(node, other_node)
+
+        return CSubscription(common.node_to_query_types(node))
+
+    def intersection(self, *others):
+        node = common.node_from_query_types(
+            self._subscription.get_query_types())
+
+        for other in others:
+            other_node = common.node_from_query_types(other.get_query_types())
+            node = common.intersection(node, other_node)
+
+        return CSubscription(common.node_to_query_types(node))
+
+    def isdisjoint(self, other):
+        other_subscription = _get_other_subscription(other)
+        return self._subscription.isdisjoint(other_subscription)
+
+
+def _get_other_subscription(other):
+    if isinstance(other, CSubscription):
+        return other._subscription
+
+    return CSubscription(other.get_query_types())._subscription

hat/event/common/subscription/pysubscription.py

@@ -0,0 +1,97 @@
+from hat.event.common.subscription import common
+
+
+class PySubscription(common.Subscription):
+    """Python implementation of Subscription"""
+
+    def __init__(self, query_types):
+        self._root = common.node_from_query_types(query_types)
+
+    def get_query_types(self):
+        return common.node_to_query_types(self._root)
+
+    def matches(self, event_type):
+        return _matches(self._root, event_type, 0)
+
+    def union(self, *others):
+        node = self._root
+
+        for other in others:
+            other_node = _get_other_node(other)
+            node = common.union(node, other_node)
+
+        result = PySubscription([])
+        result._root = node
+        return result
+
+    def intersection(self, *others):
+        node = self._root
+
+        for other in others:
+            other_node = _get_other_node(other)
+            node = common.intersection(node, other_node)
+
+        result = PySubscription([])
+        result._root = node
+        return result
+
+    def isdisjoint(self, other):
+        other_node = _get_other_node(other)
+        return _isdisjoint(self._root, other_node)
+
+
+def _get_other_node(other):
+    if isinstance(other, PySubscription):
+        return other._root
+
+    return common.node_from_query_types(other.get_query_types())
+
+
+def _matches(node, event_type, event_type_index):
+    is_leaf, children = node
+
+    if '*' in children:
+        return True
+
+    if event_type_index >= len(event_type):
+        return is_leaf
+
+    child = children.get(event_type[event_type_index])
+    if child and _matches(child, event_type, event_type_index + 1):
+        return True
+
+    child = children.get('?')
+    if child and _matches(child, event_type, event_type_index + 1):
+        return True
+
+    return False
+
+
+def _isdisjoint(first, second):
+    if first.is_leaf and second.is_leaf:
+        return False
+
+    if (('*' in first.children and (second.children or second.is_leaf)) or
+            ('*' in second.children and (first.children or first.is_leaf))):
+        return False
+
+    if '?' in first.children:
+        for child in second.children.values():
+            if not _isdisjoint(first.children['?'], child):
+                return False
+
+    if '?' in second.children:
+        for name, child in first.children.items():
+            if name == '?':
+                continue
+            if not _isdisjoint(second.children['?'], child):
+                return False
+
+    names = set(first.children.keys()).intersection(second.children.keys())
+    for name in names:
+        if name == '?':
+            continue
+        if not _isdisjoint(first.children[name], second.children[name]):
+            return False
+
+    return True

hat/event/component.py

@@ -0,0 +1,284 @@
+"""Eventer Component"""
+
+from collections.abc import Collection
+import asyncio
+import contextlib
+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
+import hat.event.eventer.client
+
+
+mlog: logging.Logger = logging.getLogger(__name__)
+"""Module logger"""
+
+State: typing.TypeAlias = hat.monitor.component.State
+"""Component state"""
+
+Runner: typing.TypeAlias = aio.Resource
+"""Component runner"""
+
+RunnerCb: typing.TypeAlias = aio.AsyncCallable[
+    ['Component', 'ServerData', hat.event.eventer.client.Client],
+    Runner]
+"""Runner callback"""
+
+StateCb: typing.TypeAlias = aio.AsyncCallable[['Component', State], None]
+"""State callback"""
+
+CloseReqCb: typing.TypeAlias = aio.AsyncCallable[['Component'], None]
+"""Close request callback"""
+
+StatusCb: typing.TypeAlias = aio.AsyncCallable[
+    ['Component', hat.event.eventer.client.Client, common.Status],
+    None]
+"""Status callback"""
+
+EventsCb: typing.TypeAlias = aio.AsyncCallable[
+    ['Component', hat.event.eventer.client.Client, Collection[common.Event]],
+    None]
+"""Events callback"""
+
+
+class ServerData(typing.NamedTuple):
+    """Server data"""
+    server_id: common.ServerId
+    addr: tcp.Address
+    server_token: str | None
+
+
+async def connect(addr: tcp.Address,
+                  name: str,
+                  group: str,
+                  server_group: str,
+                  client_name: str,
+                  runner_cb: RunnerCb,
+                  *,
+                  state_cb: StateCb | None = None,
+                  close_req_cb: CloseReqCb | None = None,
+                  status_cb: StatusCb | None = None,
+                  events_cb: EventsCb | None = None,
+                  server_data_queue_size: int = 1024,
+                  reconnect_delay: float = 0.5,
+                  observer_kwargs: dict[str, typing.Any] = {},
+                  eventer_kwargs: dict[str, typing.Any] = {}
+                  ) -> 'Component':
+    """Connect to local monitor server and create component
+
+    High-level interface for communication with Event Server, based on
+    information obtained from Monitor Server.
+
+    Component instance tries to establish active connection with
+    Event Server within monitor component group `server_group`. Once this
+    connection is established, `runner_cb` is called with currently active
+    eventer client instance. Result of calling `runner_cb` should be runner
+    representing user defined components activity associated with connection
+    to active Event Server. Once connection to Event Server is closed or new
+    active Event Server is detected, associated runner is closed. If new
+    connection to Event Server is successfully established,
+    `component_cb` will be called again to create new runner associated with
+    new instance of eventer client.
+
+    If runner is closed while connection to Event Server is open, component
+    is closed.
+
+    """
+    component = Component()
+    component._server_group = server_group
+    component._client_name = client_name
+    component._runner_cb = runner_cb
+    component._state_cb = state_cb
+    component._close_req_cb = close_req_cb
+    component._status_cb = status_cb
+    component._events_cb = events_cb
+    component._server_data_queue_size = server_data_queue_size
+    component._reconnect_delay = reconnect_delay
+    component._eventer_kwargs = eventer_kwargs
+    component._server_data = None
+    component._server_data_queue = None
+
+    component._monitor_component = await hat.monitor.component.connect(
+        addr=addr,
+        name=name,
+        group=group,
+        runner_cb=component._create_monitor_runner,
+        **{**observer_kwargs,
+           'state_cb': component._on_state,
+           'close_req_cb': component._on_close_req})
+
+    return component
+
+
+class Component(aio.Resource):
+    """Eventer Component"""
+
+    @property
+    def async_group(self):
+        return self._monitor_component.async_group
+
+    @property
+    def state(self) -> State:
+        """State"""
+        return self._monitor_component.state
+
+    @property
+    def ready(self) -> bool:
+        """Ready"""
+        return self._monitor_component.ready
+
+    async def set_ready(self, ready: bool):
+        """Set ready"""
+        await self._monitor_component.set_ready(ready)
+
+    async def _on_state(self, monitor_component, state):
+        if self._server_data_queue is not None:
+            data = self._get_active_server_data(state)
+
+            if data != self._server_data:
+                self._server_data = data
+
+                with contextlib.suppress(aio.QueueClosedError):
+                    await self._server_data_queue.put(data)
+
+        if self._state_cb:
+            await aio.call(self._state_cb, self, state)
+
+    async def _on_close_req(self, monitor_component):
+        if self._close_req_cb:
+            await aio.call(self._close_req_cb, self)
+
+    async def _on_status(self, eventer_client, status):
+        if self._status_cb:
+            await aio.call(self._status_cb, self, eventer_client, status)
+
+    async def _on_events(self, eventer_client, events):
+        if self._events_cb:
+            await aio.call(self._events_cb, self, eventer_client, events)
+
+    def _create_monitor_runner(self, monitor_component):
+        self._server_data = self._get_active_server_data(
+            monitor_component.state)
+        self._server_data_queue = aio.Queue(self._server_data_queue_size)
+
+        if self._server_data:
+            self._server_data_queue.put_nowait(self._server_data)
+
+        runner = aio.Group()
+        runner.spawn(self._server_data_loop, runner, self._server_data_queue)
+
+        return runner
+
+    def _get_active_server_data(self, state):
+        info = util.first(state.components, self._active_server_filter)
+        if not info:
+            return
+
+        server_id = json.get(info.data, 'server_id')
+        host = json.get(info.data, ['eventer_server', 'host'])
+        port = json.get(info.data, ['eventer_server', 'port'])
+        server_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(server_token, (str, types.NoneType))):
+            return
+
+        client_token = self._eventer_kwargs.get('client_token')
+        if client_token is not None and client_token != server_token:
+            return
+
+        return ServerData(server_id=server_id,
+                          addr=tcp.Address(host, port),
+                          server_token=server_token)
+
+    def _active_server_filter(self, info):
+        return (info.group == self._server_group and
+                info.blessing_req.token is not None and
+                info.blessing_req.token == info.blessing_res.token)
+
+    async def _server_data_loop(self, async_group, server_data_queue):
+        try:
+            server_data = None
+            while True:
+                while not server_data or not server_data_queue.empty():
+                    server_data = await server_data_queue.get_until_empty()
+
+                async with async_group.create_subgroup() as subgroup:
+                    subgroup.spawn(self._client_loop, subgroup, server_data)
+                    server_data = await server_data_queue.get_until_empty()
+
+        except Exception as e:
+            mlog.error("address loop error: %s", e, exc_info=e)
+            self.close()
+
+        finally:
+            async_group.close()
+            server_data_queue.close()
+
+    async def _client_loop(self, async_group, server_data):
+        try:
+            while True:
+                try:
+                    kwargs = {**self._eventer_kwargs,
+                              'status_cb': self._on_status,
+                              'events_cb': self._on_events}
+
+                    if 'server_id' not in kwargs:
+                        kwargs['server_id'] = server_data.server_id
+
+                    mlog.debug("connecting to server %s", server_data.addr)
+                    client = await hat.event.eventer.client.connect(
+                        addr=server_data.addr,
+                        client_name=self._client_name,
+                        **kwargs)
+
+                except Exception as e:
+                    mlog.warning("error connecting to server: %s", e,
+                                 exc_info=e)
+                    await asyncio.sleep(self._reconnect_delay)
+                    continue
+
+                try:
+                    mlog.debug("connected to server")
+                    runner = await client.async_group.spawn(
+                        aio.call, self._runner_cb, self, server_data, client)
+
+                    try:
+                        async with async_group.create_subgroup() as subgroup:
+                            client_closing_task = subgroup.spawn(
+                                client.wait_closing)
+                            runner_closing_task = subgroup.spawn(
+                                runner.wait_closing)
+
+                            await asyncio.wait(
+                                [client_closing_task, runner_closing_task],
+                                return_when=asyncio.FIRST_COMPLETED)
+
+                            if (runner_closing_task.done() and
+                                    not client_closing_task.done()):
+                                self.close()
+                                return
+
+                    finally:
+                        await aio.uncancellable(runner.async_close())
+
+                finally:
+                    await aio.uncancellable(client.async_close())
+
+                mlog.debug("connection to server closed")
+                await asyncio.sleep(self._reconnect_delay)
+
+        except Exception as e:
+            mlog.error("client loop error: %s", e, exc_info=e)
+            self.close()
+
+        finally:
+            async_group.close()

hat/event/eventer/__init__.py

@@ -0,0 +1,28 @@
+"""Eventer communication protocol"""
+
+from hat.event.eventer.client import (StatusCb,
+                                      EventsCb,
+                                      EventerInitError,
+                                      connect,
+                                      Client)
+from hat.event.eventer.server import (ConnectionId,
+                                      ConnectionInfo,
+                                      ConnectionCb,
+                                      RegisterCb,
+                                      QueryCb,
+                                      listen,
+                                      Server)
+
+
+__all__ = ['StatusCb',
+           'EventsCb',
+           'EventerInitError',
+           'connect',
+           'Client',
+           'ConnectionId',
+           'ConnectionInfo',
+           'ConnectionCb',
+           'RegisterCb',
+           'QueryCb',
+           'listen',
+           'Server']