remoteRF-server 1.1.0.dev28__py3-none-any.whl → 1.1.0.dev30__py3-none-any.whl

remoteRF_server/server/commands.py

@@ -148,7 +148,7 @@ def _table() -> list[Command]:
         Command(("global verify",), "Redeem the emailed code [code]", _global("verify"), "Global"),
         Command(("global leave",), "Stop participating", _global("leave"), "Global"),
         # ---- clusters (sharing devices with other labs) ----
-        Command(("cluster list", "cluster"), "Clusters shared with other labs", _federation("list"), "Clusters"),
+        Command(("cluster list",), "Clusters shared with other labs", _federation("list"), "Clusters"),
         Command(("cluster create",), "Start a cluster: cluster create <name>", _federation("create"), "Clusters"),
         Command(("cluster invite",), "Invite code for a lab: cluster invite <name>", _federation("invite"), "Clusters"),
         Command(("cluster join",), "Join with a code: cluster join <code>", _federation("join"), "Clusters"),

remoteRF_server/server/federation/cli.py

@@ -32,6 +32,17 @@ def _print(text: str, style=None) -> None:
     printf(text, style or Sty.DEFAULT)
 
 
+def _lab(party: dict) -> str:
+    short = party["deployment_id"][:8]
+    return f"{party['display_name']} ({short}…)" if party.get("display_name") else party["deployment_id"]
+
+
+def _day(epoch) -> str:
+    import datetime
+
+    return datetime.datetime.fromtimestamp(int(epoch)).strftime("%Y-%m-%d")
+
+
 def cmd_clusters() -> int:
     from ...common.utils.panel import marker, print_panel
     from . import cluster
@@ -48,10 +59,22 @@ def cmd_clusters() -> int:
     items = cluster.list_clusters()
     if not items:
         rows.append("No clusters. Start one with `cluster create <name>`.")
-    width = max([len(item["name"]) for item in items] or [0])
-    for item in items:
-        peer = item.get("peer") or "-"
-        rows.append(f"{item['name']:<{width}}  {item['role']:<6}  {item['state']:<9}  peer={peer}")
+    for index, item in enumerate(items):
+        if index:
+            rows.append("")
+        if item["role"] == "owner":
+            count = len(item["members"])
+            rows.append(f"{item['name']}  (yours)  {count} member lab{'s' if count != 1 else ''}"
+                        + (f", {item['open_invites']} open invite{'s' if item['open_invites'] != 1 else ''}"
+                           if item["open_invites"] else ""))
+            for member in item["members"]:
+                rows.append(f"    {_lab(member)}  {member['state'] or 'joining'}"
+                            + (f"  since {_day(member['joined_at'])}" if member.get("joined_at") else ""))
+            if not item["members"] and not item["open_invites"]:
+                rows.append(f"    nobody yet: `cluster invite {item['name']}`")
+        else:
+            owner = _lab({"display_name": item.get("peer_name"), "deployment_id": item["peer"]})
+            rows.append(f"{item['name']}  owned by {owner}  {item['state']}")
     print()
     print_panel("Clusters", rows, literal=True)
     print()

remoteRF_server/server/federation/cluster.py

@@ -66,9 +66,39 @@ def _state_path() -> Path:
 
 def load() -> dict:
     try:
-        return json.loads(_state_path().read_text())
+        clusters = json.loads(_state_path().read_text())
     except FileNotFoundError:
         return {}
+    for cluster in clusters.values():
+        _upgrade(cluster)
+    return clusters
+
+
+def _upgrade(cluster: dict) -> None:
+    """First shape held one partner per owner cluster; now it holds a star."""
+    if cluster.get("role") != "owner" or "members" in cluster:
+        return
+    members, invites = {}, {}
+    if cluster.get("peer"):
+        members[cluster["peer"]] = {
+            "display_name": None, "contract_id": cluster.get("contract_id"),
+            "state": cluster.get("state"), "published": cluster.get("published", []),
+            "joined_at": cluster.get("created_at"),
+        }
+        if cluster.get("joiner"):
+            members[cluster["peer"]]["joiner"] = cluster["joiner"]
+    elif cluster.get("joiner"):
+        joiner = cluster["joiner"]
+        members[joiner["deployment_id"]] = {
+            "display_name": None, "contract_id": None, "state": "pending",
+            "published": [], "joined_at": cluster.get("created_at"), "joiner": joiner,
+        }
+    elif cluster.get("secret") and cluster.get("invite_id"):
+        invites[cluster["invite_id"]] = {"secret": cluster["secret"], "auto": cluster.get("auto", True),
+                                         "created_at": cluster.get("created_at")}
+    for key in ("peer", "contract_id", "state", "published", "joiner", "secret", "invite_id", "auto"):
+        cluster.pop(key, None)
+    cluster["members"], cluster["invites"] = members, invites
 
 
 def save(clusters: dict) -> None:
