moat-kv 0.70.24__py3-none-any.whl → 0.71.6__py3-none-any.whl

build/lib/moat/kv/mock/__init__.py

@@ -1,101 +0,0 @@
-# from asyncclick.testing import CliRunner
-from __future__ import annotations
-import io
-import logging
-import shlex
-import socket
-import sys
-from pathlib import Path
-
-import attr
-from asyncscope import main_scope, scope
-from moat.src.test import run  # pylint:disable=import-error,no-name-in-module
-from moat.util import (  # pylint:disable=no-name-in-module
-    CFG,
-    OptCtx,
-    attrdict,
-    combine_dict,
-    ensure_cfg,
-    list_ext,
-    load_ext,
-    wrap_main,
-    yload,
-)
-
-from moat.kv.client import _scoped_client, client_scope
-
-logger = logging.getLogger(__name__)
-try:
-    from contextlib import asynccontextmanager
-except ImportError:
-    from async_generator import asynccontextmanager
-
-ensure_cfg("moat.kv")
-
-
-@attr.s
-class S:
-    tg = attr.ib()
-    client_ctx = attr.ib()
-    s = attr.ib(factory=list)  # servers
-    c = attr.ib(factory=list)  # clients
-    _seq = 1
-
-    async def ready(self, i=None):
-        if i is not None:
-            await self.s[i].is_ready
-            return self.s[i]
-        for s in self.s:
-            if s is not None:
-                await s.is_ready
-        return self.s
-
-    def __iter__(self):
-        return iter(self.s)
-
-    @asynccontextmanager
-    async def client(self, i: int = 0, **kv):
-        """Get a (new) client for the i'th server."""
-        await self.s[i].is_serving
-        self._seq += 1
-        for host, port, *_ in self.s[i].ports:
-            if host != "::" and host[0] == ":":
-                continue
-            try:
-                cfg = combine_dict(
-                    dict(conn=dict(host=host, port=port, ssl=self.client_ctx, **kv)),
-                    CFG["kv"],
-                )
-
-                async def scc(s, **cfg):
-                    scope.requires(s._scope)
-                    return await _scoped_client(scope.name, **cfg)
-
-                async with scope.using_scope():
-                    c = await scope.service(
-                        f"moat.kv.client.{i}.{self._seq}",
-                        scc,
-                        self.s[i],
-                        **cfg,
-                    )
-                    yield c
-                return
-            except socket.gaierror:
-                pass
-        raise RuntimeError("Duh? no connection")
-
-    async def run(self, *args, do_stdout=True):
-        h = p = None
-        for s in self.s:
-            for h, p, *_ in s.ports:
-                if h[0] != ":":
-                    break
-            else:
-                continue
-            break
-        if len(args) == 1:
-            args = args[0]
-            if isinstance(args, str):
-                args = args.split(" ")
-        async with scope.using_scope():
-            return await run("-VV", "kv", "-h", h, "-p", p, *args, do_stdout=do_stdout)

build/lib/moat/kv/mock/mqtt.py

