sliftutils 1.7.9 → 1.7.11

package/storage/remoteStorage/dist/remoteConfig.ts.cache

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.serializeRemoteConfig = exports.parseRoutingData = exports.normalizeRemoteConfig = exports.normalizeSource = exports.parseBackblazeUrl = exports.parseHostedUrl = exports.buildFileUrl = exports.getBucketBaseUrl = exports.getConfigVersion = exports.routeIntersection = exports.routesOverlap = exports.routeContains = exports.getRoute = exports.parseVariableRoute = exports.ROUTING_FILE = void 0;
+module.allowclient = true;
+const misc_1 = require("socket-function/src/misc");
+const bits_1 = require("socket-function/src/bits");
+const IArchives_1 = require("../IArchives");
+// Parsing / normalization of RemoteConfig (see IArchives.ts). Every bucket stores its own
+// configuration (a RemoteConfig) inside itself, at ROUTING_FILE. Writing that file creates the
+// bucket / reconfigures it (see storageServerState.ts); clients reconcile it by version (see
+// createArchives.ts).
+exports.ROUTING_FILE = "storage/storagerouting.json";
+const ROUTING_SUFFIX = "/" + exports.ROUTING_FILE;
+const ROUTE_PRECISION = 1000 * 1000 * 1000;
+/** The variable-shard route override embedded in the key ("<sentinel>_<value>", see VARIABLE_SHARD), or undefined when the key has no sentinel or the sentinel has no value yet. */
+function parseVariableRoute(key) {
+    let index = key.indexOf(IArchives_1.VARIABLE_SHARD);
+    if (index === -1)
+        return undefined;
+    let match = /^_(\d+(?:\.\d+)?)/.exec(key.slice(index + IArchives_1.VARIABLE_SHARD.length));
+    if (!match)
+        return undefined;
+    return +match[1];
+}
+exports.parseVariableRoute = parseVariableRoute;
+/** Where a key routes in [0, 1). A materialized variable-shard suffix completely overrides the hash. */
+function getRoute(key) {
+    let override = parseVariableRoute(key);
+    if (override !== undefined)
+        return override;
+    let hash = (0, bits_1.getBufferInt)((0, misc_1.sha256HashBuffer)(key));
+    return hash % ROUTE_PRECISION / ROUTE_PRECISION;
+}
+exports.getRoute = getRoute;
+// Route ranges are [start, end) - inclusive start, exclusive end
+function routeContains(route, value) {
+    if (!route)
+        return true;
+    return route[0] <= value && value < route[1];
+}
+exports.routeContains = routeContains;
+function routesOverlap(a, b) {
+    let [aStart, aEnd] = a || IArchives_1.FULL_ROUTE;
+    let [bStart, bEnd] = b || IArchives_1.FULL_ROUTE;
+    return aStart < bEnd && bStart < aEnd;
+}
+exports.routesOverlap = routesOverlap;
+/** The overlap of two route ranges, or undefined when they don't overlap. */
+function routeIntersection(a, b) {
+    let [aStart, aEnd] = a || IArchives_1.FULL_ROUTE;
+    let [bStart, bEnd] = b || IArchives_1.FULL_ROUTE;
+    let start = Math.max(aStart, bStart);
+    let end = Math.min(aEnd, bEnd);
+    if (start >= end)
+        return undefined;
+    return [start, end];
+}
+exports.routeIntersection = routeIntersection;
+// A missing version counts as -1, so any explicitly versioned config beats an unversioned one
+function getConfigVersion(config) {
+    var _a;
+    return (_a = config.version) !== null && _a !== void 0 ? _a : -1;
+}
+exports.getConfigVersion = getConfigVersion;
+/** Strips the routing-file suffix, leaving the bucket's public base URL (file paths append to it). */
+function getBucketBaseUrl(url) {
+    if (!url.endsWith(ROUTING_SUFFIX)) {
+        throw new Error(`Expected a bucket routing URL ending with ${JSON.stringify(ROUTING_SUFFIX)}, was ${JSON.stringify(url)}`);
+    }
+    return url.slice(0, -ROUTING_SUFFIX.length);
+}
+exports.getBucketBaseUrl = getBucketBaseUrl;
+function buildFileUrl(baseUrl, filePath) {
+    return baseUrl + "/" + filePath.split("/").map(encodeURIComponent).join("/");
+}
+exports.buildFileUrl = buildFileUrl;
+// Ex: https://storage2.vidgridweb.com:4445/file/exampleaccount/examplebucket/storage/storagerouting.json
+function parseHostedUrl(url) {
+    let base = getBucketBaseUrl(url);
+    let u = new URL(base);
+    if (u.protocol !== "https:") {
+        throw new Error(`Storage URL must use https, got ${JSON.stringify(u.protocol)} in ${JSON.stringify(url)}`);
+    }
+    let parts = u.pathname.split("/").filter(x => x);
+    if (parts.length !== 3 || parts[0] !== "file") {
+        throw new Error(`Expected a hosted bucket URL like https://host:port/file/<account>/<bucketName>${ROUTING_SUFFIX}, was ${JSON.stringify(url)}`);
+    }
+    return { address: u.hostname, port: +u.port || 443, account: decodeURIComponent(parts[1]), bucketName: decodeURIComponent(parts[2]) };
+}
+exports.parseHostedUrl = parseHostedUrl;
+// Ex: https://f002.backblazeb2.com/file/querysubtest-com-public-immutable/storage/storagerouting.json
+function parseBackblazeUrl(url) {
+    let base = getBucketBaseUrl(url);
+    let u = new URL(base);
+    let parts = u.pathname.split("/").filter(x => x);
+    if (parts.length !== 2 || parts[0] !== "file") {
+        throw new Error(`Expected a backblaze bucket URL like https://f002.backblazeb2.com/file/<bucketName>${ROUTING_SUFFIX}, was ${JSON.stringify(url)}`);
+    }
+    return { bucketName: decodeURIComponent(parts[1]) };
+}
+exports.parseBackblazeUrl = parseBackblazeUrl;
+function normalizeSource(source) {
+    if (typeof source !== "string") {
+        let window = source.validWindow;
+        if (!Array.isArray(window) || window.length !== 2 || !window.every(x => typeof x === "number")) {
+            throw new Error(`Object source configs must specify validWindow ([startMs, endMs] of the write times the source is valid for) - configuration changes must be scheduled, not flipped instantly. Use FULL_VALID_WINDOW when the source is always valid. Was ${JSON.stringify(window)} on ${JSON.stringify(source).slice(0, 500)}`);
+        }
+        let route = source.route;
+        if (route !== undefined && (!Array.isArray(route) || route.length !== 2 || !route.every(x => typeof x === "number") || route[0] < 0 || route[1] > 1 || route[0] >= route[1])) {
+            throw new Error(`Source route must be a [start, end) fraction range within [0, 1] with start < end, was ${JSON.stringify(route)} on ${JSON.stringify(source).slice(0, 500)}`);
+        }
+        if (source.readerDiskLimit !== undefined) {
+            if (typeof source.readerDiskLimit !== "number" || source.readerDiskLimit <= 0) {
+                throw new Error(`readerDiskLimit must be a positive byte count, was ${JSON.stringify(source.readerDiskLimit)} on ${JSON.stringify(source).slice(0, 500)}`);
+            }
+            if (!source.noFullSync) {
+                throw new Error(`readerDiskLimit requires noFullSync: a full copy cannot be bounded, only a read cache can. On ${JSON.stringify(source).slice(0, 500)}`);
+            }
+        }
+        if (source.type === "remote") {
+            // Throws if the URL is malformed, so bad configs are rejected before they're stored
+            parseHostedUrl(source.url);
+        }
+        return source;
+    }
+    let hostname = new URL(source).hostname;
+    if (hostname.endsWith(".backblazeb2.com")) {
+        // Validates the URL (throws on malformed) before it's stored; the bucket name is read back
+        // out of the URL at use sites, never stored on the config.
+        parseBackblazeUrl(source);
+        return { type: "backblaze", url: source, validWindow: IArchives_1.FULL_VALID_WINDOW };
+    }
+    parseHostedUrl(source);
+    return { type: "remote", url: source, validWindow: IArchives_1.FULL_VALID_WINDOW };
+}
+exports.normalizeSource = normalizeSource;
+function normalizeRemoteConfig(config) {
+    let result;
+    if (typeof config !== "string" && "sources" in config) {
+        result = { version: config.version, sources: config.sources.map(normalizeSource) };
+    }
+    else {
+        result = { sources: [normalizeSource(config)] };
+    }
+    // Mixed immutability makes no sense AMONG sources valid at the same time: a mutable source
+    // would accept overwrites that its immutable peers refuse to synchronize, forking their
+    // contents. Sources are grouped by transitively overlapping valid windows (absorb everything
+    // overlapping the group, extend the group's end, repeat) - a soft check that is correct as
+    // long as windows have clean breaks (a group ends exactly where the next begins).
+    let sources = result.sources.map(normalizeSource);
+    let sorted = [...sources];
+    (0, misc_1.sort)(sorted, x => x.validWindow[0]);
+    let group = [];
+    let groupEnd = 0;
+    function checkGroup() {
+        let immutableCount = group.filter(x => x.immutable).length;
+        if (immutableCount && immutableCount !== group.length) {
+            throw new Error(`Sources with overlapping valid windows must agree on immutability: ${immutableCount} of ${group.length} are immutable. Sources: ${JSON.stringify(group.map(x => ({ url: x.url, validWindow: x.validWindow, immutable: !!x.immutable })))}`);
+        }
+        // The sources valid at any instant must cover the whole key space, or keys routing into a
+        // gap could never be read
+        let routes = group.map(x => x.route || IArchives_1.FULL_ROUTE);
+        (0, misc_1.sort)(routes, x => x[0]);
+        let covered = 0;
+        for (let route of routes) {
+            if (route[0] > covered)
+                break;
+            covered = Math.max(covered, route[1]);
+        }
+        if (covered < 1) {
+            throw new Error(`Sources with overlapping valid windows must cover the full route space [0, 1); coverage stops at ${covered}. Sources: ${JSON.stringify(group.map(x => ({ url: x.url, validWindow: x.validWindow, route: x.route || IArchives_1.FULL_ROUTE })))}`);
+        }
+    }
+    for (let source of sorted) {
+        if (group.length && source.validWindow[0] >= groupEnd) {
+            checkGroup();
+            group = [];
+        }
+        group.push(source);
+        groupEnd = Math.max(groupEnd, source.validWindow[1]);
+    }
+    checkGroup();
+    return result;
+}
+exports.normalizeRemoteConfig = normalizeRemoteConfig;
+function parseRoutingData(data) {
+    let text = data.toString();
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch (e) {
+        throw new Error(`Routing config is not valid JSON (${String(e)}). Data: ${text.slice(0, 500)}`);
+    }
+    if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.sources)) {
+        throw new Error(`Routing config must be { version?, sources: [...] }, was ${text.slice(0, 500)}`);
+    }
+    return normalizeRemoteConfig(parsed);
+}
+exports.parseRoutingData = parseRoutingData;
+function serializeRemoteConfig(config) {
+    return Buffer.from(JSON.stringify(config, undefined, 4));
+}
+exports.serializeRemoteConfig = serializeRemoteConfig;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"remoteConfig.js","sourceRoot":"","sources":["remoteConfig.ts"],"names":[],"mappings":"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","sourcesContent":["module.allowclient = true;\n\nimport { sort, sha256HashBuffer } from \"socket-function/src/misc\";\nimport { getBufferInt } from \"socket-function/src/bits\";\nimport { RemoteConfig, RemoteConfigBase, HostedConfig, BackblazeConfig, FULL_VALID_WINDOW, FULL_ROUTE, VARIABLE_SHARD } from \"../IArchives\";\n\n// Parsing / normalization of RemoteConfig (see IArchives.ts). Every bucket stores its own\n// configuration (a RemoteConfig) inside itself, at ROUTING_FILE. Writing that file creates the\n// bucket / reconfigures it (see storageServerState.ts); clients reconcile it by version (see\n// createArchives.ts).\n\nexport const ROUTING_FILE = \"storage/storagerouting.json\";\nconst ROUTING_SUFFIX = \"/\" + ROUTING_FILE;\n\nconst ROUTE_PRECISION = 1000 * 1000 * 1000;\n\n/** The variable-shard route override embedded in the key (\"<sentinel>_<value>\", see VARIABLE_SHARD), or undefined when the key has no sentinel or the sentinel has no value yet. */\nexport function parseVariableRoute(key: string): number | undefined {\n    let index = key.indexOf(VARIABLE_SHARD);\n    if (index === -1) return undefined;\n    let match = /^_(\\d+(?:\\.\\d+)?)/.exec(key.slice(index + VARIABLE_SHARD.length));\n    if (!match) return undefined;\n    return +match[1];\n}\n\n/** Where a key routes in [0, 1). A materialized variable-shard suffix completely overrides the hash. */\nexport function getRoute(key: string): number {\n    let override = parseVariableRoute(key);\n    if (override !== undefined) return override;\n    let hash = getBufferInt(sha256HashBuffer(key));\n    return hash % ROUTE_PRECISION / ROUTE_PRECISION;\n}\n\n// Route ranges are [start, end) - inclusive start, exclusive end\nexport function routeContains(route: [number, number] | undefined, value: number): boolean {\n    if (!route) return true;\n    return route[0] <= value && value < route[1];\n}\nexport function routesOverlap(a: [number, number] | undefined, b: [number, number] | undefined): boolean {\n    let [aStart, aEnd] = a || FULL_ROUTE;\n    let [bStart, bEnd] = b || FULL_ROUTE;\n    return aStart < bEnd && bStart < aEnd;\n}\n/** The overlap of two route ranges, or undefined when they don't overlap. */\nexport function routeIntersection(a: [number, number] | undefined, b: [number, number] | undefined): [number, number] | undefined {\n    let [aStart, aEnd] = a || FULL_ROUTE;\n    let [bStart, bEnd] = b || FULL_ROUTE;\n    let start = Math.max(aStart, bStart);\n    let end = Math.min(aEnd, bEnd);\n    if (start >= end) return undefined;\n    return [start, end];\n}\n\n// A missing version counts as -1, so any explicitly versioned config beats an unversioned one\nexport function getConfigVersion(config: RemoteConfig): number {\n    return config.version ?? -1;\n}\n\n/** Strips the routing-file suffix, leaving the bucket's public base URL (file paths append to it). */\nexport function getBucketBaseUrl(url: string): string {\n    if (!url.endsWith(ROUTING_SUFFIX)) {\n        throw new Error(`Expected a bucket routing URL ending with ${JSON.stringify(ROUTING_SUFFIX)}, was ${JSON.stringify(url)}`);\n    }\n    return url.slice(0, -ROUTING_SUFFIX.length);\n}\n\nexport function buildFileUrl(baseUrl: string, filePath: string): string {\n    return baseUrl + \"/\" + filePath.split(\"/\").map(encodeURIComponent).join(\"/\");\n}\n\n// Ex: https://storage2.vidgridweb.com:4445/file/exampleaccount/examplebucket/storage/storagerouting.json\nexport function parseHostedUrl(url: string): { address: string; port: number; account: string; bucketName: string } {\n    let base = getBucketBaseUrl(url);\n    let u = new URL(base);\n    if (u.protocol !== \"https:\") {\n        throw new Error(`Storage URL must use https, got ${JSON.stringify(u.protocol)} in ${JSON.stringify(url)}`);\n    }\n    let parts = u.pathname.split(\"/\").filter(x => x);\n    if (parts.length !== 3 || parts[0] !== \"file\") {\n        throw new Error(`Expected a hosted bucket URL like https://host:port/file/<account>/<bucketName>${ROUTING_SUFFIX}, was ${JSON.stringify(url)}`);\n    }\n    return { address: u.hostname, port: +u.port || 443, account: decodeURIComponent(parts[1]), bucketName: decodeURIComponent(parts[2]) };\n}\n\n// Ex: https://f002.backblazeb2.com/file/querysubtest-com-public-immutable/storage/storagerouting.json\nexport function parseBackblazeUrl(url: string): { bucketName: string } {\n    let base = getBucketBaseUrl(url);\n    let u = new URL(base);\n    let parts = u.pathname.split(\"/\").filter(x => x);\n    if (parts.length !== 2 || parts[0] !== \"file\") {\n        throw new Error(`Expected a backblaze bucket URL like https://f002.backblazeb2.com/file/<bucketName>${ROUTING_SUFFIX}, was ${JSON.stringify(url)}`);\n    }\n    return { bucketName: decodeURIComponent(parts[1]) };\n}\n\nexport function normalizeSource(source: RemoteConfigBase): HostedConfig | BackblazeConfig {\n    if (typeof source !== \"string\") {\n        let window = source.validWindow;\n        if (!Array.isArray(window) || window.length !== 2 || !window.every(x => typeof x === \"number\")) {\n            throw new Error(`Object source configs must specify validWindow ([startMs, endMs] of the write times the source is valid for) - configuration changes must be scheduled, not flipped instantly. Use FULL_VALID_WINDOW when the source is always valid. Was ${JSON.stringify(window)} on ${JSON.stringify(source).slice(0, 500)}`);\n        }\n        let route = source.route;\n        if (route !== undefined && (!Array.isArray(route) || route.length !== 2 || !route.every(x => typeof x === \"number\") || route[0] < 0 || route[1] > 1 || route[0] >= route[1])) {\n            throw new Error(`Source route must be a [start, end) fraction range within [0, 1] with start < end, was ${JSON.stringify(route)} on ${JSON.stringify(source).slice(0, 500)}`);\n        }\n        if (source.readerDiskLimit !== undefined) {\n            if (typeof source.readerDiskLimit !== \"number\" || source.readerDiskLimit <= 0) {\n                throw new Error(`readerDiskLimit must be a positive byte count, was ${JSON.stringify(source.readerDiskLimit)} on ${JSON.stringify(source).slice(0, 500)}`);\n            }\n            if (!source.noFullSync) {\n                throw new Error(`readerDiskLimit requires noFullSync: a full copy cannot be bounded, only a read cache can. On ${JSON.stringify(source).slice(0, 500)}`);\n            }\n        }\n        if (source.type === \"remote\") {\n            // Throws if the URL is malformed, so bad configs are rejected before they're stored\n            parseHostedUrl(source.url);\n        }\n        return source;\n    }\n    let hostname = new URL(source).hostname;\n    if (hostname.endsWith(\".backblazeb2.com\")) {\n        // Validates the URL (throws on malformed) before it's stored; the bucket name is read back\n        // out of the URL at use sites, never stored on the config.\n        parseBackblazeUrl(source);\n        return { type: \"backblaze\", url: source, validWindow: FULL_VALID_WINDOW };\n    }\n    parseHostedUrl(source);\n    return { type: \"remote\", url: source, validWindow: FULL_VALID_WINDOW };\n}\n\nexport function normalizeRemoteConfig(config: RemoteConfig | RemoteConfigBase): RemoteConfig {\n    let result: RemoteConfig;\n    if (typeof config !== \"string\" && \"sources\" in config) {\n        result = { version: config.version, sources: config.sources.map(normalizeSource) };\n    } else {\n        result = { sources: [normalizeSource(config)] };\n    }\n    // Mixed immutability makes no sense AMONG sources valid at the same time: a mutable source\n    // would accept overwrites that its immutable peers refuse to synchronize, forking their\n    // contents. Sources are grouped by transitively overlapping valid windows (absorb everything\n    // overlapping the group, extend the group's end, repeat) - a soft check that is correct as\n    // long as windows have clean breaks (a group ends exactly where the next begins).\n    let sources = result.sources.map(normalizeSource);\n    let sorted = [...sources];\n    sort(sorted, x => x.validWindow[0]);\n    let group: typeof sources = [];\n    let groupEnd = 0;\n    function checkGroup() {\n        let immutableCount = group.filter(x => x.immutable).length;\n        if (immutableCount && immutableCount !== group.length) {\n            throw new Error(`Sources with overlapping valid windows must agree on immutability: ${immutableCount} of ${group.length} are immutable. Sources: ${JSON.stringify(group.map(x => ({ url: x.url, validWindow: x.validWindow, immutable: !!x.immutable })))}`);\n        }\n        // The sources valid at any instant must cover the whole key space, or keys routing into a\n        // gap could never be read\n        let routes = group.map(x => x.route || FULL_ROUTE);\n        sort(routes, x => x[0]);\n        let covered = 0;\n        for (let route of routes) {\n            if (route[0] > covered) break;\n            covered = Math.max(covered, route[1]);\n        }\n        if (covered < 1) {\n            throw new Error(`Sources with overlapping valid windows must cover the full route space [0, 1); coverage stops at ${covered}. Sources: ${JSON.stringify(group.map(x => ({ url: x.url, validWindow: x.validWindow, route: x.route || FULL_ROUTE })))}`);\n        }\n    }\n    for (let source of sorted) {\n        if (group.length && source.validWindow[0] >= groupEnd) {\n            checkGroup();\n            group = [];\n        }\n        group.push(source);\n        groupEnd = Math.max(groupEnd, source.validWindow[1]);\n    }\n    checkGroup();\n    return result;\n}\n\nexport function parseRoutingData(data: Buffer): RemoteConfig {\n    let text = data.toString();\n    let parsed: RemoteConfig;\n    try {\n        parsed = JSON.parse(text) as RemoteConfig;\n    } catch (e) {\n        throw new Error(`Routing config is not valid JSON (${String(e)}). Data: ${text.slice(0, 500)}`);\n    }\n    if (!parsed || typeof parsed !== \"object\" || !Array.isArray(parsed.sources)) {\n        throw new Error(`Routing config must be { version?, sources: [...] }, was ${text.slice(0, 500)}`);\n    }\n    return normalizeRemoteConfig(parsed);\n}\n\nexport function serializeRemoteConfig(config: RemoteConfig): Buffer {\n    return Buffer.from(JSON.stringify(config, undefined, 4));\n}\n"]}
+ /* _JS_SOURCE_HASH = "3a7b4001ca69930ddc2d211daa61b2c9ba6c78217ad2d7e2d7e5cd2ae549d03a"; */