@@ -186,18 +216,19 @@ def create(name: str) -> dict:
     clusters = load()
     if name in clusters:
         raise ClusterError(f"cluster {name} already exists")
-    clusters[name] = {"role": "owner", "state": "created", "created_at": int(time.time())}
+    clusters[name] = {"role": "owner", "created_at": int(time.time()), "members": {}, "invites": {}}
     save(clusters)
     return clusters[name]
 
 
 def invite(name: str, *, auto: bool = True) -> str:
-    """The code is the approval: whoever redeems it is pinned and contracted
-    without a further step here (`auto=False` keeps a manual `accept`)."""
+    """One code admits one lab. The code is the approval: whoever redeems it is
+    pinned and contracted without a further step here (`auto=False` keeps a
+    manual `accept`). Several codes may be open at once."""
     clusters = load()
     cluster = _find(clusters, name)
     if cluster["role"] != "owner":
-        raise ClusterError(f"{name} is owned by another deployment")
+        raise ClusterError(f"{name} is owned by another deployment; only the owner invites")
     me = _pin_self()
     invite_id, secret = secrets.token_hex(5), secrets.token_bytes(20)
     g.call("POST", "/v2/broker/invites", {
@@ -208,7 +239,7 @@ def invite(name: str, *, auto: bool = True) -> str:
         "identity": me,
         "tag": _tag(secret, invite_id, me),
     })
-    cluster.update(state="invited", invite_id=invite_id, secret=secret.hex(), auto=auto)
+    cluster["invites"][invite_id] = {"secret": secret.hex(), "auto": auto, "created_at": int(time.time())}
     save(clusters)
     return encode_code(invite_id, secret)
 
@@ -230,10 +261,13 @@ def join(code: str) -> str:
     _pin(owner["identity"], source="cluster_invite")
     name = view["cluster_name"]
     clusters = load()
+    if name in clusters and clusters[name]["role"] == "owner":
+        raise ClusterError(f"{name} is your own cluster")
     clusters[name] = {
         "role": "member",
         "state": "joined",
         "peer": owner["identity"]["deployment_id"],
+        "peer_name": owner.get("display_name"),
         "invite_id": invite_id,
         "created_at": int(time.time()),
     }
@@ -241,13 +275,9 @@ def join(code: str) -> str:
     return name
 
 
-def accept(name: str) -> dict:
-    """Owner: pin the joiner and propose the contract."""
-    clusters = load()
-    cluster = _find(clusters, name)
-    if cluster.get("state") != "pending":
-        raise ClusterError(f"{name} has no join waiting for approval")
-    joiner = cluster["joiner"]
+def _propose(cluster: dict, member: dict, peer: str) -> None:
+    """Owner: pin the joiner and propose its bilateral contract."""
+    joiner = member.pop("joiner")
     _pin(joiner, source="cluster_invite")
     me = _identity()
     a, b = sorted([me, joiner], key=lambda item: item["deployment_id"])
@@ -267,29 +297,49 @@ def accept(name: str) -> dict:
         "supersedes_version": None,
     }
     _contracts().propose(terms, actor_admin_ref="cluster")
-    cluster.update(state="proposed", peer=joiner["deployment_id"], contract_id=terms["contract_id"])
-    cluster.pop("joiner", None)
-    cluster.pop("secret", None)
+    member.update(state="proposed", contract_id=terms["contract_id"])
+    _publish(member)
+
+
+def accept(name: str, peer: str | None = None) -> dict:
+    """Owner, manual invites only: approve a join that is waiting."""
+    clusters = load()
+    cluster = _find(clusters, name)
+    pending = {pid: m for pid, m in cluster.get("members", {}).items() if m.get("state") == "pending"}
+    if not pending:
+        raise ClusterError(f"{name} has no join waiting for approval")
+    if peer is None and len(pending) > 1:
+        raise ClusterError(f"{name} has several joins waiting; name one: " + ", ".join(sorted(pending)))
+    peer = peer or next(iter(pending))
+    if peer not in pending:
+        raise ClusterError(f"{peer} is not waiting to join {name}")
+    _propose(cluster, pending[peer], peer)
     save(clusters)
