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

moat/kv/command/error.py

@@ -0,0 +1,149 @@
+# command line interface
+from __future__ import annotations
+
+import sys
+
+import asyncclick as click
+from moat.util import P, Path, yprint
+
+from moat.kv.data import add_dates
+from moat.kv.errors import ErrorRoot
+
+
+@click.group()  # pylint: disable=undefined-variable
+@click.pass_obj
+async def cli(obj):
+    """Manage error records in MoaT-KV."""
+    obj.err = await ErrorRoot.as_handler(obj.client)
+
+
+@cli.command()
+@click.option("-s", "--subsys", help="Subsystem to access")
+@click.argument("path", nargs=1)
+@click.pass_obj
+async def resolve(obj, path, subsys):
+    """
+    Mark an error as resolved.
+    """
+    path = P(path)
+    if subsys:
+        e = obj.err.get_error_record(subsys, path)
+    else:
+        e = obj.err.follow(path)
+    if e.resolved:
+        print("Already resolved.", file=sys.stderr)
+        return
+    await e.resolve()
+
+
+@cli.command()
+@click.option("-n", "--node", help="add details from this node")
+@click.option("-s", "--subsystem", "subsys", help="only show errors from this subsystem")
+@click.option("-r", "--resolved", is_flag=True, help="only resolved errors")
+@click.option("-v", "--verbose", count=True, help="add per-node details (-vv for traces)")
+@click.option("-a", "--all-errors", is_flag=True, help="add details from all nodes")
+@click.option("-d", "--as-dict", default=None, help="Dump a list of all open (or resolved) error.")
+@click.option("-p", "--path", default=":", help="only show errors below this subpath")
+@click.pass_obj
+async def dump(obj, as_dict, path, node, all_errors, verbose, resolved, subsys):
+    """Dump error entries."""
+    path = P(path)
+    path_ = obj.cfg["errors"].prefix
+    d = 2
+
+    async def one(r):
+        nonlocal y
+        val = r.value
+        if subsys and val.get("subsystem", "") != subsys:
+            return
+        if path and val.get("path", ())[: len(path)] != path:
+            return
+
+        if not all_errors and bool(val.get("resolved", False)) != resolved:
+            return
+
+        add_dates(val)
+        try:
+            rp = val.path
+            if as_dict:
+                del val.path
+            elif not isinstance(rp, Path):
+                rp = Path.build(rp)
+        except AttributeError:
+            rp = Path("incomplete") + r.path
+            if not as_dict:
+                val.path = rp
+        if rp[: len(path)] != path:
+            return
+        rp = rp[len(path) :]
+        if node is None:
+            val.syspath = r.path
+        else:
+            val.syspath = Path(node) + r.path
+
+        rn = {}
+
+        def disp(rr):
+            if node and rr.path[-1] != node:
+                return
+            val = rr.value
+            add_dates(val)
+            if verbose < 2:
+                rr.value.pop("trace", None)
+            rn[rr.path[-1]] = rr if obj.meta else rr.value
+
+        if verbose:
+            rs = await obj.client._request(
+                action="get_tree",
+                min_depth=1,
+                max_depth=1,
+                path=path_ + r.path[-2:],
+                iter=True,
+                nchain=3 if obj.meta else 0,
+            )
+            async for rr in rs:
+                disp(rr)
+
+        elif node:
+            rs = await obj.client.get(path_ + r.path[-2:] | node)
+            if "value" in rs:
+                disp(rs)
+
+        if rn:
+            val["nodes"] = rn
+
+        if as_dict is not None:
+            yy = y
+            if subsys is None:
+                yy = yy.setdefault(val.get("subsystem", "unknown"), {})
+            for p in rp:
+                yy = yy.setdefault(p, {})
+            yy[as_dict] = r if obj.meta else val
+        else:
+            yy = r if obj.meta else r.value
+
+            yprint([yy], stream=obj.stdout)
+            print("---", file=obj.stdout)
+
+    y = {}
+    res = None
+
+    if node is None and len(path) == 2 and isinstance(path[-1], int):  # single error?
+        r = await obj.client.get(path_ + path, nchain=3 if obj.meta else 0)
+        # Mangle a few variables so that the output is still OK
+        r.path = path
+        node = None
+
+        async def ait(r):
+            yield r
+
+        res = ait(r)
+        path = ()
+
+    if res is None:
+        res = obj.client.get_tree(path_, min_depth=d, max_depth=d, nchain=3 if obj.meta else 0)
+    async for r in res:
+        await one(r)
+
+    if as_dict is not None:
+        yprint(y, stream=obj.stdout)