@@ -1,159 +0,0 @@
-from __future__ import annotations
-import copy
-import logging
-import os
-import time
-from contextlib import AsyncExitStack, asynccontextmanager
-from functools import partial
-
-import anyio
-from unittest import mock
-import trio
-from asyncscope import main_scope, scope
-from moat.mqtt.broker import create_broker
-from moat.util import NotGiven, attrdict, combine_dict
-
-from moat.kv.mock import S
-from moat.kv.server import Server
-
-from . import CFG
-
-logger = logging.getLogger(__name__)
-
-otm = time.time
-
-PORT = 40000 + (os.getpid() + 10) % 10000
-
-broker_cfg = {
-    "listeners": {"default": {"type": "tcp", "bind": f"127.0.0.1:{PORT}"}},
-    "timeout-disconnect-delay": 2,
-    "auth": {"allow-anonymous": True, "password-file": None},
-}
-
-URI = f"mqtt://127.0.0.1:{PORT}/"
-
-
-@asynccontextmanager
-async def stdtest(n=1, run=True, ssl=False, tocks=20, **kw):
-    C_OUT = CFG.get("_stdout", NotGiven)
-    if C_OUT is not NotGiven:
-        del CFG["_stdout"]
-    TESTCFG = copy.deepcopy(CFG["kv"])
-    TESTCFG.server.port = None
-    TESTCFG.root = "test"
-    if C_OUT is not NotGiven:
-        CFG["_stdout"] = C_OUT
-        TESTCFG["_stdout"] = C_OUT
-
-    if ssl:
-        import ssl
-
-        import trustme
-
-        ca = trustme.CA()
-        cert = ca.issue_server_cert("127.0.0.1")
-        server_ctx = ssl.create_default_context(purpose=ssl.Purpose.CLIENT_AUTH)
-        client_ctx = ssl.create_default_context(purpose=ssl.Purpose.SERVER_AUTH)
-        ca.configure_trust(client_ctx)
-        cert.configure_cert(server_ctx)
-    else:
-        server_ctx = client_ctx = False
-
-    clock = trio.lowlevel.current_clock()
-    try:
-        clock.autojump_threshold = 0.02  # networking
-    except Exception:
-        pass  # test doesn't have autojump_clock fixture
-
-    async def mock_get_host_port(st, host):
-        i = int(host[host.rindex("_") + 1 :])
-        s = st.s[i]
-        await s.is_serving
-        for host, port, *_ in s.ports:
-            if host == "::" or host[0] != ":":
-                return host, port
-
-    def tm():
-        try:
-            return trio.current_time()
-        except RuntimeError:
-            return otm()
-
-    async def mock_set_tock(self, old):
-        assert self._tock < tocks, "Test didn't terminate. Limit:" + str(tocks)
-        await old()
-
-    done = False
-    async with main_scope("moat.kv.test.mqtt") as scp:
-        tg = scp._tg
-        st = S(tg, client_ctx)
-        async with AsyncExitStack() as ex:
-            st.ex = ex  # pylint: disable=attribute-defined-outside-init
-            ex.enter_context(mock.patch("time.time", new=tm))
-            ex.enter_context(mock.patch("time.monotonic", new=tm))
-            logging._startTime = tm()
-
-            async def run_broker(cfg):
-                async with create_broker(config=cfg) as srv:
-                    # NB: some services use "async with await …"
-                    scope.register(srv)
-                    await scope.no_more_dependents()
-
-            async def with_broker(s, *a, **k):
-                await scope.service("moat.mqtt.broker", run_broker, broker_cfg)
-                s._scope = scope.get()
-                return await s._scoped_serve(*a, **k)
-
-            args_def = kw.get("args", attrdict())
-            for i in range(n):
-                name = "test_" + str(i)
-                args = kw.get(name, args_def)
-                args = combine_dict(
-                    args,
-                    args_def,
-                    {
-                        "cfg": {
-                            "conn": {"ssl": client_ctx},
-                            "server": {
-                                "bind_default": {
-                                    "host": "127.0.0.1",
-                                    "port": i + PORT + 1,
-                                    "ssl": server_ctx,
-                                },
-                                "backend": "mqtt",
-                                "mqtt": {"uri": URI},
-                            },
-                        },
-                    },
-                    {"cfg": TESTCFG},
-                )
-                args_def.pop("init", None)
-                s = Server(name, **args)
-                ex.enter_context(
-                    mock.patch.object(s, "_set_tock", new=partial(mock_set_tock, s, s._set_tock)),
-                )
-                ex.enter_context(
-                    mock.patch.object(s, "_get_host_port", new=partial(mock_get_host_port, st)),
-                )
-                st.s.append(s)
-
-            evts = []
-            for i in range(n):
-                if kw.get(f"run_{i}", run):
-                    evt = anyio.Event()
-                    await scp.spawn_service(with_broker, st.s[i], ready_evt=evt)
-                    evts.append(evt)
-                else:
-                    setattr(st, f"run_{i}", partial(scp.spawn_service, with_broker, st.s[i]))
-
-            for e in evts:
-                await e.wait()
-            try:
-                done = True
-                yield st
-            finally:
-                with anyio.fail_after(2, shield=True):
-                    logger.info("Runtime: %s", clock.current_time())
-                    tg.cancel_scope.cancel()
-    if not done:
-        yield None

build/lib/moat/kv/mock/serf.py