-    _publish(cluster)
     return cluster
 
 
+def _revoke(contract_id: str | None) -> None:
+    if not contract_id:
+        return
+    try:
+        _contracts().revoke(contract_id, 1, actor_admin_ref="cluster")
+    except ContractError as exc:
+        if exc.code not in ("contract_revoked", "contract_terminal", "invalid_transition"):
+            raise
+
+
 def remove(name: str) -> str:
-    """Leave or disband: revoke the contract (terminal, signed, published so
-    the peer's next sync sees it) and forget the cluster locally."""
+    """Leave (member) or disband (owner): revoke every contract -- a terminal,
+    signed event the other side imports on its next sync -- and forget the
+    cluster locally."""
     clusters = load()
     cluster = _find(clusters, name)
     outcome = "removed"
-    if cluster.get("contract_id"):
-        store = _contracts()
+    parties = list(cluster["members"].values()) if cluster["role"] == "owner" else [cluster]
+    for party in parties:
+        _revoke(party.get("contract_id"))
         try:
-            store.revoke(cluster["contract_id"], 1, actor_admin_ref="cluster")
-        except ContractError as exc:
-            if exc.code not in ("contract_revoked", "contract_terminal", "invalid_transition"):
-                raise
-        try:
-            _publish(cluster)  # the other lab imports the revocation on its next sync
+            _publish(party)
         except g.GlobalError:
             outcome = "removed locally; could not reach Global to tell the other lab"
     del clusters[name]
@@ -298,30 +348,48 @@ def remove(name: str) -> str:
 
 
 def list_clusters() -> list[dict]:
+    """Owner rows carry `members` and `open_invites`; member rows carry `peer`."""
     store = None
     out = []
     for name, cluster in sorted(load().items()):
-        item = {"name": name, **cluster}
-        item.pop("secret", None)
-        if cluster.get("contract_id"):
-            try:
-                store = store or _contracts()
-                item["state"] = store.show(cluster["contract_id"], 1)["state"]
-            except ContractError:
-                pass
+        item = {"name": name, "role": cluster["role"], "created_at": cluster.get("created_at")}
+        if cluster["role"] == "owner":
+            members = []
+            for peer, member in sorted(cluster["members"].items()):
+                state = member.get("state")
+                if member.get("contract_id"):
+                    try:
+                        store = store or _contracts()
+                        state = store.show(member["contract_id"], 1)["state"]
+                    except ContractError:
+                        pass
+                members.append({"deployment_id": peer, "display_name": member.get("display_name"),
+                                "state": state, "joined_at": member.get("joined_at")})
+            item.update(members=members, open_invites=len(cluster["invites"]))
+        else:
+            state = cluster.get("state")
+            if cluster.get("contract_id"):
+                try:
+                    store = store or _contracts()
+                    state = store.show(cluster["contract_id"], 1)["state"]
+                except ContractError:
+                    pass
+            item.update(peer=cluster["peer"], peer_name=cluster.get("peer_name"), state=state)
         out.append(item)
     return out
 
 
 # -----------------------------
-# Agent
+# Agent: one pass per Global liveness tick
 # -----------------------------
 
-def _publish(cluster: dict) -> None:
-    """Send our own signed events for the cluster's contract to the broker."""
+def _publish(party: dict) -> None:
+    """Send our own signed events for this party's contract to the broker."""
+    if not party.get("contract_id"):
+        return
     store = _contracts()
-    shown = store.show(cluster["contract_id"], 1, include_signed_events=True)
-    done = set(cluster.setdefault("published", []))
+    shown = store.show(party["contract_id"], 1, include_signed_events=True)
+    done = set(party.setdefault("published", []))
     for event in shown["events"]:
         if event["actor_deployment_id"] != store.local_deployment_id or event["event_id"] in done:
             continue
@@ -329,75 +397,111 @@ def _publish(cluster: dict) -> None:
             "protocol_version": "2", "terms": shown["terms"], "signed_event": event["signed_event"],
         })
         done.add(event["event_id"])
-    cluster["published"] = sorted(done)
+    party["published"] = sorted(done)
 
 
-def _sync_contract(cluster: dict, directory: list[dict]) -> str:
-    """Import the peer's events for this cluster's contract; return the local state."""
+def _sync_contract(party: dict, peer: str, directory: list[dict]) -> str:
+    """Import the peer's events for this party's contract; return the local state."""
     store = _contracts()
