Redesign hosted WebUI around a server workspace

src/main/java/com/bencodez/votingplugin/control/domain/InMemoryNodeRegistry.java

@@ -26,7 +26,7 @@
 public final class InMemoryNodeRegistry implements NodeRegistry {
     public static final Set<String> SUPPORTED_CAPABILITIES = Set.of("discovery.read", "presence.snapshot",
             ConfigurationOperations.CAPABILITY, ConfigurationOperations.FILE_CAPABILITY,
-            ConfigurationOperations.QUICK_SETUP_CAPABILITY);
+            ConfigurationOperations.QUICK_SETUP_CAPABILITY, "config.file-comments.v1");
     private static final Pattern ID = Pattern.compile("[A-Za-z0-9][A-Za-z0-9._-]{0,63}");
     private static final Pattern CAPABILITY = Pattern.compile("[a-z][a-z0-9.-]{0,63}");
     private static final Set<String> PLATFORMS = Set.of("BUNGEECORD", "VELOCITY", "BUKKIT");
@@ -43,6 +43,7 @@ public final class InMemoryNodeRegistry implements NodeRegistry {
     private final int maxTotalDetectedPlugins;
     private int retainedBackends;
     private int retainedDetectedPlugins;
+    private long membershipRevision;
 
     public InMemoryNodeRegistry(Clock clock, Duration offlineTimeout) {
         this(clock, offlineTimeout, MAX_TOTAL_BACKENDS, MAX_TOTAL_DETECTED_PLUGINS);
@@ -69,7 +70,7 @@ public InMemoryNodeRegistry(Clock clock, Duration offlineTimeout) {
     public synchronized RegistrationResult register(NodeRegistration registration) {
         validate(registration);
         Instant now = clock.instant();
-        reclaimOfflineTopology(now, registration.nodeId());
+        if (reclaimOfflineTopology(now, registration.nodeId())) membershipRevision++;
         StoredNode current = nodes.get(registration.nodeId());
         int replacementPluginTotal = retainedDetectedPlugins
                 - (current == null ? 0 : current.detectedPlugins.size()) + registration.detectedPlugins().size();
@@ -94,6 +95,7 @@ public synchronized RegistrationResult register(NodeRegistration registration) {
             return replacement;
         });
         retainedDetectedPlugins = replacementPluginTotal;
+        if (created.get()) membershipRevision++;
         return new RegistrationResult(view(result.get()), created.get());
     }
 
@@ -128,7 +130,7 @@ public synchronized SnapshotResult replacePresence(String nodeId, PresenceSnapsh
         validateId(nodeId, "nodeId");
         validateSnapshot(snapshot);
         Instant now = clock.instant();
-        reclaimOfflineTopology(now, nodeId);
+        if (reclaimOfflineTopology(now, nodeId)) membershipRevision++;
         AtomicBoolean applied = new AtomicBoolean();
         AtomicReference<StoredNode> result = new AtomicReference<>();
         nodes.computeIfPresent(nodeId, (ignored, existing) -> {
@@ -161,11 +163,21 @@ public synchronized SnapshotResult replacePresence(String nodeId, PresenceSnapsh
 
     @Override
     public List<NodeStatus> list(int offset, int limit) {
+        return page(offset, limit, null).items();
+    }
+
+    @Override
+    public synchronized RegistryPage page(int offset, int limit, Long expectedRevision) {
         if (offset < 0 || limit < 1 || limit > 100) {
             throw invalid("offset must be >= 0 and limit must be between 1 and 100");
         }
-        return nodes.values().stream().sorted(Comparator.comparing(node -> node.nodeId))
+        if (expectedRevision != null && expectedRevision.longValue() != membershipRevision) {
+            throw new ValidationException("REGISTRY_CHANGED", "Node registry changed during pagination",
+                    List.of("expectedRevision=" + expectedRevision, "actualRevision=" + membershipRevision));
+        }
+        List<NodeStatus> items = nodes.values().stream().sorted(Comparator.comparing(node -> node.nodeId))
                 .skip(offset).limit(limit).map(this::view).toList();
+        return new RegistryPage(items, membershipRevision, nodes.size());
     }
 
     @Override
@@ -210,16 +222,19 @@ private NodeStatus view(StoredNode node) {
                 node.backends, node.snapshotSequence, node.lastSeen, node.lastAuthenticatedUpdate, online);
     }
 
-    private void reclaimOfflineTopology(Instant now, String excludedNodeId) {
+    private boolean reclaimOfflineTopology(Instant now, String excludedNodeId) {
+        AtomicBoolean reclaimed = new AtomicBoolean();
         for (String candidate : List.copyOf(nodes.keySet())) {
             if (candidate.equals(excludedNodeId)) continue;
             nodes.computeIfPresent(candidate, (ignored, existing) -> {
                 if (now.isBefore(existing.lastSeen.plus(offlineTimeout))) return existing;
                 retainedDetectedPlugins -= existing.detectedPlugins.size();
                 retainedBackends -= existing.backends.size();
+                reclaimed.set(true);
                 return null;
             });
         }
+        return reclaimed.get();
     }
 
     private static void validate(NodeRegistration registration) {

src/main/java/com/bencodez/votingplugin/control/domain/NodeRegistry.java

@@ -11,11 +11,13 @@ public interface NodeRegistry {
     NodeStatus heartbeat(String nodeId, Heartbeat heartbeat);
     SnapshotResult replacePresence(String nodeId, PresenceSnapshot snapshot);
     List<NodeStatus> list(int offset, int limit);
+    RegistryPage page(int offset, int limit, Long expectedRevision);
     NodeStatus find(String nodeId);
     void requireSession(String nodeId, java.util.UUID sessionId);
     <T> T withSession(String nodeId, java.util.UUID sessionId,
                       java.util.function.Function<NodeStatus, T> action);
 
     record RegistrationResult(NodeStatus node, boolean created) { }
     record SnapshotResult(NodeStatus node, boolean applied) { }
+    record RegistryPage(List<NodeStatus> items, long revision, int total) { }
 }

src/main/java/com/bencodez/votingplugin/control/http/ControlHttpServer.java

@@ -224,7 +224,8 @@ private void handle(HttpExchange exchange) throws IOException {
                 case "NODE_NOT_FOUND", "OPERATION_NOT_FOUND" -> 404;
                 case "UNSUPPORTED_PROTOCOL", "INCOMPATIBLE_CAPABILITIES", "SESSION_MISMATCH",
                         "PREVIEW_INCOMPLETE", "APPROVAL_REQUIRED", "NODE_UNAVAILABLE", "OPERATION_LIMIT",
-                        "REGISTRY_LIMIT", "TASK_NOT_CLAIMED", "TASK_LEASE_EXPIRED", "SETUP_COMPLETE" -> 409;
+                        "REGISTRY_LIMIT", "REGISTRY_CHANGED", "TASK_NOT_CLAIMED", "TASK_LEASE_EXPIRED",
+                        "SETUP_COMPLETE" -> 409;
                 case "UNSUPPORTED_MEDIA_TYPE" -> 415;
                 default -> 400;
             };
@@ -380,8 +381,12 @@ private void route(HttpExchange exchange) throws IOException {
             Map<String, String> query = query(uri.getRawQuery());
             int offset = integer(query.getOrDefault("offset", "0"), "offset");
             int limit = integer(query.getOrDefault("limit", "50"), "limit");
-            BackendPage page = boundedNodePage(registry.list(offset, limit));
+            Long expectedRevision = query.containsKey("revision")
+                    ? longInteger(query.get("revision"), "revision") : null;
+            NodeRegistry.RegistryPage registryPage = registry.page(offset, limit, expectedRevision);
+            BackendPage page = boundedNodePage(registryPage.items());
             send(exchange, 200, Map.of("items", page.items(), "offset", offset, "limit", limit,
+                    "registryRevision", registryPage.revision(), "total", registryPage.total(),
                     "backendItemsReturned", page.backendItemsReturned(),
                     "backendItemsTruncated", page.backendItemsTruncated()));
             return;
@@ -788,6 +793,17 @@ private static int integer(String value, String name) {
         }
     }
 
+    private static long longInteger(String value, String name) {
+        try {
+            long parsed = Long.parseLong(value);
+            if (parsed < 0) throw new NumberFormatException();
+            return parsed;
+        } catch (NumberFormatException e) {
+            throw new ValidationException("VALIDATION_ERROR", "Request validation failed",
+                    List.of(name + " must be a non-negative integer"));
+        }
+    }
+
     private static Map<String, String> query(String raw) {
         Map<String, String> result = new HashMap<>();
         if (raw == null || raw.isBlank()) {