moat-kv 0.70.20__py3-none-any.whl → 0.70.23__py3-none-any.whl

moat/kv/_config.yaml

@@ -1,98 +0,0 @@
-kv:
-  conn:
-    # client: controls how to talk to the MoaT-KV server
-    host: localhost
-    port: 27586
-    ssl: false
-    # ssl:
-    #   cert: '/path/to/cert.pem',key='/path/to/cert.key'
-    init_timeout: 5
-    # time to wait for connection plus greeting
-    auth: null
-    # no auth used by default
-    name: null
-    # defaults to a seqnum
-  config:
-    prefix: !P :.moat.kv.config
-  errors:
-    prefix: !P :.moat.kv.error
-  codes:
-    prefix: !P :.moat.kv.code.proc
-  modules:
-    prefix: !P :.moat.kv.code.module
-  runner: # for moat.kv.runner.RunnerRoot
-    # storage for runnable commands
-    prefix: !P :.moat.kv.run"
-    # storage for runner states
-    state: !P :.moat.kv.state"
-
-    name: "run"
-    # Serf event name, suffixed by subpath
-
-    start_delay: 1
-    # time to wait between job starts. Not optional.
-
-    ping: -15
-    # set an I-am-running message every those-many seconds
-    # positive: set in moat.kv, negative: broadcast to :moat.kv.run tag
-
-    actor:
-      # Actor config, required for Runner
-      cycle: 20
-      nodes: -1
-      splits: 5
-      n_hosts: 3
-      version: 1
-    sub:
-      # tags for various runner modes
-      group: "any"
-      single: "at"
-      all: "all"
-  server:
-    # server-side configuration
-    buffer: 10
-    # per-stream buffer
-
-    backend: "mqtt"
-    # default
-    mqtt:
-      uri: "mqtt://localhost:1883"
-    serf:
-      host: "localhost"
-      port: 7373
-
-    # event message path/topic prefix
-    root: !P moat.kv
-
-    paranoia: False
-    # typecheck server-to-server updates?
-    #
-    # which addresses/ports to accept MoaT-KV connections on
-    bind: [{}]
-    bind_default:
-      # default values for all elements of "bind"
-      host: "localhost"
-      port: PORT
-      ssl: False
-    change:
-      length: 5
-      # chain length: use max nr of network sections +1
-    ping:
-      cycle: 10
-      gap: 2
-      # asyncserf.Actor config timing for server sync
-    # ping also controls minimum server startup time
-    delete:
-      # asyncserf.Actor config timing for deletion
-      cycle: 100
-      gap: 10
-      version: 1
-  paranoia: false
-  # typecheck server>server updates?
-
-  # how does a new server reach existing nodes, to download state?
-  domain: null
-  # domain in which to look up node names, if not in hostmap
-  hostmap:   # map MoaT-KV server names to connect destinations
-    test1: ["localhost", 27586]
-    test2: ["does-not-exist.invalid", 27586]

moat/kv/actor/__init__.py

@@ -1,97 +0,0 @@
-"""
-This module implements a :class:`asyncactor.Actor` which works on top of
-a MoaT-KV client.
-"""
-
-from asyncactor import Actor  # noqa
-from asyncactor.abc import MonitorStream, Transport
-
-__all__ = [
-    "ClientActor",
-    "ActorState",
-    "BrokenState",
-    "DetachedState",
-    "PartialState",
-    "CompleteState",
-]
-
-
-class ClientActor(Actor):
-    def __init__(self, client, *a, topic, **kw):
-        super().__init__(ClientTransport(client, topic), *a, **kw)
-
-
-class ClientTransport(Transport):
-    """
-    This class exports the client's direct messaging interface to the
-    actor.
-    """
-
-    def __init__(self, client, topic):
-        self.client = client
-        self.topic = topic
-
-    def monitor(self):
-        return ClientMonitor(self)
-
-    async def send(self, payload):
-        await self.client.msg_send(self.topic, payload)
-
-
-class ClientMonitor(MonitorStream):
-    _mon1 = None
-    _mon2 = None
-    _it = None
-
-    async def __aenter__(self):
-        self._mon1 = self.transport.client.msg_monitor(self.transport.topic)
-        self._mon2 = await self._mon1.__aenter__()
-        return self
-
-    async def __aexit__(self, *tb):
-        return await self._mon1.__aexit__(*tb)
-
-    def __aiter__(self):
-        self._it = self._mon2.__aiter__()
-        return self
-
-    async def __anext__(self):
-        msg = await self._it.__anext__()
-        return msg.data
-
-
-# The following events are used by Runner etc. to notify running jobs
-# about the current connectivity state.
-#
-class ActorState:
-    """base class for states"""
-
-    def __init__(self, msg=None):
-        self.msg = msg
-
-    def __repr__(self):
-        return "<%s:%r>" % (self.__class__.__name__, self.msg)
-
-
-class BrokenState(ActorState):
-    """I have no idea what's happening, probably nothing good"""
-
-    pass
-
-
-class DetachedState(ActorState):
-    """I am detached, my actor group is not visible"""
-
-    pass
-
-
-class PartialState(ActorState):
-    """Some but not all members of my actor group are visible"""
-
-    pass
-
-
-class CompleteState(ActorState):
-    """All members of my actor group are visible"""
-
-    pass