-    if not cluster.get("contract_id"):
-        # Member: the owner's proposal names us; adopt it.
+    if not party.get("contract_id"):
+        # Member: adopt the owner's proposal that names both of us -- the
+        # newest one that is not already revoked (an earlier cluster's may be).
+        candidates = []
         for item in directory:
             terms = item.get("terms") or {}
-            if cluster.get("peer") in (terms.get("deployment_a"), terms.get("deployment_b")) and item["version"] == 1:
-                cluster["contract_id"] = item["contract_id"]
-                break
-        else:
-            return cluster["state"]
+            parties = {terms.get("deployment_a"), terms.get("deployment_b")}
+            if parties != {peer, store.local_deployment_id} or item["version"] != 1 or not item.get("events"):
+                continue
+            store.import_bundle(canonical_json({
+                "protocol_version": "2", "terms": terms, "events": item["events"],
+            }))
+            if store.show(item["contract_id"], 1)["state"] != "revoked":
+                candidates.append((terms["valid_from"], item["contract_id"]))
+        if not candidates:
+            return party["state"]
+        party["contract_id"] = max(candidates)[1]
     for item in directory:
-        if item["contract_id"] == cluster["contract_id"] and item.get("terms"):
+        if item["contract_id"] == party["contract_id"] and item.get("terms"):
             store.import_bundle(canonical_json({
                 "protocol_version": "2", "terms": item["terms"], "events": item["events"],
             }))
-    return store.show(cluster["contract_id"], 1)["state"]
+    return store.show(party["contract_id"], 1)["state"]
+
+
+def _advance(party: dict, peer: str, directory: list[dict], *, label: str, notify, is_member: bool) -> None:
+    """Move one bilateral contract one step; notify on active / revoked."""
+    before = party.get("state")
+    if before in ("pending", "revoked"):
+        return
+    state = _sync_contract(party, peer, directory)
+    store = _contracts()
+    if state == "proposed" and is_member:
+        store.accept(party["contract_id"], 1, actor_admin_ref="cluster")
+        state = store.activate(party["contract_id"], 1, actor_admin_ref="cluster")["state"]
+    elif state == "accepted":
+        mine = {e["actor_deployment_id"] for e in store.show(party["contract_id"], 1)["events"]
+                if e["event_type"] == "activate"}
+        if store.local_deployment_id not in mine:
+            state = store.activate(party["contract_id"], 1, actor_admin_ref="cluster")["state"]
+    _publish(party)
+    if party.get("contract_id"):
+        party["state"] = state
+    if state == "active" and before != "active":
+        notify(f"[cluster] {label} is active")
+    if state == "revoked" and before != "revoked":
+        notify(f"[cluster] {label} was ended by the other lab")
+
+
+def _collect_joins(name: str, cluster: dict, broker_invites: list[dict], notify) -> None:
+    """Owner: turn redeemed invites into members; drop invites Global no longer holds."""
+    seen = {item["invite_id"]: item for item in broker_invites}
+    for invite_id, invite in list(cluster["invites"].items()):
+        item = seen.get(invite_id)
+        if item is None:
+            del cluster["invites"][invite_id]  # expired or consumed elsewhere
+            continue
+        if not item.get("joiner"):
+            continue
+        joiner = item["joiner"]
+        secret = bytes.fromhex(invite["secret"])
+        if not hmac.compare_digest(joiner["tag"], _tag(secret, invite_id, joiner["identity"])):
+            notify(f"[cluster] {name}: a join arrived without the invite secret; ignored")
+            del cluster["invites"][invite_id]
+            continue
+        peer = joiner["identity"]["deployment_id"]
+        member = cluster["members"].setdefault(peer, {"published": [], "joined_at": int(time.time())})
+        member.update(display_name=joiner.get("display_name"), joiner=joiner["identity"], state="pending")
+        del cluster["invites"][invite_id]
+        if invite.get("auto", True):
+            _propose(cluster, member, peer)
+        else:
+            notify(f"[cluster] {peer} wants to join {name}: run `cluster accept {name}`")
 
 
 def tick(notify=None) -> None:
-    """One agent pass: move every cluster one step closer to active."""
+    """One agent pass: move every cluster and member one step closer to active."""
     notify = notify or (lambda text: None)
     clusters = load()
     if not clusters:
         return
     directory = None