package/storage/remoteStorage/dist/sourceWrapper.ts.cache

@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.SourceWrapper = exports.RETRY_GROWTH = exports.RETRY_MAX_DELAY = exports.RETRY_START_DELAY = void 0;
+module.allowclient = true;
+const misc_1 = require("socket-function/src/misc");
+const batching_1 = require("socket-function/src/batching");
+const getSecret_1 = require("../../misc/getSecret");
+const remoteConfig_1 = require("./remoteConfig");
+const ArchivesRemote_1 = require("./ArchivesRemote");
+const ArchivesUrl_1 = require("./ArchivesUrl");
+const backblaze_1 = require("../backblaze");
+const storageServerState_1 = require("./storageServerState");
+exports.RETRY_START_DELAY = 2 * 1000;
+exports.RETRY_MAX_DELAY = 5 * 60 * 1000;
+exports.RETRY_GROWTH = 1.5;
+const ACCESS_RECHECK_INTERVAL = 60 * 1000;
+const PING_INTERVAL = 60 * 1000;
+const PING_HISTORY = 10;
+async function hasBackblazeCreds() {
+    if (!(0, misc_1.isNode)())
+        return false;
+    try {
+        await (0, getSecret_1.getSecret)("backblaze.json.applicationKeyId");
+        await (0, getSecret_1.getSecret)("backblaze.json.applicationKey");
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+// One source of a RemoteConfig, as a usable IArchives. Reads fall back to the public-URL form when
+// we don't have API access; writes always attempt the API (so access granted later is picked up on
+// the next write). When a call fails while the WebSocket is down, noteFailure starts a background
+// reconnect loop with a ramping delay - it never blocks callers, it just keeps trying so the
+// connection eventually comes back. Sources without a WebSocket (backblaze, URL-form, our own
+// local server) report always-connected: they're last-resort sources where throwing is fine.
+class SourceWrapper {
+    constructor(config, 
+    // false for short-lived probe instances, which must never leave a retry loop behind
+    background) {
+        this.config = config;
+        this.background = background;
+        this.disposed = false;
+        this.reconnectRunning = false;
+        this.pings = [];
+    }
+    static async create(config, options) {
+        let wrapper = new SourceWrapper(config, (options === null || options === void 0 ? void 0 : options.background) !== false);
+        if (config.type === "backblaze") {
+            if (await hasBackblazeCreds()) {
+                wrapper.api = new backblaze_1.ArchivesBackblaze({ bucketName: (0, remoteConfig_1.parseBackblazeUrl)(config.url).bucketName, public: config.public, immutable: config.immutable });
+            }
+            else if ((0, misc_1.isNode)()) {
+                wrapper.writeBlocked = `No backblaze credentials for ${config.url}. Provide backblaze.json.applicationKeyId and backblaze.json.applicationKey via getSecret to enable API access.`;
+            }
+            else {
+                wrapper.writeBlocked = `Browsers cannot write to backblaze (bucket ${config.url})`;
+            }
+            if (!wrapper.api && config.public !== false) {
+                wrapper.url = new ArchivesUrl_1.ArchivesUrl((0, remoteConfig_1.getBucketBaseUrl)(config.url));
+            }
+            return wrapper;
+        }
+        let parsed = (0, remoteConfig_1.parseHostedUrl)(config.url);
+        let server = (0, misc_1.isNode)() && (0, storageServerState_1.getStorageServerConfigOptional)() || undefined;
+        if (server && parsed.address === server.domain && parsed.port === server.port) {
+            // A bucket hosted by our own process - use it directly instead of calling ourselves
+            wrapper.api = (0, storageServerState_1.getLocalArchives)(parsed.account, parsed.bucketName);
+            return wrapper;
+        }
+        wrapper.remote = new ArchivesRemote_1.ArchivesRemote({ url: config.url, accountName: config.accountName, waitForAccess: false });
+        wrapper.api = wrapper.remote;
+        if (config.public !== false) {
+            wrapper.url = new ArchivesUrl_1.ArchivesUrl((0, remoteConfig_1.getBucketBaseUrl)(config.url));
+        }
+        return wrapper;
+    }
+    getDebugName() {
+        return `source/${this.config.url}`;
+    }
+    isConnected() {
+        if (!this.remote)
+            return true;
+        return this.remote.isConnected();
+    }
+    /** 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. */
+    noteFailure() {
+        if (!this.background || this.disposed || this.reconnectRunning)
+            return;
+        if (this.isConnected())
+            return;
+        this.reconnectRunning = true;
+        void this.reconnectLoop();
+    }
+    async reconnectLoop() {
+        var _a, _b;
+        let retryDelay = exports.RETRY_START_DELAY;
+        while (true) {
+            await (0, batching_1.delay)(retryDelay);
+            if (this.disposed) {
+                this.reconnectRunning = false;
+                return;
+            }
+            if (this.isConnected())
+                break;
+            try {
+                // Any call re-establishes the WebSocket; the result doesn't matter
+                await ((_a = this.remote) === null || _a === void 0 ? void 0 : _a.getInfo(remoteConfig_1.ROUTING_FILE));
+                break;
+            }
+            catch (e) {
+                // Even a failing call (e.g. access denied) proves the connection is back
+                if (this.isConnected())
+                    break;
+                console.warn(`Cannot connect to storage source ${this.config.url}, retrying in ${Math.round(retryDelay / 1000)}s. ${(_b = e.stack) !== null && _b !== void 0 ? _b : e}`);
+            }
+            retryDelay = Math.min(exports.RETRY_MAX_DELAY, retryDelay * exports.RETRY_GROWTH);
+        }
+        this.reconnectRunning = false;
+        console.log(`Reconnected to storage source ${this.config.url}`);
+    }
+    // For hosted sources: cached access check, so reads know whether to use the API or the public
+    // URL form. Access, once seen, is assumed to stick; no-access is re-checked periodically (the
+    // check also registers our access request server-side, which logs the grant link).
+    async checkAccess() {
+        let remote = this.remote;
+        if (!remote)
+            return !!this.api;
+        let cached = this.accessCache;
+        if (cached && (cached.hasAccess || Date.now() - cached.time < ACCESS_RECHECK_INTERVAL)) {
+            return cached.hasAccess;
+        }
+        let waiting = await remote.waitingForAccess();
+        this.accessCache = { hasAccess: !waiting, time: Date.now() };
+        if (waiting) {
+            console.warn(`No access to storage account for ${this.config.url} (our machine ${waiting.machineId}, ip ${waiting.ip}). Reading via the public URL form where possible. Grant access at ${waiting.link}`);
+        }
+        return !waiting;
+    }
+    async read(run) {
+        if (this.api && await this.checkAccess()) {
+            return await run(this.api);
+        }
+        if (this.url) {
+            return await run(this.url);
+        }
+        if (this.api) {
+            // No public URL form - let the API call throw its own error (which includes the access
+            // instructions for hosted sources)
+            return await run(this.api);
+        }
+        throw new Error(`Source ${this.config.url} has no API access and no public URL form (public: false)`);
+    }
+    async hasWriteAccess() {
+        if (this.writeBlocked || !this.api)
+            return false;
+        return await this.api.hasWriteAccess();
+    }
+    /** 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() {
+        var _a, _b;
+        let remote = this.remote;
+        if (!remote || this.pingTimer || this.disposed)
+            return;
+        let measure = async () => {
+            let start = Date.now();
+            try {
+                await remote.ping();
+            }
+            catch (_a) {
+                return;
+            }
+            this.pings.push(Date.now() - start);
+            if (this.pings.length > PING_HISTORY) {
+                this.pings.shift();
+            }
+        };
+        void measure();
+        this.pingTimer = setInterval(() => {
+            void measure();
+        }, PING_INTERVAL);
+        (_b = (_a = this.pingTimer).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
+    }
+    /** Median of the recent pings. Sources that can't be pinged sort last (Infinity), except our
+     *  own in-process server, which is the best possible target (0). */
+    getLatency() {
+        if (!this.remote) {
+            if (this.config.type === "remote" && this.api)
+                return 0;
+            return Infinity;
+        }
+        if (!this.pings.length)
+            return Infinity;
+        let sorted = [...this.pings];
+        (0, misc_1.sort)(sorted, x => x);
+        return sorted[Math.floor(sorted.length / 2)];
+    }
+    /** Writes always go through the API, so a permission error throws to the caller on every write
+     *  (and access granted in the meantime is picked up automatically). */
+    async write(run) {
+        if (this.writeBlocked) {
+            throw new Error(this.writeBlocked);
+        }
+        let api = this.api;
+        if (!api) {
+            throw new Error(`Source ${this.config.url} has no API access, so it cannot accept writes`);
+        }
+        let result = await run(api);
+        this.accessCache = { hasAccess: true, time: Date.now() };
+        return result;
+    }
+    dispose() {
+        this.disposed = true;
+        if (this.pingTimer) {
+            clearInterval(this.pingTimer);
+        }
+    }
+}
+exports.SourceWrapper = SourceWrapper;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sourceWrapper.js","sourceRoot":"","sources":["sourceWrapper.ts"],"names":[],"mappings":"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","sourcesContent":["module.allowclient = true;\n\nimport { isNode, sort } from \"socket-function/src/misc\";\nimport { delay } from \"socket-function/src/batching\";\nimport { getSecret } from \"../../misc/getSecret\";\nimport { IArchives, HostedConfig, BackblazeConfig } from \"../IArchives\";\nimport { ROUTING_FILE, getBucketBaseUrl, parseHostedUrl, parseBackblazeUrl } from \"./remoteConfig\";\nimport { ArchivesRemote } from \"./ArchivesRemote\";\nimport { ArchivesUrl } from \"./ArchivesUrl\";\nimport { ArchivesBackblaze } from \"../backblaze\";\nimport { getStorageServerConfigOptional, getLocalArchives } from \"./storageServerState\";\n\nexport const RETRY_START_DELAY = 2 * 1000;\nexport const RETRY_MAX_DELAY = 5 * 60 * 1000;\nexport const RETRY_GROWTH = 1.5;\nconst ACCESS_RECHECK_INTERVAL = 60 * 1000;\nconst PING_INTERVAL = 60 * 1000;\nconst PING_HISTORY = 10;\n\nasync function hasBackblazeCreds(): Promise<boolean> {\n    if (!isNode()) return false;\n    try {\n        await getSecret(\"backblaze.json.applicationKeyId\");\n        await getSecret(\"backblaze.json.applicationKey\");\n        return true;\n    } catch {\n        return false;\n    }\n}\n\n// One source of a RemoteConfig, as a usable IArchives. Reads fall back to the public-URL form when\n// we don't have API access; writes always attempt the API (so access granted later is picked up on\n// the next write). When a call fails while the WebSocket is down, noteFailure starts a background\n// reconnect loop with a ramping delay - it never blocks callers, it just keeps trying so the\n// connection eventually comes back. Sources without a WebSocket (backblaze, URL-form, our own\n// local server) report always-connected: they're last-resort sources where throwing is fine.\nexport class SourceWrapper {\n    public api?: IArchives;\n    public url?: ArchivesUrl;\n    public writeBlocked?: string;\n    private remote?: ArchivesRemote;\n    private disposed = false;\n    private reconnectRunning = false;\n    private accessCache?: { hasAccess: boolean; time: number };\n\n    private constructor(\n        public config: HostedConfig | BackblazeConfig,\n        // false for short-lived probe instances, which must never leave a retry loop behind\n        private background: boolean,\n    ) { }\n\n    public static async create(config: HostedConfig | BackblazeConfig, options?: { background?: boolean }): Promise<SourceWrapper> {\n        let wrapper = new SourceWrapper(config, options?.background !== false);\n        if (config.type === \"backblaze\") {\n            if (await hasBackblazeCreds()) {\n                wrapper.api = new ArchivesBackblaze({ bucketName: parseBackblazeUrl(config.url).bucketName, public: config.public, immutable: config.immutable });\n            } else if (isNode()) {\n                wrapper.writeBlocked = `No backblaze credentials for ${config.url}. Provide backblaze.json.applicationKeyId and backblaze.json.applicationKey via getSecret to enable API access.`;\n            } else {\n                wrapper.writeBlocked = `Browsers cannot write to backblaze (bucket ${config.url})`;\n            }\n            if (!wrapper.api && config.public !== false) {\n                wrapper.url = new ArchivesUrl(getBucketBaseUrl(config.url));\n            }\n            return wrapper;\n        }\n        let parsed = parseHostedUrl(config.url);\n        let server = isNode() && getStorageServerConfigOptional() || undefined;\n        if (server && parsed.address === server.domain && parsed.port === server.port) {\n            // A bucket hosted by our own process - use it directly instead of calling ourselves\n            wrapper.api = getLocalArchives(parsed.account, parsed.bucketName);\n            return wrapper;\n        }\n        wrapper.remote = new ArchivesRemote({ url: config.url, accountName: config.accountName, waitForAccess: false });\n        wrapper.api = wrapper.remote;\n        if (config.public !== false) {\n            wrapper.url = new ArchivesUrl(getBucketBaseUrl(config.url));\n        }\n        return wrapper;\n    }\n\n    public getDebugName(): string {\n        return `source/${this.config.url}`;\n    }\n\n    public isConnected(): boolean {\n        if (!this.remote) return true;\n        return this.remote.isConnected();\n    }\n\n    /** Call after a request failed while isConnected() was false: starts (if not already running)\n     *  the background reconnect loop. Never blocks - the failed request still throws. */\n    public noteFailure(): void {\n        if (!this.background || this.disposed || this.reconnectRunning) return;\n        if (this.isConnected()) return;\n        this.reconnectRunning = true;\n        void this.reconnectLoop();\n    }\n\n    private async reconnectLoop(): Promise<void> {\n        let retryDelay = RETRY_START_DELAY;\n        while (true) {\n            await delay(retryDelay);\n            if (this.disposed) {\n                this.reconnectRunning = false;\n                return;\n            }\n            if (this.isConnected()) break;\n            try {\n                // Any call re-establishes the WebSocket; the result doesn't matter\n                await this.remote?.getInfo(ROUTING_FILE);\n                break;\n            } catch (e) {\n                // Even a failing call (e.g. access denied) proves the connection is back\n                if (this.isConnected()) break;\n                console.warn(`Cannot connect to storage source ${this.config.url}, retrying in ${Math.round(retryDelay / 1000)}s. ${(e as Error).stack ?? e}`);\n            }\n            retryDelay = Math.min(RETRY_MAX_DELAY, retryDelay * RETRY_GROWTH);\n        }\n        this.reconnectRunning = false;\n        console.log(`Reconnected to storage source ${this.config.url}`);\n    }\n\n    // For hosted sources: cached access check, so reads know whether to use the API or the public\n    // URL form. Access, once seen, is assumed to stick; no-access is re-checked periodically (the\n    // check also registers our access request server-side, which logs the grant link).\n    private async checkAccess(): Promise<boolean> {\n        let remote = this.remote;\n        if (!remote) return !!this.api;\n        let cached = this.accessCache;\n        if (cached && (cached.hasAccess || Date.now() - cached.time < ACCESS_RECHECK_INTERVAL)) {\n            return cached.hasAccess;\n        }\n        let waiting = await remote.waitingForAccess();\n        this.accessCache = { hasAccess: !waiting, time: Date.now() };\n        if (waiting) {\n            console.warn(`No access to storage account for ${this.config.url} (our machine ${waiting.machineId}, ip ${waiting.ip}). Reading via the public URL form where possible. Grant access at ${waiting.link}`);\n        }\n        return !waiting;\n    }\n\n    public async read<T>(run: (archives: IArchives) => Promise<T>): Promise<T> {\n        if (this.api && await this.checkAccess()) {\n            return await run(this.api);\n        }\n        if (this.url) {\n            return await run(this.url);\n        }\n        if (this.api) {\n            // No public URL form - let the API call throw its own error (which includes the access\n            // instructions for hosted sources)\n            return await run(this.api);\n        }\n        throw new Error(`Source ${this.config.url} has no API access and no public URL form (public: false)`);\n    }\n\n    public async hasWriteAccess(): Promise<boolean> {\n        if (this.writeBlocked || !this.api) return false;\n        return await this.api.hasWriteAccess();\n    }\n\n    private pings: number[] = [];\n    private pingTimer: ReturnType<typeof setInterval> | undefined;\n\n    /** Starts measuring this source's latency (for variable-shard target preference). Only hosted\n     *  remotes are pinged; our own local server counts as 0, everything else as Infinity. */\n    public startPinging(): void {\n        let remote = this.remote;\n        if (!remote || this.pingTimer || this.disposed) return;\n        let measure = async () => {\n            let start = Date.now();\n            try {\n                await remote.ping();\n            } catch {\n                return;\n            }\n            this.pings.push(Date.now() - start);\n            if (this.pings.length > PING_HISTORY) {\n                this.pings.shift();\n            }\n        };\n        void measure();\n        this.pingTimer = setInterval(() => {\n            void measure();\n        }, PING_INTERVAL);\n        (this.pingTimer as { unref?: () => void }).unref?.();\n    }\n\n    /** Median of the recent pings. Sources that can't be pinged sort last (Infinity), except our\n     *  own in-process server, which is the best possible target (0). */\n    public getLatency(): number {\n        if (!this.remote) {\n            if (this.config.type === \"remote\" && this.api) return 0;\n            return Infinity;\n        }\n        if (!this.pings.length) return Infinity;\n        let sorted = [...this.pings];\n        sort(sorted, x => x);\n        return sorted[Math.floor(sorted.length / 2)];\n    }\n\n    /** Writes always go through the API, so a permission error throws to the caller on every write\n     *  (and access granted in the meantime is picked up automatically). */\n    public async write<T>(run: (archives: IArchives) => Promise<T>): Promise<T> {\n        if (this.writeBlocked) {\n            throw new Error(this.writeBlocked);\n        }\n        let api = this.api;\n        if (!api) {\n            throw new Error(`Source ${this.config.url} has no API access, so it cannot accept writes`);\n        }\n        let result = await run(api);\n        this.accessCache = { hasAccess: true, time: Date.now() };\n        return result;\n    }\n\n    public dispose(): void {\n        this.disposed = true;\n        if (this.pingTimer) {\n            clearInterval(this.pingTimer);\n        }\n    }\n}\n"]}
+ /* _JS_SOURCE_HASH = "3a5c2a0fc81c1c0d6780259c6352627995fdb1e43a09267a810e41b274f48639"; */