moat/kv/command/internal.py

@@ -0,0 +1,248 @@
+# command line interface
+from __future__ import annotations
+
+from collections.abc import Mapping
+
+import asyncclick as click
+from moat.util import P, PathLongener, yprint
+from range_set import RangeSet
+
+
+@click.group(short_help="Control internal state.")  # pylint: disable=undefined-variable
+async def cli():
+    """
+    This subcommand queries and controls the server's internal state.
+    """
+    pass
+
+
+@cli.command()
+@click.option("-n", "--nodes", is_flag=True, help="Get node status.")
+@click.option("-d", "--deleted", is_flag=True, help="Get deletion status.")
+@click.option("-m", "--missing", is_flag=True, help="Get missing-node status.")
+@click.option(
+    "-r",
+    "--remote-missing",
+    "remote_missing",
+    is_flag=True,
+    help="Get remote-missing-node status.",
+)
+@click.option("-p", "--present", is_flag=True, help="Get known-data status.")
+@click.option("-s", "--superseded", is_flag=True, help="Get superseded-data status.")
+@click.option("-D", "--debug", is_flag=True, help="Get internal verbosity.")
+@click.option("--debugger", is_flag=True, help="Start a remote debugger. DO NOT USE.")
+@click.option("-k", "--known", hidden=True, is_flag=True, help="Get superseded-data status.")
+@click.option("-a", "--all", is_flag=True, help="All available data.")
+@click.pass_obj
+async def state(obj, **flags):
+    """
+    Dump the server's state.
+    """
+    if flags.pop("known", None):
+        flags["superseded"] = True
+    if flags.pop("all", None):
+        flags["superseded"] = True
+        flags["present"] = True
+        flags["nodes"] = True
+        flags["deleted"] = True
+        flags["missing"] = True
+        flags["remote_missing"] = True
+    res = await obj.client._request("get_state", iter=False, **flags)
+    k = res.pop("known", None)
+    if k is not None:
+        res["superseded"] = k
+    yprint(res, stream=obj.stdout)
+
+
+@cli.command()
+@click.option("-d", "--deleted", is_flag=True, help="Mark as deleted. Default: superseded")
+@click.option(
+    "-n",
+    "--node",
+    "source",
+    default="?",
+    help="The node this message is faked as being from.",
+)
+@click.option("-b", "--broadcast", is_flag=True, help="Send to all servers")
+@click.argument("node", nargs=1)
+@click.argument("items", type=int, nargs=-1)
+@click.pass_obj
+async def mark(obj, deleted, source, node, items, broadcast):
+    """
+    Fix internal state. Use no items to fetch the current list from the
+    server's ``missing`` state. Use an empty node name to add the whole
+    list, not just a single node's.
+
+    This is a dangerous command.
+    """
+
+    k = "deleted" if deleted else "superseded"
+    if not items:
+        r = await obj.client._request("get_state", iter=False, missing=True)
+        r = r["missing"]
+        if node != "":
+            r = {node: r[node]}
+    elif node == "":
+        raise click.UsageError("You can't do that with an empty node")
+    else:
+        r = RangeSet()
+        for i in items:
+            r.add(i)
+        r = {node: r.__getstate__()}
+
+    msg = {k: r, "node": source}
+
+    await obj.client._request("fake_info", iter=False, **msg)
+    if broadcast:
+        await obj.client._request("fake_info_send", iter=False, **msg)
+
+    res = await obj.client._request("get_state", iter=False, **{k: True})
+    yprint(res, stream=obj.stdout)
+
+
+@cli.command(short_help="Manage the Deleter list")
+@click.option("-d", "--delete", is_flag=True, help="Remove these nodes")
+@click.argument("nodes", nargs=-1)
+@click.pass_obj
+async def deleter(obj, delete, nodes):
+    """
+    Manage the Deleter list
+
+    This is the set of nodes that must be online for removal of deleted
+    entries from MoaT-KV's data.
+
+    There should be one such node in every possible network partition.
+    Also, all nodes with permanent storage should be on the list.
+
+    Usage:
+    - … deleter          -- list state
+    - … deleter NODE…    -- add this node
+    - … deleter -d NODE… -- remove this node
+    """
+
+    res = await obj.client._request(
+        action="get_internal",
+        path=("actor", "del"),
+        iter=False,
+        nchain=3 if delete or nodes else 2,
+    )
+    val = res.get("value", {})
+    if isinstance(val, Mapping):
+        val = val.get("nodes", [])
+    # else: compatibility, TODO remove
+    val = set(val)
+    if delete:
+        if nodes:
+            val -= set(nodes)
+        else:
+            val = set()
+    elif nodes:
+        val |= set(nodes)
+    else:
+        yprint(res, stream=obj.stdout)
+        return
+
+    val = {"nodes": list(val)}
+    res = await obj.client._request(
+        action="set_internal",
+        path=("actor", "del"),
+        iter=False,
+        chain=res.chain,
+        value=val,
+    )
+    res.value = val
+    yprint(res, stream=obj.stdout)
+
+
+@cli.command()
+@click.argument("path", nargs=1)
+@click.pass_obj
+async def dump(obj, path):
+    """
+    Dump internal state.
+
+    This displays MoaT-KV's internal state.
+    """
+
+    path = P(path)
+    y = {}
+    pl = PathLongener()
+    async for r in await obj.client._request("get_tree_internal", path=path, iter=True, nchain=0):
+        pl(r)
+        path = r["path"]
+        yy = y
+        for p in path:
+            yy = yy.setdefault(p, {})
+        try:
+            yy["_"] = r["value"]
+        except KeyError:
+            pass
+    yprint(y, stream=obj.stdout)
+
+
+@cli.command()
+@click.argument("node", nargs=1)
+@click.argument("tick", type=int, nargs=1)
+@click.pass_obj
+async def get(obj, node, tick):
+    """
+    Fetch data by node+tick.
+
+    This looks up internal data.
+    """
+
+    res = await obj.client._request("get_value", node=node, tick=tick, nchain=99)
+    if not obj.meta:
+        res = res.value
+    yprint(res, stream=obj.stdout)
+
+
+@cli.command()
+@click.option("-n", "--num", type=int, help="Return at most this many IDs")
+@click.option("-c", "--current", is_flag=True, help="Return only IDs with current data")
+@click.option("-C", "--copy", is_flag=True, help="Create an no-op change")
+@click.argument("node", nargs=1)
+@click.pass_obj
+async def enum(obj, node, num, current, copy):
+    """
+    List IDs of live data by a specific node.
+
+    Can be used to determine whether a node still has live data,
+    otherwise it can be deleted.
+
+    If '--current' is set, only the IDs of the entries that have last been
+    updated by that node are shown. '--copy' rewrites these entries.
+
+    Increase verbosity to also show the oject paths.
+    """
+
+    res = await obj.client._request("enum_node", node=node, max=num, current=current)
+    if obj.meta and not copy and obj.debug <= 1:
+        yprint(res, stream=obj.stdout)
+    else:
+        for k in res.result:
+            if copy or obj.debug > 1:
+                res = await obj.client._request("get_value", node=node, tick=k, nchain=3)
+                if obj.debug > 1:
+                    print(k, res.path)
+                else:
+                    print(k)
+                if copy and res.chain.node == node:
+                    res = await obj.client.set(res.path, value=res.value, chain=res.chain)
+            else:
+                print(k)
+
+
+@cli.command()
+@click.argument("node", nargs=1)
+@click.pass_obj
+async def kill(obj, node):
+    """
+    Remove a node from the node list.
+
+    This command only works if this node does not have any current data in
+    the system.
+    """
+    res = await obj.client._request("kill_node", node=node)
+    if obj.meta:
+        yprint(res, stream=obj.stdout)