sliftutils 1.7.19 → 1.7.21

package/index.d.ts

@@ -2871,7 +2871,9 @@ declare module "sliftutils/storage/remoteStorage/ArchivesRemote" {
         private lastDeniedLog;
         getDebugName(): string;
         isConnected(): boolean;
-        ping(): Promise<void>;
+        ping(): Promise<{
+            takeover?: string;
+        }>;
         private authenticate;
         private callAuthed;
         waitingForAccess(): Promise<{
@@ -3185,6 +3187,7 @@ declare module "sliftutils/storage/remoteStorage/createArchives" {
         getDebugName(): string;
         private getState;
         private init;
+        private createChainSource;
         private buildSources;
         private startConfigPoll;
         private configRefreshInFlight;
@@ -3295,6 +3298,10 @@ declare module "sliftutils/storage/remoteStorage/deployTakeover" {
      *  of the deploy overlap points at the alternate port. Pure, in-memory only - the stored routing
      *  config is never modified, and this must never be applied to data that gets persisted. */
     export declare function applyDeployRemap(routing: RemoteConfig): RemoteConfig;
+    /** A stamp of the current remap interpretation, advertised in ping responses - so every connected
+     *  client learns of a takeover within one ping interval, instead of waiting for its config poll
+     *  or a write rejection. */
+    export declare function getTakeoverStamp(): string | undefined;
     /** For the dying process: fast-write flush delays must never extend past this time, and after it
      *  fast writes flush immediately - so nothing is left in memory when the write window transfers. */
     export declare function getFlushDeadline(): number | undefined;
@@ -3375,6 +3382,10 @@ declare module "sliftutils/storage/remoteStorage/sourceWrapper" {
         private pings;
         private pingTimer;
         private loggedConnected;
+        private lastTakeoverStamp;
+        /** Fired when the source's advertised takeover stamp changes (a deploy takeover started or
+         *  ended) - the chain refreshes its config, so connected clients learn within one ping. */
+        onServedConfigChanged: (() => void) | undefined;
         /** Starts measuring this source's latency (for variable-shard target preference). Only hosted
          *  remotes are pinged; our own local server counts as 0, everything else as Infinity. */
         startPinging(): void;
@@ -3428,7 +3439,9 @@ declare module "sliftutils/storage/remoteStorage/storageController" {
         trustedMachines?: TrustRecord[];
     };
     export declare const RemoteStorageController: import("socket-function/SocketFunctionTypes").SocketRegistered<{
-        ping: () => Promise<void>;
+        ping: () => Promise<{
+            takeover?: string;
+        }>;
         authenticate: (token: AuthToken) => Promise<{
             machineId: string;
             ip: string;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "sliftutils",
-    "version": "1.7.19",
+    "version": "1.7.21",
     "main": "index.js",
     "license": "MIT",
     "files": [
@@ -57,7 +57,7 @@
         "node-forge": "https://github.com/sliftist/forge#e618181b469b07bdc70b968b0391beb8ef5fecd6",
         "preact-old-types": "^10.28.1",
         "shell-quote": "^1.8.3",
-        "socket-function": "^1.2.24",
+        "socket-function": "^1.2.26",
         "typenode": "^6.6.1",
         "typesafecss": "*",
         "ws": "^8.18.3",

package/storage/remoteStorage/ArchivesRemote.d.ts

@@ -29,7 +29,9 @@ export declare class ArchivesRemote implements IArchives {
     private lastDeniedLog;
     getDebugName(): string;
     isConnected(): boolean;
-    ping(): Promise<void>;
+    ping(): Promise<{
+        takeover?: string;
+    }>;
     private authenticate;
     private callAuthed;
     waitingForAccess(): Promise<{

package/storage/remoteStorage/ArchivesRemote.ts

@@ -77,8 +77,8 @@ export class ArchivesRemote implements IArchives {
         return SocketFunction.isNodeConnected(this.nodeId);
     }
 
-    public async ping(): Promise<void> {
-        await this.controller.ping();
+    public async ping(): Promise<{ takeover?: string }> {
+        return await this.controller.ping();
     }
 
     private async authenticate(): Promise<void> {

package/storage/remoteStorage/createArchives.d.ts

@@ -15,6 +15,7 @@ export declare class ArchivesChain implements IArchives {
     getDebugName(): string;
     private getState;
     private init;
+    private createChainSource;
     private buildSources;
     private startConfigPoll;
     private configRefreshInFlight;

package/storage/remoteStorage/createArchives.ts

@@ -223,6 +223,29 @@ export class ArchivesChain implements IArchives {
                     }
                 }
             }
+            // The server may be MID deploy-takeover: its getConfig returns the in-memory
+            // interpretation (window splits pointing at a successor's port), which is never in the
+            // routing file. A client connecting during the takeover must start on that
+            // interpretation, not discover it minutes later.
+            try {
+                let probeApi = found.probe.api;
+                if (probeApi) {
+                    let servedConfig = (await probeApi.getConfig()).remoteConfig;
+                    if (servedConfig) {
+                        let served = normalizeRemoteConfig(servedConfig);
+                        if (JSON.stringify(served) !== JSON.stringify(active) && getConfigVersion(served) >= getConfigVersion(active)) {
+                            console.log(`Adopting the server's in-memory routing interpretation at init for ${this.getDebugName()} (deploy takeover in progress)`);
+                            active = served;
+                            for (let source of sources) {
+                                source.dispose();
+                            }
+                            sources = await this.buildSources(active);
+                        }
+                    }
+                }
+            } catch {
+                // The raw routing config we already adopted still works
+            }
             // The routing fetches double as our first latency measurements: variable-shard picking
             // works immediately, instead of waiting for the first ping pass to land
             for (let source of sources) {
@@ -241,13 +264,23 @@ export class ArchivesChain implements IArchives {
         }
     }
 
+    private async createChainSource(sourceConfig: HostedConfig | BackblazeConfig): Promise<SourceWrapper> {
+        let source = await SourceWrapper.create(sourceConfig);
+        // A takeover stamp change in a ping means the server's routing interpretation changed
+        // (deploy takeover started/ended); refresh so we learn within one ping interval
+        source.onServedConfigChanged = () => {
+            console.log(`Storage ${source.getDebugName()} advertised a routing change (deploy takeover); refreshing config for ${this.getDebugName()}`);
+            void this.refreshActiveConfig().catch((e: Error) => console.error(`Config refresh failed for ${this.getDebugName()}: ${e.stack ?? e}`));
+        };
+        // Latency (for variable-shard target preference) is tracked from initialization on
+        source.startPinging();
+        return source;
+    }
+
     private async buildSources(config: RemoteConfig): Promise<SourceWrapper[]> {
         let sources: SourceWrapper[] = [];
         for (let sourceConfig of config.sources.map(normalizeSource)) {
-            let source = await SourceWrapper.create(sourceConfig);
-            // Latency (for variable-shard target preference) is tracked from initialization on
-            source.startPinging();
-            sources.push(source);
+            sources.push(await this.createChainSource(sourceConfig));
         }
         return sources;
     }
@@ -320,9 +353,7 @@ export class ArchivesChain implements IArchives {
                 oldByConfig.delete(key);
                 sources.push(old);
             } else {
-                let source = await SourceWrapper.create(sourceConfig);
-                source.startPinging();
-                sources.push(source);
+                sources.push(await this.createChainSource(sourceConfig));
             }
         }
         // In-flight requests still hold the old wrappers and finish fine; dispose just stops any

package/storage/remoteStorage/deployTakeover.d.ts

@@ -16,6 +16,10 @@ export declare function onTakeoverEvent(listener: (event: TakeoverEvent) => void
  *  of the deploy overlap points at the alternate port. Pure, in-memory only - the stored routing
  *  config is never modified, and this must never be applied to data that gets persisted. */
 export declare function applyDeployRemap(routing: RemoteConfig): RemoteConfig;
+/** A stamp of the current remap interpretation, advertised in ping responses - so every connected
+ *  client learns of a takeover within one ping interval, instead of waiting for its config poll
+ *  or a write rejection. */
+export declare function getTakeoverStamp(): string | undefined;
 /** For the dying process: fast-write flush delays must never extend past this time, and after it
  *  fast writes flush immediately - so nothing is left in memory when the write window transfers. */
 export declare function getFlushDeadline(): number | undefined;

package/storage/remoteStorage/deployTakeover.ts

@@ -392,6 +392,15 @@ export function applyDeployRemap(routing: RemoteConfig): RemoteConfig {
     return { version: routing.version, sources };
 }
 
+/** A stamp of the current remap interpretation, advertised in ping responses - so every connected
+ *  client learns of a takeover within one ping interval, instead of waiting for its config poll
+ *  or a write rejection. */
+export function getTakeoverStamp(): string | undefined {
+    let remap = current.remap;
+    if (!remap) return undefined;
+    return JSON.stringify(remap);
+}
+
 /** For the dying process: fast-write flush delays must never extend past this time, and after it
  *  fast writes flush immediately - so nothing is left in memory when the write window transfers. */
 export function getFlushDeadline(): number | undefined {