sliftutils 1.7.46 → 1.7.48

package/index.d.ts

@@ -3188,7 +3188,12 @@ declare module "sliftutils/storage/remoteStorage/createArchives" {
     /** The address, port, account, and bucket name a bucket routing URL addresses. Throws when the URL isn't a hosted bucket routing URL (https://host:port/file/<account>/<bucketName>/storage/storagerouting.json). */
     export { parseHostedUrl, parseBackblazeUrl, getBucketBaseUrl } from "./remoteConfig";
     export declare function createApiArchives(source: HostedConfig | BackblazeConfig): IArchives;
+    export type ArchivesChainOptions = {
+        /** Outside of node we default to read-only downloads over the public URLs (no API connection) when the config has public sources. Set this to connect to the API anyway - needed for writing, listing, and any other operation the plain URL form cannot serve. */
+        directConnect?: boolean;
+    };
     export declare class ArchivesChain implements IArchives {
+        private options?;
         private configured;
         private activeConfig;
         private statePromise;
@@ -3197,10 +3202,12 @@ declare module "sliftutils/storage/remoteStorage/createArchives" {
         private pollTimer;
         private disposed;
         private unsubscribeRoutingPush;
-        constructor(config: RemoteConfig | RemoteConfigBase);
+        constructor(config: RemoteConfig | RemoteConfigBase, options?: ArchivesChainOptions | undefined);
         getDebugName(): string;
         private getState;
         private init;
+        /** Clientside, a config with public sources is served entirely over plain URL downloads - no API connection, no access grant, and no writing. directConnect opts out of that. */
+        private isReadOnly;
         private createChainSource;
         private buildSources;
         private startConfigPoll;
@@ -3272,7 +3279,7 @@ declare module "sliftutils/storage/remoteStorage/createArchives" {
         getURLs(path: string): Promise<string[]>;
         dispose(): void;
     }
-    export declare function createArchives(config: RemoteConfig | RemoteConfigBase): ArchivesChain;
+    export declare function createArchives(config: RemoteConfig | RemoteConfigBase, options?: ArchivesChainOptions): ArchivesChain;
     export declare function listServerBuckets(config: {
         url: string;
         account: string;
@@ -3421,12 +3428,16 @@ declare module "sliftutils/storage/remoteStorage/sourceWrapper" {
         updateValidWindow(validWindow: [number, number]): void;
         static create(config: HostedConfig | BackblazeConfig, options?: {
             background?: boolean;
+            readOnly?: boolean;
         }): Promise<SourceWrapper>;
         getDebugName(): string;
         isConnected(): boolean;
         /** A source whose window has passed is never read from or written to (see the window checks in ArchivesChain), and an intermediate only exists for the minutes of a deploy switchover - on either, being unreachable is expected, not a problem to report. */
         private isConnectionProblemWorthReporting;
-        /** Call after a request failed while isConnected() was false: starts (if not already running) the background reconnect loop. Never blocks - the failed request still throws. */
+        private cooldownUntil;
+        /** A source that failed while disconnected is skipped by callers for SOURCE_FAILURE_COOLDOWN - but only while some other source can serve the request. When nothing else is usable, callers ignore this and try it anyway, so a total outage still retries every time. */
+        isOnCooldown(): boolean;
+        /** Call after a request failed while isConnected() was false: puts the source on cooldown and starts (if not already running) the background reconnect loop. Never blocks - the failed request still throws. */
         noteFailure(): void;
         private reconnectLoop;
         private checkAccess;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "sliftutils",
-    "version": "1.7.46",
+    "version": "1.7.48",
     "main": "index.js",
     "license": "MIT",
     "files": [

package/storage/remoteStorage/createArchives.d.ts

@@ -5,7 +5,12 @@ import { ServerBucketInfo, ActiveBucketInfo } from "./storageServerState";
 /** The address, port, account, and bucket name a bucket routing URL addresses. Throws when the URL isn't a hosted bucket routing URL (https://host:port/file/<account>/<bucketName>/storage/storagerouting.json). */
 export { parseHostedUrl, parseBackblazeUrl, getBucketBaseUrl } from "./remoteConfig";
 export declare function createApiArchives(source: HostedConfig | BackblazeConfig): IArchives;
+export type ArchivesChainOptions = {
+    /** Outside of node we default to read-only downloads over the public URLs (no API connection) when the config has public sources. Set this to connect to the API anyway - needed for writing, listing, and any other operation the plain URL form cannot serve. */
+    directConnect?: boolean;
+};
 export declare class ArchivesChain implements IArchives {
+    private options?;
     private configured;
     private activeConfig;
     private statePromise;
@@ -14,10 +19,12 @@ export declare class ArchivesChain implements IArchives {
     private pollTimer;
     private disposed;
     private unsubscribeRoutingPush;
-    constructor(config: RemoteConfig | RemoteConfigBase);
+    constructor(config: RemoteConfig | RemoteConfigBase, options?: ArchivesChainOptions | undefined);
     getDebugName(): string;
     private getState;
     private init;
+    /** Clientside, a config with public sources is served entirely over plain URL downloads - no API connection, no access grant, and no writing. directConnect opts out of that. */
+    private isReadOnly;
     private createChainSource;
     private buildSources;
     private startConfigPoll;
@@ -89,7 +96,7 @@ export declare class ArchivesChain implements IArchives {
     getURLs(path: string): Promise<string[]>;
     dispose(): void;
 }
-export declare function createArchives(config: RemoteConfig | RemoteConfigBase): ArchivesChain;
+export declare function createArchives(config: RemoteConfig | RemoteConfigBase, options?: ArchivesChainOptions): ArchivesChain;
 export declare function listServerBuckets(config: {
     url: string;
     account: string;

package/storage/remoteStorage/createArchives.ts

@@ -45,6 +45,11 @@ type ChainState = {
     sources: SourceWrapper[];
 };
 
+export type ArchivesChainOptions = {
+    /** Outside of node we default to read-only downloads over the public URLs (no API connection) when the config has public sources. Set this to connect to the API anyway - needed for writing, listing, and any other operation the plain URL form cannot serve. */
+    directConnect?: boolean;
+};
+
 function configWindowCurrent(config: HostedConfig | BackblazeConfig): boolean {
     let now = Date.now();
     let [start, end] = config.validWindow;
@@ -55,6 +60,34 @@ function configAcceptsWrites(config: HostedConfig | BackblazeConfig): boolean {
     return configWindowCurrent(config);
 }
 
+/** The fewest sources whose routes span the whole key space, or undefined when they leave a gap. */
+function coverRoutes(candidates: SourceWrapper[]): SourceWrapper[] | undefined {
+    let chosen: SourceWrapper[] = [];
+    let covered = 0;
+    while (covered < 1) {
+        let best: SourceWrapper | undefined;
+        let bestEnd = covered;
+        for (let source of candidates) {
+            let [start, end] = source.config.route || FULL_ROUTE;
+            if (start > covered) continue;
+            if (end > bestEnd) {
+                bestEnd = end;
+                best = source;
+            }
+        }
+        if (!best) return undefined;
+        chosen.push(best);
+        covered = bestEnd;
+    }
+    return chosen;
+}
+
+/** Drops sources that recently failed while disconnected - unless that would leave nothing, in which case a down source is still better than no source, and we retry it immediately. */
+function preferUsable(sources: SourceWrapper[]): SourceWrapper[] {
+    let usable = sources.filter(x => !x.isOnCooldown());
+    return usable.length && usable || sources;
+}
+
 export class ArchivesChain implements IArchives {
     private configured: RemoteConfig;
     private activeConfig: RemoteConfig;
@@ -65,7 +98,7 @@ export class ArchivesChain implements IArchives {
     private disposed = false;
     private unsubscribeRoutingPush: (() => void) | undefined;
 
-    constructor(config: RemoteConfig | RemoteConfigBase) {
+    constructor(config: RemoteConfig | RemoteConfigBase, private options?: ArchivesChainOptions) {
         this.configured = normalizeRemoteConfig(config);
         this.activeConfig = this.configured;
         this.unsubscribeRoutingPush = onServerRoutingChanged(() => {
@@ -107,8 +140,9 @@ export class ArchivesChain implements IArchives {
 
     private async init(): Promise<ChainState> {
         let configs = this.configured.sources.map(normalizeSource);
+        let readOnly = this.isReadOnly(this.configured);
         let fetches = await Promise.all(configs.map(async sourceConfig => {
-            let probe = await SourceWrapper.create(sourceConfig, { background: false });
+            let probe = await SourceWrapper.create(sourceConfig, { background: false, readOnly });
             let start = Date.now();
             try {
                 let existing = await probe.readRoutingConfig();
@@ -215,16 +249,23 @@ export class ArchivesChain implements IArchives {
         }
     }
 
-    private async createChainSource(sourceConfig: HostedConfig | BackblazeConfig): Promise<SourceWrapper> {
-        let source = await SourceWrapper.create(sourceConfig);
+    /** Clientside, a config with public sources is served entirely over plain URL downloads - no API connection, no access grant, and no writing. directConnect opts out of that. */
+    private isReadOnly(config: RemoteConfig): boolean {
+        if (this.options?.directConnect || isNode()) return false;
+        return config.sources.map(normalizeSource).some(x => x.public);
+    }
+
+    private async createChainSource(sourceConfig: HostedConfig | BackblazeConfig, readOnly: boolean): Promise<SourceWrapper> {
+        let source = await SourceWrapper.create(sourceConfig, { readOnly });
         source.startPinging();
         return source;
     }
 
     private async buildSources(config: RemoteConfig): Promise<SourceWrapper[]> {
+        let readOnly = this.isReadOnly(config);
         let sources: SourceWrapper[] = [];
         for (let sourceConfig of config.sources.map(normalizeSource)) {
-            sources.push(await this.createChainSource(sourceConfig));
+            sources.push(await this.createChainSource(sourceConfig, readOnly));
         }
         return sources;
     }
@@ -300,6 +341,7 @@ export class ArchivesChain implements IArchives {
             }
             list.push(source);
         }
+        let readOnly = this.isReadOnly(latest);
         let sources: SourceWrapper[] = [];
         for (let sourceConfig of latest.sources.map(normalizeSource)) {
             let old = oldByConfig.get(strippedKey(sourceConfig))?.shift();
@@ -307,7 +349,7 @@ export class ArchivesChain implements IArchives {
                 old.updateValidWindow(sourceConfig.validWindow);
                 sources.push(old);
             } else {
-                sources.push(await this.createChainSource(sourceConfig));
+                sources.push(await this.createChainSource(sourceConfig, readOnly));
             }
         }
         for (let leftovers of oldByConfig.values()) {
@@ -358,9 +400,11 @@ export class ArchivesChain implements IArchives {
         let recheckedAvailability = false;
         while (true) {
             let errors: string[] = [];
-            for (let source of state.sources) {
-                if (config.route !== undefined && !routeContains(source.config.route, config.route)) continue;
-                if (!configWindowCurrent(source.config)) continue;
+            let candidates = state.sources.filter(source =>
+                (config.route === undefined || routeContains(source.config.route, config.route))
+                && configWindowCurrent(source.config)
+            );
+            for (let source of preferUsable(candidates)) {
                 try {
                     if (config.apiOnly) {
                         let api = source.api;
@@ -393,7 +437,7 @@ export class ArchivesChain implements IArchives {
         let recheckedAvailability = false;
         while (true) {
             let state = await this.getState();
-            let target = state.sources.find(x => configAcceptsWrites(x.config) && (route === undefined || routeContains(x.config.route, route)));
+            let target = preferUsable(state.sources.filter(x => configAcceptsWrites(x.config) && (route === undefined || routeContains(x.config.route, route))))[0];
             if (!target) {
                 if (!recheckedAvailability) {
                     recheckedAvailability = true;
@@ -475,24 +519,10 @@ export class ArchivesChain implements IArchives {
 
     private selectCoveringSources(state: ChainState, excluded: Set<SourceWrapper>): SourceWrapper[] {
         let candidates = state.sources.filter(x => configWindowCurrent(x.config) && x.api && !excluded.has(x));
-        let chosen: SourceWrapper[] = [];
-        let covered = 0;
-        while (covered < 1) {
-            let best: SourceWrapper | undefined;
-            let bestEnd = covered;
-            for (let source of candidates) {
-                let [start, end] = source.config.route || FULL_ROUTE;
-                if (start > covered) continue;
-                if (end > bestEnd) {
-                    bestEnd = end;
-                    best = source;
-                }
-            }
-            if (!best) {
-                throw new Error(`Cannot cover the full route space for ${this.getDebugName()}: the available sources only cover up to ${covered} (some shards are down or URL-only)`);
-            }
-            chosen.push(best);
-            covered = bestEnd;
+        // Unlike the single-source paths, dropping a cooled-down source can leave a route gap - so the cooled-down set only comes back as a whole, when the healthy sources cannot cover everything on their own
+        let chosen = coverRoutes(candidates.filter(x => !x.isOnCooldown())) || coverRoutes(candidates);
+        if (!chosen) {
+            throw new Error(`Cannot cover the full route space for ${this.getDebugName()}: the available sources leave a gap (some shards are down or URL-only)`);
         }
         return chosen;
     }
@@ -632,8 +662,7 @@ export class ArchivesChain implements IArchives {
         while (true) {
             let state = await this.getState();
             let targetsByRoute = new Map<string, SourceWrapper>();
-            for (let source of state.sources) {
-                if (!configAcceptsWrites(source.config)) continue;
+            for (let source of preferUsable(state.sources.filter(x => configAcceptsWrites(x.config)))) {
                 let routeKey = JSON.stringify(source.config.route || FULL_ROUTE);
                 if (!targetsByRoute.has(routeKey)) {
                     targetsByRoute.set(routeKey, source);
@@ -672,7 +701,7 @@ export class ArchivesChain implements IArchives {
         let recheckedAvailability = false;
         while (true) {
             let state = await this.getState();
-            let target = state.sources.find(x => configAcceptsWrites(x.config) && routeContains(x.config.route, route));
+            let target = preferUsable(state.sources.filter(x => configAcceptsWrites(x.config) && routeContains(x.config.route, route)))[0];
             if (!target) {
                 if (!recheckedAvailability) {
                     recheckedAvailability = true;
@@ -737,8 +766,8 @@ export class ArchivesChain implements IArchives {
     }
 }
 
-export function createArchives(config: RemoteConfig | RemoteConfigBase): ArchivesChain {
-    return new ArchivesChain(config);
+export function createArchives(config: RemoteConfig | RemoteConfigBase, options?: ArchivesChainOptions): ArchivesChain {
+    return new ArchivesChain(config, options);
 }
 
 async function callServer<T>(url: string, run: (controller: typeof RemoteStorageController.nodes[string]) => Promise<T>): Promise<T> {