moat/kv/actor/deletor.py

@@ -1,137 +0,0 @@
-"""
-This module implements additional code for the server-side DeleteActor,
-which is used to clean up the list of deleted nodes.
-"""
-
-import weakref
-from collections import deque
-
-import anyio
-from asyncactor import Actor, PingEvent, TagEvent
-from asyncactor.backend import get_transport
-
-TAGS = 4
-
-
-class DeleteActor:
-    _enabled = None
-
-    def __init__(self, server):
-        self._server = weakref.ref(server)
-        self.deleted = deque()
-        self.tags = []
-        self.actor = None
-
-        self.max_seen = 0
-        self.n_tags = 0
-        self.n_pings = 0
-        self.n_nodes = 0
-
-    @property
-    def server(self):
-        return self._server()
-
-    async def tock_me(self):
-        """
-        Add the current tock to our buffer.
-
-        This is updated whenever a new leader is selected.
-        """
-        self.tags.append(self.server.tock)
-        self.tags = self.tags[-TAGS:]
-        await self.actor.set_value((self.tags[0], self.tags[-1]))
-
-    def add_deleted(self, nodes: "NodeSet"):  # noqa: F821
-        """
-        These nodes are deleted. Remember them for some time.
-        """
-        if self.n_nodes == 0:
-            return
-        self.deleted.append((self.server.tock, nodes))
-
-    def purge_to(self, tock):
-        """
-        Sufficient time has passed since this tock was seen, while all
-        Delete actor nodes were active. Finally flush the entries that have
-        been deleted before it.
-        """
-        while self.deleted and self.deleted[0][0] < tock:
-            d = self.deleted.popleft()
-            self.server.purge_deleted(d[1])
-
-    async def enable(self, n):
-        """
-        Enable this actor, as a group of N.
-        """
-        if self.actor is None:
-            self._enabled = True
-        else:
-            await self.actor.enable(n)
-        self.n_tags = 0
-        self.n_pings = 0
-        self.n_nodes = n
-
-    async def disable(self, n: int = 0):
-        """
-        Disable this actor. It will still listen, and require N Delete
-        actor members in order to flush its deletion entries.
-
-        Completely disable deletion flushing by passing n=0.
-        """
-        if self.actor is None:
-            self._enabled = False
-        else:
-            await self.actor.disable()
-        self.n_tags = 0
-        self.n_pings = 0
-        self.n_nodes = n
-
-    async def run(self, evt: anyio.abc.Event = None):
-        """
-        The task that monitors the Delete actor.
-        """
-        try:
-            T = get_transport("moat_kv")
-            async with Actor(
-                T(self.server.backend, *self.server.cfg.server.root, "del"),
-                name=self.server.node.name,
-                cfg=self.server.cfg.server.delete,
-                enabled=False,
-            ) as actor:
-                self.actor = actor
-                if self._enabled is not None:
-                    if self._enabled:
-                        await actor.enable()
-                    else:
-                        await actor.disable()
-                if evt is not None:
-                    evt.set()
-                async for evt in actor:
-                    if isinstance(evt, PingEvent):
-                        val = evt.value
-                        if val is None:
-                            self.n_pings = self.n_tags = 0
-                            continue
-                        if len(evt.msg.history) < self.n_nodes:
-                            self.n_pings = self.n_tags = 0
-                            continue
-                        self.n_pings += 1
-                        if self.n_pings > self.n_nodes:
-                            mx, self.max_seen = (
-                                self.max_seen,
-                                max(self.max_seen, val[1]),
-                            )
-                            if val[0] > mx > 0:
-                                await self.server.resync_deleted(evt.msg.history)
-                                continue
-                            self.purge_to(val[0])
-                            self.max_seen = max(self.max_seen, val[1])
-
-                    elif isinstance(evt, TagEvent):
-                        if actor.history_size == self.n_nodes:
-                            self.n_tags += 1
-                            if self.n_tags > 2:
-                                self.purge_to(self.tags[0])
-                            await self.tock_me()
-        finally:
-            self.actor = None