@@ -1,250 +0,0 @@
-from __future__ import annotations
-import copy
-import logging
-import time
-from contextlib import AsyncExitStack, asynccontextmanager
-from functools import partial
-
-import anyio
-import attr
-from unittest import mock
-import trio
-from asyncscope import main_scope, scope
-from asyncserf.stream import SerfEvent
-from moat.util import NotGiven, ValueEvent, attrdict, combine_dict, create_queue
-
-from moat.kv.codec import unpacker
-from moat.kv.mock import S as _S
-from moat.kv.server import Server
-
-logger = logging.getLogger(__name__)
-
-otm = time.time
-
-from . import CFG
-
-
-@asynccontextmanager
-async def stdtest(n=1, run=True, ssl=False, tocks=20, **kw):
-    C_OUT = CFG.get("_stdout", NotGiven)
-    if C_OUT is not NotGiven:
-        del CFG["_stdout"]
-    TESTCFG = copy.deepcopy(CFG["kv"])
-    TESTCFG.server.port = None
-    TESTCFG.server.backend = "serf"
-    TESTCFG.root = "test"
-    if C_OUT is not NotGiven:
-        CFG["_stdout"] = C_OUT
-        TESTCFG["_stdout"] = C_OUT
-
-    if ssl:
-        import ssl
-
-        import trustme
-
-        ca = trustme.CA()
-        cert = ca.issue_server_cert("127.0.0.1")
-        server_ctx = ssl.create_default_context(purpose=ssl.Purpose.CLIENT_AUTH)
-        client_ctx = ssl.create_default_context(purpose=ssl.Purpose.SERVER_AUTH)
-        ca.configure_trust(client_ctx)
-        cert.configure_cert(server_ctx)
-    else:
-        server_ctx = client_ctx = False
-
-    clock = trio.lowlevel.current_clock()
-    clock.autojump_threshold = 0.0
-    # clock.rate = 5
-
-    @attr.s
-    class S(_S):
-        splits = attr.ib(factory=set)
-        serfs = attr.ib(factory=set)
-
-        def split(self, s):
-            assert s not in self.splits
-            logger.debug("Split: add %d", s)
-            self.splits.add(s)
-
-        def join(self, s):
-            logger.debug("Split: join %d", s)
-            self.splits.remove(s)
-
-    async def mock_get_host_port(st, host):
-        i = int(host[host.rindex("_") + 1 :])
-        s = st.s[i]
-        await s.is_serving
-        for host, port, *_ in s.ports:
-            if host == "::" or host[0] != ":":
-                return host, port
-
-    def tm():
-        try:
-            return trio.current_time()
-        except RuntimeError:
-            return otm()
-
-    async def mock_set_tock(self, old):
-        assert self._tock < tocks, "Test didn't terminate. Limit:" + str(tocks)
-        await old()
-
-    async with main_scope("moat.kv.test.serf") as scp:
-        tg = scp._tg
-        st = S(tg, client_ctx)
-        async with AsyncExitStack() as ex:
-            st.ex = ex  # pylint: disable=attribute-defined-outside-init
-            ex.enter_context(mock.patch("time.time", new=tm))
-            ex.enter_context(mock.patch("time.monotonic", new=tm))
-            logging._startTime = tm()
-
-            ex.enter_context(
-                mock.patch("asyncserf.serf_client", new=partial(mock_serf_client, st)),
-            )
-
-            for i in range(n):
-                name = "test_" + str(i)
-                args = kw.get(name, kw.get("args", attrdict()))
-                args["cfg"] = combine_dict(
-                    args.get("cfg", {}),
-                    {
-                        "kv": {
-                            "conn": {"ssl": client_ctx},
-                        },
-                        "server": {
-                            "bind_default": {
-                                "host": "127.0.0.1",
-                                "port": i + 50120,
-                                "ssl": server_ctx,
-                            },
-                            "serf": {"i": i},
-                        },
-                    },
-                    TESTCFG,
-                )
-                s = Server(name, **args)
-                ex.enter_context(
-                    mock.patch.object(s, "_set_tock", new=partial(mock_set_tock, s, s._set_tock)),
-                )
-                ex.enter_context(
-                    mock.patch.object(s, "_get_host_port", new=partial(mock_get_host_port, st)),
-                )
-                st.s.append(s)
-
-            async def with_serf(s, *a, **k):
-                s._scope = scope.get()
-                return await s._scoped_serve(*a, **k)
-
-            evts = []
-            for i in range(n):
-                if kw.get("run_" + str(i), run):
-                    evt = anyio.Event()
-                    await scp.spawn_service(with_serf, st.s[i], ready_evt=evt)
-                    evts.append(evt)
-            for e in evts:
-                await e.wait()
-            try:
-                yield st
-            finally:
-                with anyio.fail_after(2, shield=True):
-                    logger.info("Runtime: %s", clock.current_time())
-                    tg.cancel_scope.cancel()
-        logger.info("End")
-        pass  # unwinding ex:AsyncExitStack
-
-
-@asynccontextmanager
-async def mock_serf_client(master, **cfg):
-    async with scope.using_scope():
-        ms = MockServ(master, **cfg)
-        master.serfs.add(ms)
-        ms._scope = scope.get()  # pylint:disable=attribute-defined-outside-init
-        try:
-            yield ms
-        finally:
-            master.serfs.remove(ms)
-        pass  # terminating mock_serf_client nursery
-
-
-class MockServ:
-    def __init__(self, master, **cfg):
-        self.cfg = cfg
-        self._tg = scope._tg
-        self.streams = {}
-        self._master = master
-
-    def __hash__(self):
-        return id(self)
-
-    async def spawn(self, fn, *args, **kw):
-        async def run(evt):
-            with anyio.CancelScope() as sc:
-                await evt.set(sc)
-                await fn(*args, **kw)
-
-        evt = ValueEvent()
-        self._tg.spawn(run, evt)
-        return await evt.get()
-
-    async def event(self, name, payload, coalesce=True):
-        try:
-            logger.debug("SERF:%s: %r", name, unpacker(payload))
-        except Exception:
-            logger.debug("SERF:%s: %r (raw)", name, payload)
-        assert not coalesce, "'coalesce' must be cleared!"
-
-        i_self = self.cfg.get("i", 0)
-        for s in list(self._master.serfs):
-            i_s = s.cfg.get("i", 0)
-            for x in self._master.splits:
-                if (i_s < x) != (i_self < x):
-                    break
-            else:
-                n = tuple(name.split("."))
-                while n:
-                    sl = s.streams.get(n, ())
-                    for sn in sl:
-                        await sn.q.put((name, payload))
-                    n = n[:-1]
-
-    def stream(self, typ):
-        """compat for supporting asyncactor"""
-        if not typ.startswith("user:"):
-            raise RuntimeError("not supported")
-        typ = typ[5:]
-        return self.serf_mon(typ)
-
-    def serf_mon(self, typ):
-        if "," in typ:
-            raise RuntimeError("not supported")
-        s = MockSerfStream(self, "user:" + typ)
-        return s
-
-    async def serf_send(self, typ, payload):
-        """compat for supporting asyncactor"""
-        return await self.event(typ, payload)
-
-
-class MockSerfStream:
-    q = None
-
-    def __init__(self, serf, typ):
-        self.serf = serf
-        assert typ.startswith("user:")
-        self.typ = tuple(typ[5:].split("."))
-
-    async def __aenter__(self):
-        self.q = create_queue(100)
-        self.serf.streams.setdefault(self.typ, []).append(self)
-        return self
-
-    async def __aexit__(self, *tb):
-        self.serf.streams[self.typ].remove(self)
-        del self.q
-
-    def __aiter__(self):
-        return self
-
-    async def __anext__(self):
-        res = await self.q.get()
-        evt = SerfEvent(self)
-        evt.topic, evt.payload = res
-        return evt

