sliftutils 1.7.28 → 1.7.32

package/storage/remoteStorage/storageController.d.ts

@@ -36,6 +36,9 @@ export type AccessState = {
     grantAccessCommand?: string;
     trustedMachines?: TrustRecord[];
 };
+/** Called by storageServerState the moment any routing config is applied - clients must never
+ *  have to wait for a poll to learn the topology changed. */
+export declare function broadcastRoutingChanged(): void;
 export declare const RemoteStorageController: import("socket-function/SocketFunctionTypes").SocketRegistered<{
     ping: () => Promise<{
         takeover?: string;

package/storage/remoteStorage/storageController.ts

@@ -16,6 +16,7 @@ import {
     deleteBucketFile, assertWritesAllowed, assertMutable, LoadedBucket,
     getBucketConfig, listAccountBuckets, ServerBucketInfo,
 } from "./storageServerState";
+import { StorageClientController } from "./storageClientController";
 
 // The remote storage server's API. Authentication uses certs.ts machine identities: a client
 // proves it owns its machine key by signing a timestamped token (bound to this server, so tokens
@@ -105,6 +106,31 @@ function assertValidPath(path: string) {
     }
 }
 
+// Every client pings us (immediately on connect, then continuously), so pings tell us exactly who
+// our currently-connected clients are. Client nodeIds never reconnect (a reconnect is a NEW
+// nodeId), so the disconnect callback fully cleans an entry up.
+const connectedClients = new Set<string>();
+function trackCaller(): void {
+    let nodeId = SocketFunction.getCaller().nodeId;
+    if (connectedClients.has(nodeId)) return;
+    connectedClients.add(nodeId);
+    SocketFunction.onNextDisconnect(nodeId, () => {
+        connectedClients.delete(nodeId);
+    });
+}
+
+/** Called by storageServerState the moment any routing config is applied - clients must never
+ *  have to wait for a poll to learn the topology changed. */
+export function broadcastRoutingChanged(): void {
+    console.log(`Broadcasting routing config change to ${connectedClients.size} connected clients`);
+    for (let nodeId of [...connectedClients]) {
+        void StorageClientController.nodes[nodeId].routingConfigChanged().catch(() => {
+            // The client is gone (or too old to know the controller); the disconnect callback
+            // cleans the registry, nothing to do here
+        });
+    }
+}
+
 function getCallerMachineId(): string {
     let caller = SocketFunction.getCaller();
     let machineId = sessions.get(caller.nodeId);
@@ -155,8 +181,10 @@ async function getBucket(account: string, bucketName: string): Promise<LoadedBuc
 class RemoteStorageControllerBase {
     // Latency measurement (see SourceWrapper's pinging); no auth, it measures the transport. The
     // takeover stamp piggybacks on it so every connected client learns of a deploy takeover
-    // within one ping interval.
+    // within one ping interval. Pings also tell us who our clients ARE - the trackCaller
+    // registry is what routing-change broadcasts push to.
     async ping(): Promise<{ takeover?: string }> {
+        trackCaller();
         return { takeover: getTakeoverStamp() };
     }
 

package/storage/remoteStorage/storageServerState.ts

@@ -14,6 +14,7 @@ import { ROUTING_FILE, parseRoutingData, parseHostedUrl, buildFileUrl, getConfig
 import { applyDeployRemap, getTakeoverAltPort, getOwnWindowEndClip, onTakeoverEvent } from "./deployTakeover";
 import { createApiArchives } from "./createArchives";
 import type { IStorage } from "../IStorage";
+import { broadcastRoutingChanged } from "./storageController";
 import type { AccessRequest, TrustRecord } from "./storageController";
 import { getArg } from "./cliArgs";
 
@@ -563,6 +564,7 @@ export function getLoadedBucket(account: string, bucketName: string): Promise<Lo
     return loaded;
 }
 
+
 // Routing reloads are serialized per bucket, so concurrent writes/syncs can't rebuild the same
 // store twice in parallel
 const routingReloads = new Map<string, Promise<void>>();
@@ -610,6 +612,7 @@ async function checkRoutingChanged(account: string, bucketName: string, config?:
         buckets.set(key, Promise.resolve(updated));
         scheduleWindowBoundaryRebuild(updated);
         scheduleBoundaryScans(updated);
+        broadcastRoutingChanged();
         return;
     }
     console.log(`Rebuilding the store for bucket ${key} (${reason})`);
@@ -617,6 +620,7 @@ async function checkRoutingChanged(account: string, bucketName: string, config?:
         await loaded.store.dispose();
     }
     buckets.set(key, Promise.resolve(buildBucket(account, bucketName, routing, plan)));
+    broadcastRoutingChanged();
 }
 
 // Per-write options are evaluated at the WRITE's time (and the key's route), not the current
@@ -657,6 +661,7 @@ async function writeRoutingConfig(account: string, bucketName: string, data: Buf
     if (!loaded) {
         await new ArchivesDisk(getBucketFolder(account, bucketName)).set(ROUTING_FILE, data, { lastModified: config?.lastModified });
         buckets.set(key, Promise.resolve(buildBucket(account, bucketName, incoming)));
+        broadcastRoutingChanged();
         console.log(`Created bucket ${key}`);
         return;
     }