+    broker_invites = None
     for name, cluster in clusters.items():
-        state = cluster.get("state")
-        if state in ("created", "pending", "revoked"):
-            continue
-        if state == "invited":
-            for item in g.call("GET", "/v2/broker/invites")["invites"]:
-                if item["invite_id"] != cluster["invite_id"] or not item.get("joiner"):
-                    continue
-                joiner = item["joiner"]
-                secret = bytes.fromhex(cluster["secret"])
-                if not hmac.compare_digest(joiner["tag"], _tag(secret, cluster["invite_id"], joiner["identity"])):
-                    notify(f"[cluster] {name}: a join arrived without the invite secret; ignored")
-                    continue
-                cluster.update(state="pending", joiner=joiner["identity"])
+        if cluster["role"] == "owner":
+            if cluster["invites"]:
+                if broker_invites is None:
+                    broker_invites = g.call("GET", "/v2/broker/invites")["invites"]
+                _collect_joins(name, cluster, broker_invites, notify)
                 save(clusters)
-                if cluster.get("auto"):
-                    accept(name)
-                    clusters = load()
-                else:
-                    notify(f"[cluster] {joiner['identity']['deployment_id']} wants to join {name}: "
-                           f"run `cluster accept {name}`")
-            continue
-        if directory is None:
-            directory = g.call("GET", "/v2/broker/contracts")["contracts"]
-        contract_state = _sync_contract(cluster, directory)
-        store = _contracts()
-        if contract_state == "proposed" and cluster["role"] == "member":
-            store.accept(cluster["contract_id"], 1, actor_admin_ref="cluster")
-            contract_state = store.activate(cluster["contract_id"], 1, actor_admin_ref="cluster")["state"]
-        elif contract_state == "accepted":
-            mine = {e["actor_deployment_id"] for e in store.show(cluster["contract_id"], 1)["events"]
-                    if e["event_type"] == "activate"}
-            if store.local_deployment_id not in mine:
-                contract_state = store.activate(cluster["contract_id"], 1, actor_admin_ref="cluster")["state"]
-        if cluster.get("contract_id"):
-            _publish(cluster)
-        if contract_state == "active" and state != "active":
-            notify(f"[cluster] {name} is active")
-        if contract_state == "revoked" and state != "revoked":
-            notify(f"[cluster] {name} was ended by the other lab; `cluster remove {name}` forgets it")
-        cluster["state"] = contract_state if cluster.get("contract_id") else state
+            if not cluster["members"]:
+                continue
+            if directory is None:
+                directory = g.call("GET", "/v2/broker/contracts")["contracts"]
+            for peer, member in cluster["members"].items():
+                _advance(member, peer, directory, label=f"{name}: {member.get('display_name') or peer}",
+                         notify=notify, is_member=False)
+        else:
+            if directory is None:
+                directory = g.call("GET", "/v2/broker/contracts")["contracts"]
+            _advance(cluster, cluster["peer"], directory, label=name, notify=notify, is_member=True)
         save(clusters)

{remoterf_server-1.1.0.dev28.dist-info → remoterf_server-1.1.0.dev30.dist-info}/METADATA

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

{remoterf_server-1.1.0.dev28.dist-info → remoterf_server-1.1.0.dev30.dist-info}/RECORD

@@ -52,7 +52,7 @@ remoteRF_server/host/host_tunnel_server.py,sha256=sz06xOtFbaDZSy1UQfw6faKhJmuOy5
 remoteRF_server/server/__init__.py,sha256=-1h_xQjiE66oiWRO-vnLGJ4smpgUNhFuV-ZreW9_tD4,667
 remoteRF_server/server/acc_perms.py,sha256=2loCvstVu8uvsb2uCv2Sk7iNQ5GyO_sBIkPQFzqOaRI,13334
 remoteRF_server/server/cert_provider.py,sha256=CRDrZL4DSf-eL6wzPJzwucrzPLOr2PvNRq5V--oZtr0,6272
-remoteRF_server/server/commands.py,sha256=9R-RlMRrUyZG0COydBThJcqJ2qNXdlGC4c-qh8hrAW8,17018
+remoteRF_server/server/commands.py,sha256=dH19PK86cUiZhTnN9jC1RdM1t_t6dPuL6x-bdACxkSY,17008
 remoteRF_server/server/console.py,sha256=J91LfwPVmBgielOxfE740NOYduekggyZkqi-47y_A4w,4472
 remoteRF_server/server/control.py,sha256=Uq1Fk0zIoHHX_EXfz3OuNle8urvO_UhAiB5Lk5cs2e4,5177
 remoteRF_server/server/device_manager.py,sha256=nRTvk_jeZFU3QnlM6qf3DIckU2V2e_gyDeD5gW14KQI,38802
