360 lines
9.9 KiB
Python
360 lines
9.9 KiB
Python
'''
|
|
Actor tree daemon sub-service verifications
|
|
|
|
'''
|
|
from typing import (
|
|
AsyncContextManager,
|
|
Callable,
|
|
)
|
|
from contextlib import asynccontextmanager as acm
|
|
from types import SimpleNamespace
|
|
|
|
from exceptiongroup import BaseExceptionGroup
|
|
import pytest
|
|
import trio
|
|
import tractor
|
|
|
|
from piker.service import (
|
|
find_service,
|
|
Services,
|
|
)
|
|
from piker.service import _registry
|
|
from piker.data import (
|
|
open_feed,
|
|
)
|
|
from piker.clearing import (
|
|
open_ems,
|
|
)
|
|
from piker.clearing._messages import (
|
|
BrokerdPosition,
|
|
Status,
|
|
)
|
|
from piker.clearing._client import (
|
|
OrderClient,
|
|
)
|
|
|
|
|
|
def test_runtime_boot(
|
|
open_test_pikerd: AsyncContextManager
|
|
):
|
|
'''
|
|
Verify we can boot the `pikerd` service stack using the
|
|
`open_test_pikerd()` fixture helper and that contact-registry
|
|
address details match up.
|
|
|
|
'''
|
|
async def main():
|
|
port = 6666
|
|
daemon_addr = ('127.0.0.1', port)
|
|
services: Services
|
|
|
|
async with (
|
|
open_test_pikerd(
|
|
reg_addr=daemon_addr,
|
|
) as (_, _, pikerd_portal, services),
|
|
|
|
tractor.wait_for_actor(
|
|
'pikerd',
|
|
registry_addr=daemon_addr,
|
|
) as portal,
|
|
):
|
|
uw_raddr: tuple = pikerd_portal.chan.raddr.unwrap()
|
|
canonical_addr: tuple = (
|
|
_registry._normalize_addresses(
|
|
[daemon_addr],
|
|
)[0]
|
|
)
|
|
assert uw_raddr == canonical_addr
|
|
assert uw_raddr == portal.chan.raddr.unwrap()
|
|
|
|
# no service tasks should be started
|
|
assert not services.service_tasks
|
|
|
|
trio.run(main)
|
|
|
|
|
|
def test_registry_normalizes_tagged_addresses(
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
):
|
|
'''
|
|
Tractor now emits tagged registry addresses while existing Piker
|
|
callers still pass legacy socket pairs. Direct list and set
|
|
comparisons treated the two forms as different and retained the
|
|
legacy value in `Registry.addrs`.
|
|
|
|
Seed `Registry.addrs` with a legacy pair, request the equivalent
|
|
tagged address, and enter `open_registry()` as a root actor. The
|
|
yielded and stored values must both use tractor's canonical form.
|
|
|
|
'''
|
|
legacy = ('127.0.0.1', 6116)
|
|
tagged = ('tcp', '127.0.0.1', 6116)
|
|
actor = SimpleNamespace(
|
|
aid=SimpleNamespace(uid=('test', 'uid')),
|
|
)
|
|
monkeypatch.setattr(
|
|
tractor,
|
|
'current_actor',
|
|
lambda: actor,
|
|
)
|
|
monkeypatch.setattr(
|
|
tractor,
|
|
'is_root_process',
|
|
lambda: True,
|
|
)
|
|
_registry.Registry.addrs = [legacy]
|
|
|
|
async def main():
|
|
async with _registry.open_registry(
|
|
[tagged],
|
|
) as addrs:
|
|
assert addrs == [tagged]
|
|
assert _registry.Registry.addrs == [tagged]
|
|
assert _registry._tractor_kwargs[
|
|
'registry_addrs'
|
|
] == [tagged]
|
|
|
|
try:
|
|
trio.run(main)
|
|
finally:
|
|
_registry.Registry.addrs = []
|
|
|
|
|
|
def test_datad_spawn(
|
|
open_test_pikerd: AsyncContextManager,
|
|
loglevel: str,
|
|
|
|
) -> None:
|
|
'''
|
|
Verify the new (data-feed-only) `datad.<broker>` daemon
|
|
can be spawned/registered as a `pikerd` sub-service via
|
|
the `maybe_spawn_datad()` factory.
|
|
|
|
'''
|
|
from piker.service import maybe_spawn_datad
|
|
|
|
backend: str = 'kraken'
|
|
datad_name: str = f'datad.{backend}'
|
|
|
|
async def main():
|
|
async with (
|
|
open_test_pikerd() as (_, _, _, services),
|
|
|
|
maybe_spawn_datad(
|
|
backend,
|
|
loglevel=loglevel,
|
|
) as portal,
|
|
):
|
|
assert portal
|
|
|
|
async with ensure_service(datad_name):
|
|
assert (
|
|
datad_name in services.service_tasks
|
|
)
|
|
|
|
trio.run(main)
|
|
|
|
|
|
def test_ensure_datafeed_actors(
|
|
open_test_pikerd: AsyncContextManager,
|
|
loglevel: str,
|
|
# cancel_method: str,
|
|
|
|
) -> None:
|
|
'''
|
|
Verify that booting a data feed starts a `datad`
|
|
actor and a singleton global `samplerd` and opening
|
|
an order mode in paper opens the `paperboi` service.
|
|
|
|
'''
|
|
actor_name: str = 'datad'
|
|
backend: str = 'kraken'
|
|
datad_name: str = f'{actor_name}.{backend}'
|
|
|
|
async def main():
|
|
async with (
|
|
open_test_pikerd(),
|
|
|
|
open_feed(
|
|
['xbtusdt.kraken'],
|
|
loglevel=loglevel,
|
|
) as feed
|
|
):
|
|
# halt rt quote streams since we aren't testing them
|
|
await feed.pause()
|
|
|
|
async with (
|
|
ensure_service(datad_name),
|
|
ensure_service('samplerd'),
|
|
):
|
|
await trio.sleep(0.1)
|
|
|
|
trio.run(main)
|
|
|
|
|
|
@acm
|
|
async def ensure_service(
|
|
name: str,
|
|
sockaddr: tuple[str, int] | None = None,
|
|
) -> None:
|
|
async with find_service(name) as portal:
|
|
remote_sockaddr: tuple = portal.chan.raddr.unwrap()
|
|
print(f'FOUND `{name}` @ {remote_sockaddr}')
|
|
|
|
if sockaddr:
|
|
assert remote_sockaddr == sockaddr
|
|
|
|
yield portal
|
|
|
|
|
|
def run_test_w_cancel_method(
|
|
cancel_method: str,
|
|
main: Callable,
|
|
|
|
) -> None:
|
|
'''
|
|
Run our runtime under trio and expect a certain type of cancel condition
|
|
depending on input.
|
|
|
|
'''
|
|
cancelled_msg: str = (
|
|
"was remotely cancelled by remote actor (\'pikerd\'")
|
|
|
|
if cancel_method == 'sigint':
|
|
# XXX: with modern `tractor` the (single-exc)
|
|
# group is collapsed so a bare KBI normally
|
|
# propagates; tolerate either form.
|
|
with pytest.raises((
|
|
KeyboardInterrupt,
|
|
BaseExceptionGroup,
|
|
)) as exc_info:
|
|
trio.run(main)
|
|
|
|
err = exc_info.value
|
|
match err:
|
|
case BaseExceptionGroup():
|
|
for suberr in err.exceptions:
|
|
match suberr:
|
|
# ensure we receive a remote
|
|
# cancellation error caused by the
|
|
# pikerd root actor.
|
|
case tractor.ContextCancelled():
|
|
assert (
|
|
cancelled_msg
|
|
in
|
|
suberr.args[0]
|
|
)
|
|
|
|
case KeyboardInterrupt():
|
|
pass
|
|
|
|
case _:
|
|
pytest.fail(
|
|
f'Unexpected error {suberr}'
|
|
)
|
|
|
|
case KeyboardInterrupt():
|
|
pass
|
|
|
|
elif cancel_method == 'services':
|
|
# XXX: cancelling our own sub-service via
|
|
# `Services.cancel_service()` is a *self*
|
|
# requested cancel: modern `tractor` absorbs the
|
|
# resulting `ContextCancelled` (canceller is our
|
|
# own actor) so the runtime tears down gracefully
|
|
# with NO error raised to the opener.
|
|
trio.run(main)
|
|
|
|
else:
|
|
pytest.fail(f'Test is broken due to {cancel_method}')
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
'cancel_method',
|
|
['services', 'sigint'],
|
|
)
|
|
def test_ensure_ems_in_paper_actors(
|
|
open_test_pikerd: AsyncContextManager,
|
|
loglevel: str,
|
|
|
|
cancel_method: str,
|
|
|
|
) -> None:
|
|
|
|
backend: str = 'kraken'
|
|
datad_name: str = f'datad.{backend}'
|
|
brokerd_name: str = f'brokerd.{backend}'
|
|
|
|
async def main():
|
|
|
|
# type declares
|
|
client: OrderClient
|
|
pps: dict[str, list[BrokerdPosition]]
|
|
accounts: list[str]
|
|
dialogs: dict[str, Status]
|
|
|
|
# ensure we timeout after is startup is too slow.
|
|
# TODO: something like this should be our start point for
|
|
# benchmarking end-to-end startup B)
|
|
# NOTE: includes a live (kraken) symbology fetch so
|
|
# the budget needs some headroom for net latency..
|
|
with trio.fail_after(19):
|
|
async with (
|
|
open_test_pikerd() as (_, _, _, services),
|
|
|
|
open_ems(
|
|
'xbtusdt.kraken',
|
|
mode='paper',
|
|
loglevel=loglevel,
|
|
) as (
|
|
client,
|
|
_, # trades_stream: tractor.MsgStream
|
|
pps,
|
|
accounts,
|
|
dialogs,
|
|
),
|
|
):
|
|
# there should be no on-going positions,
|
|
# TODO: though eventually we'll want to validate against
|
|
# local ledger and `pps.toml` state ;)
|
|
assert not pps
|
|
assert not dialogs
|
|
# XXX: should be new client with no state from other tests
|
|
assert not client._sent_orders
|
|
assert accounts
|
|
|
|
pikerd_subservices = ['emsd', 'samplerd']
|
|
|
|
async with (
|
|
ensure_service('emsd'),
|
|
ensure_service(datad_name),
|
|
ensure_service(f'paperboi.{backend}'),
|
|
):
|
|
for name in pikerd_subservices:
|
|
assert name in services.service_tasks
|
|
|
|
# datad.kraken actor should have been
|
|
# started implicitly by the feed layer.
|
|
assert datad_name in services.service_tasks
|
|
|
|
# XXX: paper-mode sessions should NEVER
|
|
# boot a (live, credentialed) `brokerd`;
|
|
# only emsd's `open_brokerd_dialog()`
|
|
# live-ep path is allowed to spawn it!
|
|
assert (
|
|
brokerd_name
|
|
not in
|
|
services.service_tasks
|
|
)
|
|
|
|
print('ALL SERVICES STARTED, cancelling runtime with:\n'
|
|
f'-> {cancel_method}')
|
|
|
|
if cancel_method == 'services':
|
|
await services.cancel_service('emsd')
|
|
|
|
elif cancel_method == 'sigint':
|
|
raise KeyboardInterrupt
|
|
|
|
run_test_w_cancel_method(cancel_method, main)
|