sliftutils 1.7.28 → 1.7.29

package/storage/remoteStorage/storageController.ts

@@ -14,8 +14,9 @@ import { getTakeoverStamp } from "./deployTakeover";
 import {
     getStorageServerConfig, getTrust, getRequests, getLoadedBucket, writeBucketFile,
     deleteBucketFile, assertWritesAllowed, assertMutable, LoadedBucket,
-    getBucketConfig, listAccountBuckets, ServerBucketInfo,
+    getBucketConfig, listAccountBuckets, ServerBucketInfo, setRoutingChangedBroadcaster,
 } 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);
+    });
+}
+
+// The moment any routing config changes on this server, every connected client is told - clients
+// must never have to wait for a poll to learn the topology changed
+setRoutingChangedBroadcaster(() => {
+    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.d.ts

@@ -37,6 +37,7 @@ export type LoadedBucket = {
 };
 export declare function addExtraListenPort(port: number): void;
 export declare function getLoadedBucket(account: string, bucketName: string): Promise<LoadedBucket | undefined>;
+export declare function setRoutingChangedBroadcaster(broadcaster: () => void): void;
 export declare function assertMutable(bucket: LoadedBucket, filePath: string, writeTime: number): Promise<void>;
 export declare function writeBucketFile(account: string, bucketName: string, filePath: string, data: Buffer, config?: {
     lastModified?: number;

package/storage/remoteStorage/storageServerState.ts

@@ -563,6 +563,18 @@ export function getLoadedBucket(account: string, bucketName: string): Promise<Lo
     return loaded;
 }
 
+// Called whenever any bucket's routing config is applied (created, updated in place, or rebuilt).
+// storageController wires this to its connected-client broadcast, so every client is pushed the
+// change immediately - never waiting for a poll. (A callback, not an import - storageController
+// imports us, so importing it back would be a cycle.)
+let routingChangedBroadcaster: (() => void) | undefined;
+export function setRoutingChangedBroadcaster(broadcaster: () => void): void {
+    routingChangedBroadcaster = broadcaster;
+}
+function notifyRoutingChanged(): void {
+    routingChangedBroadcaster?.();
+}
+
 // 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 +622,7 @@ async function checkRoutingChanged(account: string, bucketName: string, config?:
         buckets.set(key, Promise.resolve(updated));
         scheduleWindowBoundaryRebuild(updated);
         scheduleBoundaryScans(updated);
+        notifyRoutingChanged();
         return;
     }
     console.log(`Rebuilding the store for bucket ${key} (${reason})`);
@@ -617,6 +630,7 @@ async function checkRoutingChanged(account: string, bucketName: string, config?:
         await loaded.store.dispose();
     }
     buckets.set(key, Promise.resolve(buildBucket(account, bucketName, routing, plan)));
+    notifyRoutingChanged();
 }
 
 // Per-write options are evaluated at the WRITE's time (and the key's route), not the current
@@ -657,6 +671,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)));
+        notifyRoutingChanged();
         console.log(`Created bucket ${key}`);
         return;
     }