remoteRF-server 1.7.16__tar.gz → 1.7.17__tar.gz

{remoterf_server-1.7.16 → remoterf_server-1.7.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remoteRF-server
-Version: 1.7.16
+Version: 1.7.17
 Summary: RemoteRF server-side control package
 License: GPL-3.0-or-later
 Classifier: Programming Language :: Python :: 3

{remoterf_server-1.7.16 → remoterf_server-1.7.17}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "remoteRF-server"
-version = "1.7.16"
+version = "1.7.17"
 description = "RemoteRF server-side control package"
 license = { text = "GPL-3.0-or-later" }
 requires-python = ">=3.10"

{remoterf_server-1.7.16 → remoterf_server-1.7.17}/src/remoteRF_server/server/commands.py

@@ -130,7 +130,7 @@ def _table() -> list[Command]:
         Command(("reservations purge",), "Remove ALL reservations", _daemon("cmd_reservations_purge"), "Reservations", where=D),
         # ---- groups ----
         Command(("groups list",), "List user groups", _shell("cmd_groups_list"), "Groups"),
-        Command(("groups create",), "Create a user group (interactive)", _shell("cmd_groups_create"), "Groups"),
+        Command(("groups create",), "Create a group: groups create <name> --devices <ids> [--max-reservations 3 --max-time 1800 --horizon 604800 --lifetime 0 --lan-only --public --share <clusters>] --yes [--json]; no name is interactive", _shell("cmd_groups_create"), "Groups"),
         Command(("groups edit",), "Edit a user group (interactive)", _shell("cmd_groups_edit"), "Groups"),
         Command(("groups remove",), "Delete a user group (interactive)", _shell("cmd_groups_remove"), "Groups"),
         Command(("groups public",), "Share a group with anyone on RemoteRF Global, or stop: groups public <group> on|off", _federation("public"), "Groups"),
@@ -138,7 +138,7 @@ def _table() -> list[Command]:
         Command(("groups csv",), "Export ALL user groups as CSV to Downloads", _shell("cmd_groups_csv"), "Groups"),
         # ---- enrollment codes ----
         Command(("codes list",), "List enrollment codes", _shell("cmd_codes_list"), "Enrollment codes"),
-        Command(("codes create",), "Create enrollment codes for a group or a cluster (interactive)", _shell("cmd_codes_create"), "Enrollment codes"),
+        Command(("codes create",), "Create codes: codes create <group name|id|none> --count N [--length 10 --uses 1 --duration 3600] --yes [--json]; no group is interactive", _shell("cmd_codes_create"), "Enrollment codes"),
         Command(("codes remove",), "Delete an enrollment code (interactive)", _shell("cmd_codes_remove"), "Enrollment codes"),
         Command(("codes csv",), "Export ALL enrollment codes as CSV to Downloads", _shell("cmd_codes_csv"), "Enrollment codes"),
         # ---- hosts ----

{remoterf_server-1.7.16 → remoterf_server-1.7.17}/src/remoteRF_server/serverrf_cli.py

@@ -1448,6 +1448,66 @@ def _yes(argv: List[str]) -> bool:
     return "-y" in argv or "--yes" in argv
 
 
+def _parse_create_args(argv, *, value_flags, bool_flags):
+    """Small strict parser for the two forced-command-safe create forms."""
+    positional, values = [], {}
+    i = 0
+    while i < len(argv):
+        token = argv[i]
+        if not token.startswith("--"):
+            positional.append(token)
+            i += 1
+            continue
+        option, equals, inline = token[2:].partition("=")
+        if option in bool_flags:
+            if equals:
+                return None, f"--{option} does not take a value"
+            values[option] = True
+            i += 1
+            continue
+        if option not in value_flags:
+            return None, f"unknown option --{option}"
+        if equals:
+            value = inline
+        elif i + 1 < len(argv) and not argv[i + 1].startswith("--"):
+            i += 1
+            value = argv[i]
+        else:
+            return None, f"--{option} requires a value"
+        values[option] = value
+        i += 1
+    return (positional, values), None
+
+
+def _bounded_int(value, option, *, minimum, maximum=None):
+    try:
+        number = int(value)
+    except (TypeError, ValueError):
+        raise ValueError(f"{option} must be an integer") from None
+    if number < minimum:
+        raise ValueError(f"{option} must be >= {minimum}")
+    if maximum is not None and number > maximum:
+        raise ValueError(f"{option} must be <= {maximum}")
+    return number
+
+
+def _comma_ints(value, *, required=False):
+    if value is None:
+        if required:
+            raise ValueError("--devices is required")
+        return []
+    parts = [part for part in str(value).replace(",", " ").split() if part]
+    if not parts:
+        raise ValueError("--devices requires one or more device ids")
+    try:
+        devices = [int(part) for part in parts]
+    except ValueError:
+        raise ValueError("--devices must be comma-separated integer ids") from None
+    if any(device < 0 for device in devices):
+        raise ValueError("--devices ids must be >= 0")
+    return list(dict.fromkeys(devices))
+
+
 def _ask(prompt: str, default: str = "") -> str:
     try:
         value = input(f"  {prompt}{f' [{default}]' if default else ''}: ").strip()
@@ -2051,9 +2111,96 @@ def cmd_groups_list(argv):
 
 
 def cmd_groups_create(argv):
-    from remoteRF_server.server.user_group_cli import make_user_group_local
+    from remoteRF_server.server import user_group_cli as groups
 
-    make_user_group_local(_prompt_session())
+    if not _positional(argv) or (sys.stdin.isatty() and not any(a.startswith("-") for a in argv)):
+        groups.make_user_group_local(_prompt_session())
+        return 0
+    if not _yes(argv):
+        print("ERROR: non-interactive group creation requires --yes", file=sys.stderr)
+        return 1
+
+    parsed, error = _parse_create_args(
+        argv,
+        value_flags={"devices", "max-reservations", "max-time", "horizon", "lifetime", "share"},
+        bool_flags={"yes", "json", "lan-only", "public"},
+    )
+    if error:
+        print(f"ERROR: {error}", file=sys.stderr)
+        return 1
+    pos, flags = parsed
+    if len(pos) != 1:
+        print("ERROR: groups create requires exactly one group name", file=sys.stderr)
+        return 1
+    name = pos[0].strip()
+    existing = groups.user_group_handler.get_all_user_groups(include_users=False) or []
+    if any(g.get("group_name") == name for g in existing):
+        print(f"ERROR: group {name!r} already exists", file=sys.stderr)
+        return 1
+
+    try:
+        devices = _comma_ints(flags.get("devices"), required=True)
+        max_reservations = _bounded_int(flags.get("max-reservations", "3"), "--max-reservations", minimum=1)
+        max_time = _bounded_int(flags.get("max-time", "1800"), "--max-time", minimum=1)
+        horizon = _bounded_int(flags.get("horizon", str(7 * 86400)), "--horizon", minimum=0)
+        lifetime = _bounded_int(flags.get("lifetime", "0"), "--lifetime", minimum=0)
+    except ValueError as exc:
+        print(f"ERROR: {exc}", file=sys.stderr)
+        return 1
+    lan_only = bool(flags.get("lan-only"))
+    public = bool(flags.get("public"))
+    shares = groups._names(str(flags.get("share", "none")))
+    if lan_only and (public or shares):
+        print("ERROR: a LAN-only group cannot be public or shared with partner clusters", file=sys.stderr)
+        return 1
+
+    group_id = groups.user_group_handler.create_user_group(
+        group_name=name,
+        devices_whitelist=devices,
+        max_reservation_time_sec=max_time,
+        max_reservations=max_reservations,
+        lifetime_sec=lifetime,
+        lan_only=lan_only,
+        max_horizon_sec=horizon,
+    )
+    if group_id is None:
+        now = groups.user_group_handler.get_all_user_groups(include_users=False) or []
+        if any(g.get("group_name") == name for g in now):
+            print(f"ERROR: group {name!r} already exists", file=sys.stderr)
+        else:
+            print(f"ERROR: failed to create group {name!r}", file=sys.stderr)
+        return 1
+
+    shared_with = []
+    if public or shares:
+        from remoteRF_server.server.federation import cluster
+
+        for cluster_name in (["global"] if public else []) + shares:
+            try:
+                cluster.attach_group(cluster_name, str(group_id))
+                shared_with.append(cluster_name)
+            except (cluster.ClusterError, RuntimeError, OSError) as exc:
+                print(f"WARNING: group was not shared with {cluster_name}: {exc}", file=sys.stderr)
+
+    if flags.get("json"):
+        created_group = next(
+            (g for g in groups.user_group_handler.get_all_user_groups(include_users=False) or []
+             if int(g.get("group_id", -1)) == int(group_id)),
+            {},
+        )
+        print(json.dumps({
+            "group_id": int(group_id), "group_name": name,
+            "devices_whitelist": created_group.get("devices_whitelist", devices),
+            "max_reservations": created_group.get("max_reservations", max_reservations),
+            "max_reservation_time_sec": created_group.get("max_reservation_time_sec", max_time),
+            "max_horizon_sec": created_group.get("max_horizon_sec", horizon),
+            "lifetime_sec": created_group.get("lifetime_sec", lifetime),
+            "lan_only": created_group.get("lan_only", lan_only),
+            "public": "global" in shared_with, "shared_with": shared_with,
+        }, separators=(",", ":")))
+    else:
+        print(f"Created group {name} (id {group_id})")
+    return 0
 
 
 def cmd_groups_edit(argv):
@@ -2081,9 +2228,80 @@ def cmd_codes_list(argv):
 
 
 def cmd_codes_create(argv):
-    from remoteRF_server.server.user_group_cli import make_enrollment_codes_local
+    from remoteRF_server.server import user_group_cli as groups
+
+    if not _positional(argv) or (sys.stdin.isatty() and not any(a.startswith("-") for a in argv)):
+        groups.make_enrollment_codes_local(_prompt_session())
+        return 0
+    if not _yes(argv):
+        print("ERROR: non-interactive enrollment-code creation requires --yes", file=sys.stderr)
+        return 1
+
+    parsed, error = _parse_create_args(
+        argv, value_flags={"count", "length", "uses", "duration"},
+        bool_flags={"yes", "json"},
+    )
+    if error:
+        print(f"ERROR: {error}", file=sys.stderr)
+        return 1
+    pos, flags = parsed
+    if len(pos) != 1:
+        print("ERROR: codes create requires exactly one group name, group id, or 'none'", file=sys.stderr)
+        return 1
 
-    make_enrollment_codes_local(_prompt_session())
+    ref = pos[0].strip()
+    all_groups = groups.user_group_handler.get_all_user_groups(include_users=False) or []
+    by_id = {int(g["group_id"]): g for g in all_groups}
+    by_name = {str(g["group_name"]): g for g in all_groups}
+    if ref.lower() == "none":
+        group_id = -1
+    else:
+        selected = by_id.get(int(ref)) if ref.isdigit() else by_name.get(ref)
+        if selected is None:
+            print(f"ERROR: unknown group {ref!r}", file=sys.stderr)
+            return 1
+        group_id = int(selected["group_id"])
+
+    try:
+        if "count" not in flags:
+            raise ValueError("--count is required")
+        count = _bounded_int(flags["count"], "--count", minimum=1, maximum=500)
+        length = _bounded_int(flags.get("length", "10"), "--length", minimum=4)
+        uses = _bounded_int(flags.get("uses", "1"), "--uses", minimum=1)
+        duration = _bounded_int(flags.get("duration", "3600"), "--duration", minimum=0)
+    except ValueError as exc:
+        print(f"ERROR: {exc}", file=sys.stderr)
+        return 1
+
+    code_names = groups.user_group_handler.generate_random_enrollment_code_names(
+        count=count, char_count=length,
+    ) or []
+    if len(code_names) != count:
+        print(f"ERROR: generated only {len(code_names)} of {count} enrollment codes", file=sys.stderr)
+        return 1
+    result = groups.user_group_handler.create_enrollment_codes(
+        code_names=code_names, group_id=group_id, uses=uses, duration_sec=duration,
+    )
+    created = [row for row in groups.user_group_handler.get_all_enrollment_codes() or []
+               if row.get("code_name") in code_names]
+    if len(created) != count:
+        print(f"ERROR: created only {len(created)} of {count} enrollment codes{f': {result}' if result else ''}", file=sys.stderr)
+        return 1
+    rows = groups._invites(created)
+    if flags.get("json"):
+        print(json.dumps({
+            "group_id": group_id, "uses": uses, "duration_sec": duration,
+            "invites": [row["invite"] for row in rows],
+        }, separators=(",", ":")))
+        return 0
+
+    print(f"\n{result}")
+    if rows[0]["invite"] == rows[0]["code_name"]:
+        print(f"Hand these out as is; users connect first with: remoterf -c -a {groups.lan_endpoint() or '<lan address>'}")
+    else:
+        print("Hand these out as is; users enter one at: remoterf --register")
+    groups.print_table("Enrollment codes", rows, ["invite"])
+    return 0
 
 
 def cmd_codes_remove(argv):

{remoterf_server-1.7.16 → remoterf_server-1.7.17}/src/remoteRF_server.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remoteRF-server
-Version: 1.7.16
+Version: 1.7.17
 Summary: RemoteRF server-side control package
 License: GPL-3.0-or-later
 Classifier: Programming Language :: Python :: 3

{remoterf_server-1.7.16 → remoterf_server-1.7.17}/tests/test_commands.py

@@ -2,10 +2,12 @@
 
 import contextlib
 import io
+import json
 import os
 import tempfile
 import unittest
 from pathlib import Path
+from types import SimpleNamespace
 from unittest import mock
 
 import yaml
@@ -158,3 +160,109 @@ class TwoDoorsTests(unittest.TestCase):
             self.assertEqual(dispatch(["global", "clusters"], in_daemon=True), 1)
         self.assertIn("Not configured", out.getvalue())
         self.assertIn("not enabled", out.getvalue())
+
+
+class NonInteractiveGroupCommandsTests(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.addCleanup(self.tmp.cleanup)
+        self.cfg = Path(self.tmp.name) / "remoterf"
+        db = self.cfg / "db"
+        db.mkdir(parents=True)
+        env = mock.patch.dict(os.environ, {
+            "REMOTERF_CONFIG_DIR": str(self.cfg),
+            "XDG_CONFIG_HOME": self.tmp.name,
+            "XDG_DATA_HOME": str(Path(self.tmp.name) / "data"),
+        })
+        env.start()
+        self.addCleanup(env.stop)
+
+        from remoteRF_server.server import user_group_cli
+        from remoteRF_server.server import user_group_handler as handler_module
+
+        with mock.patch.object(handler_module, "get_db_dir", return_value=db):
+            self.handler = handler_module.UserGroupHandler()
+        handler = mock.patch.object(user_group_cli, "user_group_handler", self.handler)
+        handler.start()
+        self.addCleanup(handler.stop)
+
+    def run_shell(self, argv):
+        out = io.StringIO()
+        from remoteRF_server import serverrf_cli
+
+        stdin = SimpleNamespace(isatty=lambda: False)
+        with mock.patch.object(serverrf_cli.sys, "stdin", stdin), \
+                contextlib.redirect_stdout(out), contextlib.redirect_stderr(out):
+            rc = dispatch(argv, in_daemon=False)
+        return rc, out.getvalue()
+
+    def create_group(self):
+        return self.run_shell([
+            "groups", "create", "ee123", "--devices", "7,3,7",
+            "--max-reservations", "4", "--max-time", "900",
+            "--horizon", "172800", "--lifetime", "86400",
+            "--lan-only", "--yes", "--json",
+        ])
+
+    def test_group_create_from_flags_and_duplicate_is_refused(self):
+        rc, output = self.create_group()
+        self.assertEqual(rc, 0, output)
+        value = json.loads(output)
+        self.assertEqual(value["group_name"], "ee123")
+        self.assertEqual(value["devices_whitelist"], [3, 7])
+        group = self.handler.get_all_user_groups(include_users=False)[0]
+        self.assertEqual(group["devices_whitelist"], [3, 7])
+        self.assertEqual((group["max_reservations"], group["max_reservation_time_sec"]), (4, 900))
+        self.assertEqual((group["max_horizon_sec"], group["lifetime_sec"], group["lan_only"]),
+                         (172800, 86400, True))
+
+        rc, output = self.run_shell([
+            "groups", "create", "ee123", "--devices", "3", "--yes",
+        ])
+        self.assertEqual(rc, 1)
+        self.assertEqual(output, "ERROR: group 'ee123' already exists\n")
+
+    def test_codes_create_json_honours_group_uses_and_duration(self):
+        rc, output = self.create_group()
+        self.assertEqual(rc, 0, output)
+        group_id = json.loads(output)["group_id"]
+
+        rc, output = self.run_shell([
+            "codes", "create", "ee123", "--count", "3", "--uses", "5",
+            "--duration", "7200", "--yes", "--json",
+        ])
+        self.assertEqual(rc, 0, output)
+        value = json.loads(output)
+        self.assertEqual(value["group_id"], group_id)
+        self.assertEqual((value["uses"], value["duration_sec"]), (5, 7200))
+        self.assertEqual(len(value["invites"]), 3)
+        rows = self.handler.get_all_enrollment_codes()
+        self.assertEqual({row["group_id"] for row in rows}, {group_id})
+        self.assertEqual({row["uses"] for row in rows}, {5})
+        self.assertEqual({row["duration_sec"] for row in rows}, {7200})
+        self.assertEqual(set(value["invites"]), {row["code_name"] for row in rows})
+
+    def test_unknown_group_and_missing_yes_are_refused(self):
+        rc, output = self.run_shell([
+            "codes", "create", "missing", "--count", "3", "--yes",
+        ])
+        self.assertEqual(rc, 1)
+        self.assertEqual(output, "ERROR: unknown group 'missing'\n")
+
+        rc, output = self.run_shell([
+            "groups", "create", "ee123", "--devices", "3",
+        ])
+        self.assertEqual(rc, 1)
+        self.assertEqual(output, "ERROR: non-interactive group creation requires --yes\n")
+
+        rc, output = self.run_shell([
+            "codes", "create", "none", "--count", "1",
+        ])
+        self.assertEqual(rc, 1)
+        self.assertEqual(output, "ERROR: non-interactive enrollment-code creation requires --yes\n")
+
+    def test_help_lists_flag_forms(self):
+        groups_help = "\n".join(commands.help_text(in_daemon=False, section="Groups"))
+        codes_help = "\n".join(commands.help_text(in_daemon=False, section="Enrollment codes"))
+        self.assertIn("groups create <name> --devices <ids>", groups_help)
+        self.assertIn("codes create <group name|id|none> --count N", codes_help)