build/lib/moat/kv/mock/tracer.py

@@ -1,63 +0,0 @@
-from __future__ import annotations
-import traceback
-
-import trio
-from outcome import Error
-
-import moat
-
-moat.kill = False
-
-import logging
-
-logger = logging.getLogger("TRACE")
-e = logger.error
-
-
-class Tracer(trio.abc.Instrument):
-    def __init__(self):
-        super().__init__()
-        self.etasks = set()
-
-    def _print_with_task(self, msg, task, err=None):
-        # repr(task) is perhaps more useful than task.name in general,
-        # but in context of a tutorial the extra noise is unhelpful.
-        if err is not None:
-            e("%s: %s %s", msg, task.name, repr(err))
-            traceback.print_exception(type(err), err, err.__traceback__)
-        else:
-            e("%s: %s", msg, task.name)
-
-    def nursery_end(self, task, exception):
-        if isinstance(exception, Exception):
-            self.etasks.add(task)
-            self._print_with_task("*** task excepted", task, exception)
-
-    def before_task_step(self, task):
-        if isinstance(task._next_send, Error) and isinstance(task._next_send.error, Exception):
-            self._print_with_task("*** step resume ERROR", task, task._next_send.error)
-            self.etasks.add(task)
-        elif moat.kill:  # pylint: disable=c-extension-no-member  # OH COME ON
-            self._print_with_task("*** step resume", task)
-
-    def task_scheduled(self, task):
-        e("SCHED %r", task)
-
-    def task_exited(self, task):
-        self._print_with_task("*** task exited", task)
-        self.etasks.discard(task)
-
-    def before_io_wait(self, timeout):
-        if timeout > 10000 and self.etasks:
-            e("\n\n\n\n\n\n\n\n\n\n")
-            e("*** ERROR: lock-out, killing off error tasks")
-            e("\n\n\n\n")
-            for t in self.etasks:
-                if t._next_send_fn is None:
-                    self._print_with_task("!!! Killing", t)
-                    t._runner.reschedule(t, Error(RuntimeError("*** Locked ***")))
-                else:
-                    self._print_with_task("??? already scheduled", t)
-
-
-# trio.run(main_, instruments=[Tracer()])