@@ -70,8 +70,8 @@ remoteRF_server/server/deployment/__init__.py,sha256=YV86uafd8XiGD7sLaqNfO5xxmt5
 remoteRF_server/server/deployment/capabilities.py,sha256=20RxmGG03VoQQZnV3jGhc-3i9B5hOl5fCopnsErFjPk,872
 remoteRF_server/server/federation/__init__.py,sha256=MZLqqh0Lzzh1t59VXrkS_bdpMO5znk1UVBjRGPvnUCg,735
 remoteRF_server/server/federation/admin.py,sha256=t3F17FIytekzclPICmaFJEA4-F5OuWcDx3rgmFga17A,9187
-remoteRF_server/server/federation/cli.py,sha256=TvklPVxG-6yPa0dUhiFo4tceGnrqe6euwKOHEz6NY3U,5952
-remoteRF_server/server/federation/cluster.py,sha256=mjp___eBcWwZK8xVi-2l_sX9dct1tHZrgqEZ5xugY0k,14933
+remoteRF_server/server/federation/cli.py,sha256=Ax0tQw7_giLUP5lX1Y6x3sS1cbUbU2PxYur5k_5f3Po,7028
+remoteRF_server/server/federation/cluster.py,sha256=2C8ys2BwUSxCLlYGvNjWU840q8e6H2ShGfl380yzA0I,19970
 remoteRF_server/server/federation/contracts.py,sha256=NYh7lb_9etJHFfzXwevjC4HfSBUypLxg5xGeBgydLF4,29305
 remoteRF_server/server/federation/destination.py,sha256=XawmGCiVbL_MfNNn8xwV9_bYxUDW1L7efCpL11K2JAc,35909
 remoteRF_server/server/federation/devices.py,sha256=n5MvnD0UZyl4sFpiekG9ProanWXTYizYq6YchCflLgY,18061
@@ -90,9 +90,9 @@ remoteRF_server/tools/gen_certs.py,sha256=Vbyu8JjRu__UYPVmyCRXt5SOw0Za1HV7g1md3G
 remoteRF_server/tools/gist_status.py,sha256=SFv2iQgQrIKT9gxKrU-_Dr7S0p0rE4wQM6J3OC6FcoM,4649
 remoteRF_server/tools/gist_status_testing.py,sha256=IYw7UkPjAUpKDTtIlnYGb5g6SJkwz4TRGUfJJ6f4LhQ,2690
 remoteRF_server/tools/introspect_uhd.py,sha256=vUpPb0rM9tsHPxWadS3EfMDE-gMd-TvNV0TjrZOQqBY,4531
-remoterf_server-1.1.0.dev28.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-remoterf_server-1.1.0.dev28.dist-info/METADATA,sha256=2nvyC9qOu-zwADY_pJnUNO6kvBTyKNq-SAwHgvoD-YE,42069
-remoterf_server-1.1.0.dev28.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-remoterf_server-1.1.0.dev28.dist-info/entry_points.txt,sha256=_bbKk65PfYi-n6zUjqOiOwcalf_Ws1TCGATIe1TukxE,136
-remoterf_server-1.1.0.dev28.dist-info/top_level.txt,sha256=NuYWe8dSx3qdbxshWBwOgx68EHmJ9I8Zvxam4ARsQ_I,30
-remoterf_server-1.1.0.dev28.dist-info/RECORD,,
+remoterf_server-1.1.0.dev30.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+remoterf_server-1.1.0.dev30.dist-info/METADATA,sha256=HAEJaoA51VNwScm3KxXvq650DbitxyOWXy1ChAXpD3s,42069
+remoterf_server-1.1.0.dev30.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+remoterf_server-1.1.0.dev30.dist-info/entry_points.txt,sha256=_bbKk65PfYi-n6zUjqOiOwcalf_Ws1TCGATIe1TukxE,136
+remoterf_server-1.1.0.dev30.dist-info/top_level.txt,sha256=NuYWe8dSx3qdbxshWBwOgx68EHmJ9I8Zvxam4ARsQ_I,30
+remoterf_server-1.1.0.dev30.dist-info/RECORD,,