async def test_create_process_event():
server_id = 123
source = common.Source(common.SourceType.MODULE, None, 321)
register_events = [
common.RegisterEvent(event_type=(str(i), ),
source_timestamp=common.now(),
payload=None) for i in range(10)
]
conf = {'modules': []}
backend = BackendEngine(server_id=server_id)
engine = await hat.event.server.module_engine.create(conf, backend)
event_ids = set()
for register_event in register_events:
process_event = engine.create_process_event(source, register_event)
assert process_event.event_type == register_event.event_type
assert (
process_event.source_timestamp == register_event.source_timestamp)
assert process_event.payload == register_event.payload
assert process_event.source == source
assert process_event.event_id.server == 123
assert process_event.event_id not in event_ids
event_ids.add(process_event.event_id)
await engine.async_close()
await backend.async_close()
def __init__(self, conn, engine, source_id):
self._conn = conn
self._engine = engine
self._subscription = None
self._source = common.Source(type=common.SourceType.COMMUNICATION,
name=None,
id=source_id)
self.async_group.spawn(self._connection_loop)
def _process_register_request(self, msg, conn):
proc_events = [
self._engine.create_process_event(
source=common.Source(type=common.SourceType.COMMUNICATION,
id=self._connection_ids[conn]),
event=common.register_event_from_sbs(i)) for i in msg.data.data
]
self._async_group.spawn(self._register_request_response, proc_events,
conn, msg)
async def test_cancel_register(create_module):
process_enter_future = asyncio.Future()
process_exit_future = asyncio.Future()
async def process(events):
process_enter_future.set_result(None)
await process_exit_future
return []
source = common.Source(common.SourceType.MODULE, None, 1)
module_name = create_module(process)
conf = {'modules': [{'module': module_name}]}
backend = BackendEngine()
engine = await hat.event.server.module_engine.create(conf, backend)
registered_events = aio.Queue()
engine.register_events_cb(registered_events.put_nowait)
source = common.Source(common.SourceType.COMMUNICATION, None, 0)
register_future = asyncio.ensure_future(
engine.register(source, [
common.RegisterEvent(
event_type=(), source_timestamp=None, payload=None)
]))
await process_enter_future
register_future.cancel()
process_exit_future.set_result(None)
assert registered_events.empty()
await asyncio.wait_for(registered_events.get(), 0.01)
assert engine.is_open
await engine.async_close()
async def test_register(backend_module_name, create_backend_module):
conf = {'server_id': 123, 'backend': {'module': backend_module_name}}
event_ids = [common.EventId(conf['server_id'], i) for i in range(10)]
process_events = [
common.ProcessEvent(event_id=event_id,
source=common.Source(common.SourceType.MODULE,
'abc', 1),
event_type=[],
source_timestamp=common.now(),
payload=None) for event_id in event_ids
]
def register(events):
return events
with create_backend_module(register_cb=register):
engine = await hat.event.server.backend_engine.create(conf)
events = await engine.register(process_events)
assert [i.event_id for i in events] == event_ids
await engine.async_close()
async def test_register(create_module, module_count, value):
backend_events = asyncio.Future()
engine_events = asyncio.Future()
def on_backend_events(events):
backend_events.set_result(events)
return events
def on_engine_events(events):
engine_events.set_result(events)
def process(source, events):
for event in events:
if event.source.type == common.SourceType.MODULE:
if event.source != source:
continue
if not event.payload.data:
continue
yield engine.create_process_event(
source,
common.RegisterEvent(event_type=event.event_type,
source_timestamp=None,
payload=event.payload._replace(
data=event.payload.data - 1)))
def get_values(events):
return [event.payload.data for event in events]
sources = [
common.Source(common.SourceType.MODULE, None, i)
for i in range(module_count)
]
module_names = [
create_module(functools.partial(process, source)) for source in sources
]
conf = {
'modules': [{
'module': module_name
} for module_name in module_names]
}
backend = BackendEngine(register_cb=on_backend_events)
engine = await hat.event.server.module_engine.create(conf, backend)
engine.register_events_cb(on_engine_events)
source = common.Source(common.SourceType.COMMUNICATION, None, 0)
result = await engine.register(source, [
common.RegisterEvent(event_type=(),
source_timestamp=None,
payload=common.EventPayload(
common.EventPayloadType.JSON, value))
])
backend_events = backend_events.result()
engine_events = engine_events.result()
values = [value]
if module_count:
while (last := values[-1]):
values.extend([last - 1] * module_count)