sliftutils 1.7.88 → 1.7.89

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.StoreConfig = void 0;
+const misc_1 = require("socket-function/src/misc");
+const IArchives_1 = require("../IArchives");
+// The configuration of ONE store, kept current. A store is named by its entries (see CommonConfig.name), and at any instant exactly one of them is in effect - the config write path enforces that - so "the configuration of this store right now" is a single entry, and everything the store does with routes, flags and limits reads it from here rather than being handed a snapshot that goes stale.
+class StoreConfig {
+    constructor(name, entries) {
+        this.name = name;
+        // Every entry naming this store, oldest window first - past ones included, because a stamped write or a scan can legitimately concern a window that has already ended
+        this.entries = [];
+        this.update(entries);
+    }
+    /** The routing config changed. Same store either way: its name did not change, so neither did its folder, its index, or the data in it. */
+    /** No entries is a real state, not an error: a store exists as soon as its folder does, and it may never have heard of a configuration (see StorePolicy). */
+    update(entries) {
+        let ordered = [...entries];
+        (0, misc_1.sort)(ordered, x => x.validWindow[0]);
+        this.entries = ordered;
+    }
+    all() {
+        return this.entries;
+    }
+    /**
+     * What this store is configured to be right now: the entry whose window contains this moment;
+     * failing that the next one due to start; failing that the last one to have ended.
+     *
+     * There is always an answer, and it matters that there is: a store between windows still holds
+     * data and still has to answer for it, so it needs a route and flags even when nothing is
+     * currently pointing writes at it. Which of the three cases produced the answer is deliberately
+     * not exposed - the valid window itself is what says whether writes belong here, and every write
+     * is checked against it separately.
+     */
+    current() {
+        let now = Date.now();
+        let containing = this.entries.find(x => x.validWindow[0] <= now && now < x.validWindow[1]);
+        if (containing)
+            return containing;
+        let upcoming = this.entries.find(x => x.validWindow[0] > now);
+        if (upcoming)
+            return upcoming;
+        let last = this.entries[this.entries.length - 1];
+        if (last)
+            return last;
+        return UNCONFIGURED;
+    }
+}
+exports.StoreConfig = StoreConfig;
+// A store nobody has configured: always valid, the whole key space, no delays and no limits. Every one of these is the answer that does the least - it holds its own data and nothing else happens to it - which is what makes a store usable before it has ever seen a config.
+const UNCONFIGURED = { validWindow: IArchives_1.FULL_VALID_WINDOW };
+//# sourceMappingURL=data:application/json;base64,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
+ /* _JS_SOURCE_HASH = "696854eab64026ab54a84df68537b6018f1f3e7d4f5bceb692aa1fc72ff2e347"; */

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

@@ -1,21 +1,28 @@
-"use strict"; var console = (function shimConsole() {             let baseConsole = globalThis.console;             if (typeof window !== "undefined")                 return baseConsole;             let name = __filename.replaceAll("\\", "/").split("/").pop();             let dirName = __dirname.replaceAll("\\", "/").split("/").pop();             let context = {                 __FILE__: __filename,                 __DIR__: __dirname,                 __NAME__: name,                 __DIRNAME__: dirName             };             let newConsole = {                 ...baseConsole             };             for (let shim of ["log", "info", "warn", "error"]) {                 newConsole[shim] = (...args) => {                     args.push(context);                     baseConsole[shim](...args);                 };             }             newConsole.__context = context;             return newConsole;         })(); "use strict";
+"use strict";
 Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
-//exports.computeStorePlan = exports.selectEntryAt = exports.findSelfIndexes = void 0;
+//exports.planSelfStores = exports.previousWindowOwners = exports.selectEntryAt = exports.findSelfIndexes = exports.isSelfSource = void 0;
 const misc_1 = require("socket-function/src/misc");
 const IArchives_1 = require("../IArchives");
 const remoteConfig_1 = require("./remoteConfig");
 const serverConfig_1 = require("./serverConfig");
 // Turns a bucket's routing config into this server's store plan: which of the entries are us, what stores (one per route) we run, and which peers each store synchronizes from.
+/** Whether a config entry is THIS server's copy of this bucket - the same account and bucket, at an address this process answers on. */
+function isSelfSource(source, account, bucketName) {
+    if (source.type !== "remote")
+        return false;
+    let parsed = (0, remoteConfig_1.parseHostedUrl)(source.url);
+    if (parsed.account !== account || parsed.bucketName !== bucketName)
+        return false;
+    return (0, serverConfig_1.isOwnAddress)(parsed.address, parsed.port);
+}
+exports.isSelfSource = isSelfSource;
 function findSelfIndexes(routing, account, bucketName) {
     let indexes = [];
     for (let i = 0; i < routing.sources.length; i++) {
         let source = routing.sources[i];
-        if (typeof source === "string" || source.type !== "remote")
-            continue;
-        let parsed = (0, remoteConfig_1.parseHostedUrl)(source.url);
-        if (parsed.account !== account || parsed.bucketName !== bucketName)
+        if (typeof source === "string")
             continue;
-        if ((0, serverConfig_1.isOwnAddress)(parsed.address, parsed.port)) {
+        if (isSelfSource(source, account, bucketName)) {
             indexes.push(i);
         }
     }
@@ -44,6 +51,87 @@ function selectEntryAt(entries, time, route) {
     return best;
 }
 exports.selectEntryAt = selectEntryAt;
+/** The parts of `ranges` that `cut` does not cover, plus the single range spanning what it did. Routes are half-open [start, end), so subtracting one from another leaves at most a piece on each side. */
+function subtractRoute(ranges, cut) {
+    let remaining = [];
+    let claimed;
+    for (let range of ranges) {
+        let overlap = (0, remoteConfig_1.routeIntersection)(range, cut);
+        if (!overlap) {
+            remaining.push(range);
+            continue;
+        }
+        claimed = claimed && [Math.min(claimed[0], overlap[0]), Math.max(claimed[1], overlap[1])] || overlap;
+        if (range[0] < overlap[0])
+            remaining.push([range[0], overlap[0]]);
+        if (overlap[1] < range[1])
+            remaining.push([overlap[1], range[1]]);
+    }
+    return { remaining, claimed };
+}
+/**
+ * Who held each slice of our route in the window before windowStart, for every self entry whose
+ * window starts exactly then. This is the whole of "who do we take over from": a store taking over a
+ * route may be taking it from several previous owners at once (their shards need not line up with
+ * ours), and from itself for the parts it already held.
+ *
+ * A self entry is skipped when an EARLIER entry valid at the boundary already covers its whole route:
+ * config order is priority, so that entry is the write target and we are not the one taking over.
+ * Owners are then resolved in config order too, each claiming the part of our route still unclaimed -
+ * the same first-match-wins rule that picks a write target at any other moment.
+ *
+ * Pure: config in, plan out. Nothing here reads a store, a clock, or the network.
+ */
+function previousWindowOwners(config, windowStart, selfIndexes) {
+    let selfIndexSet = new Set(selfIndexes);
+    let previousTime = windowStart - 1;
+    let validAt = (source, time) => source.validWindow[0] <= time && time < source.validWindow[1];
+    let byRoute = new Map();
+    for (let selfIndex of selfIndexes) {
+        let self = config.sources[selfIndex];
+        if (typeof self === "string" || self.validWindow[0] !== windowStart)
+            continue;
+        let selfRoute = self.route || IArchives_1.FULL_ROUTE;
+        let shadowed = false;
+        for (let i = 0; i < selfIndex; i++) {
+            let other = config.sources[i];
+            if (typeof other === "string" || !validAt(other, windowStart))
+                continue;
+            let route = other.route || IArchives_1.FULL_ROUTE;
+            if (route[0] <= selfRoute[0] && selfRoute[1] <= route[1]) {
+                shadowed = true;
+                break;
+            }
+        }
+        if (shadowed)
+            continue;
+        // Keyed by both: one name can take over several routes at the same boundary, and each is pulled separately
+        let handoverKey = `${self.name}|${JSON.stringify(selfRoute)}`;
+        let handover = byRoute.get(handoverKey);
+        if (!handover) {
+            handover = { name: self.name, route: selfRoute, scanOwnDisk: false, remotes: new Map() };
+            byRoute.set(handoverKey, handover);
+        }
+        let unclaimed = [[selfRoute[0], selfRoute[1]]];
+        for (let i = 0; i < config.sources.length && unclaimed.length; i++) {
+            let other = config.sources[i];
+            if (typeof other === "string" || !validAt(other, previousTime))
+                continue;
+            let { remaining, claimed } = subtractRoute(unclaimed, other.route || IArchives_1.FULL_ROUTE);
+            unclaimed = remaining;
+            if (!claimed)
+                continue;
+            if (selfIndexSet.has(i)) {
+                handover.scanOwnDisk = true;
+                continue;
+            }
+            let existing = handover.remotes.get(i);
+            handover.remotes.set(i, existing && [Math.min(existing[0], claimed[0]), Math.max(existing[1], claimed[1])] || claimed);
+        }
+    }
+    return [...byRoute.values()].filter(x => x.scanOwnDisk || x.remotes.size);
+}
+exports.previousWindowOwners = previousWindowOwners;
 function mergeRoutes(routes) {
     let list = routes.map(x => x || IArchives_1.FULL_ROUTE).map(x => [x[0], x[1]]);
     (0, misc_1.sort)(list, x => x[0]);
@@ -73,86 +161,27 @@ function summarizeSelf(selfEntries, now) {
         public: current.some(x => x.public),
         immutable: current.some(x => x.immutable),
         noFullSync: current.some(x => x.noFullSync),
-        rawDisk: current.some(x => x.rawDisk),
         readerDiskLimit: (_a = current.find(x => x.readerDiskLimit !== undefined)) === null || _a === void 0 ? void 0 : _a.readerDiskLimit,
     };
 }
-function computeStorePlan(account, bucketName, routing) {
-    var _a;
+/** Which stores this server runs for a bucket, by name. Nothing more: a store is found by name, and configures itself. */
+function planSelfStores(account, bucketName, routing) {
     let selfIndexes = findSelfIndexes(routing, account, bucketName);
     let selfEntries = selfIndexes.map(i => routing.sources[i]);
     let self = summarizeSelf(selfEntries, Date.now());
-    let ownIndexes = new Set(selfIndexes);
-    // One store per distinct route among ALL our entries - past and future windows included, so historical route folders keep serving their data and upcoming routes sync ahead of their window
-    let groups = new Map();
-    for (let i of selfIndexes) {
-        let entry = routing.sources[i];
-        let routeKey = JSON.stringify(entry.route || IArchives_1.FULL_ROUTE);
-        let group = groups.get(routeKey);
-        if (!group) {
-            group = { route: entry.route, entries: [], firstIndex: i };
-            groups.set(routeKey, group);
-        }
-        group.entries.push(entry);
-    }
-    let stores = [];
-    for (let [routeKey, group] of groups) {
-        let anchor = selectEntryAt(group.entries, Date.now());
-        let diskWindow = [0, 0];
-        if (anchor) {
-            let [start, end] = anchor.validWindow;
-            let merged = true;
-            while (merged) {
-                merged = false;
-                for (let entry of group.entries) {
-                    let [entryStart, entryEnd] = entry.validWindow;
-                    if (entryStart > end || entryEnd < start)
-                        continue;
-                    if (entryStart < start || entryEnd > end) {
-                        start = Math.min(start, entryStart);
-                        end = Math.max(end, entryEnd);
-                        merged = true;
-                    }
-                }
-            }
-            diskWindow = [start, end];
+    // One store per NAME among ALL our entries - past and future windows included, so a name we no longer write to keeps serving its data and a name we are about to use exists ahead of its window
+    let byName = new Map();
+    for (let entry of selfEntries) {
+        let entries = byName.get(entry.name);
+        if (!entries) {
+            entries = [];
+            byName.set(entry.name, entries);
         }
-        let sourceSpecs = [{ validWindows: [diskWindow] }];
-        let noFullSync = group.entries.some(x => x.noFullSync);
-        // The same peer endpoint (url+route+flags) can appear under several windows at once (a switchover splits one window around an intermediate). It is ONE sync source that carries ALL those windows - never several sources, which would double-scan it and, worse, make matching a request depend on which window the caller happened to hold.
-        let peerByKey = new Map();
-        for (let i = group.firstIndex + 1; i < routing.sources.length; i++) {
-            let source = routing.sources[i];
-            if (typeof source === "string" || ownIndexes.has(i))
-                continue;
-            let sharedRoute = (0, remoteConfig_1.routeIntersection)(group.route, source.route);
-            if (!sharedRoute)
-                continue;
-            let key = JSON.stringify({ ...source, validWindow: undefined });
-            let spec = peerByKey.get(key);
-            if (!spec) {
-                spec = { sourceConfig: source, validWindows: [], route: sharedRoute, noFullSync: source.noFullSync || noFullSync };
-                peerByKey.set(key, spec);
-                sourceSpecs.push(spec);
-            }
-            spec.validWindows.push(source.validWindow);
-        }
-        stores.push({
-            routeKey,
-            route: group.route,
-            entries: group.entries,
-            rawDisk: group.entries.some(x => x.rawDisk),
-            readerDiskLimit: (_a = group.entries.find(x => x.readerDiskLimit !== undefined)) === null || _a === void 0 ? void 0 : _a.readerDiskLimit,
-            sourceSpecs,
-        });
-    }
-    if (!stores.length) {
-        // Not in the config at all: still serve whatever the plain folder holds, through one inert full-route store
-        stores.push({ routeKey: JSON.stringify(IArchives_1.FULL_ROUTE), route: undefined, entries: [], rawDisk: false, readerDiskLimit: undefined, sourceSpecs: [{ validWindows: [[0, 0]] }] });
+        entries.push(entry);
     }
-    let structureKey = JSON.stringify(stores.map(s => ({ routeKey: s.routeKey, rawDisk: s.rawDisk, readerDiskLimit: s.readerDiskLimit })));
-    return { selfEntries, self, stores, structureKey };
+    // Not in the config at all: no name means no store here
+    return { selfEntries, self, stores: [...byName].map(([name, entries]) => ({ name, entries })) };
 }
-exports.computeStorePlan = computeStorePlan;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"storePlan.js","sourceRoot":"","sources":["storePlan.ts"],"names":[],"mappings":"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","sourcesContent":["import { sort } from \"socket-function/src/misc\";\nimport { RemoteConfig, HostedConfig, SourceConfig, FULL_ROUTE } from \"../IArchives\";\nimport { parseHostedUrl, routeContains, routeIntersection } from \"./remoteConfig\";\nimport { isOwnAddress } from \"./serverConfig\";\n\n// Turns a bucket's routing config into this server's store plan: which of the entries are us, what stores (one per route) we run, and which peers each store synchronizes from.\n\nexport function findSelfIndexes(routing: RemoteConfig, account: string, bucketName: string): number[] {\n    let indexes: number[] = [];\n    for (let i = 0; i < routing.sources.length; i++) {\n        let source = routing.sources[i];\n        if (typeof source === \"string\" || source.type !== \"remote\") continue;\n        let parsed = parseHostedUrl(source.url);\n        if (parsed.account !== account || parsed.bucketName !== bucketName) continue;\n        if (isOwnAddress(parsed.address, parsed.port)) {\n            indexes.push(i);\n        }\n    }\n    return indexes;\n}\n\nexport function selectEntryAt(entries: HostedConfig[], time: number, route?: number): HostedConfig | undefined {\n    if (route !== undefined) {\n        let covering = entries.filter(x => routeContains(x.route, route));\n        if (covering.length) {\n            entries = covering;\n        }\n    }\n    let containing = entries.find(x => x.validWindow[0] <= time && time < x.validWindow[1]);\n    if (containing) return containing;\n    let best: HostedConfig | undefined;\n    let bestDistance = Infinity;\n    for (let entry of entries) {\n        let distance = Math.min(Math.abs(time - entry.validWindow[0]), Math.abs(time - entry.validWindow[1]));\n        if (distance < bestDistance) {\n            bestDistance = distance;\n            best = entry;\n        }\n    }\n    return best;\n}\n\n/** Our role in a bucket's routing config, summarized across ALL currently-valid self entries. Stored instead of a single representative HostedConfig, so nothing can accidentally use one entry's route or flags where the union is required - the standard config has the same URL twice: a routed write-shard entry plus an unrouted read-everything entry. */\nexport type SelfSummary = {\n    /** The union of the current entries' routes, with overlapping/adjacent ranges combined - which commonly collapses to a single full range, making matching trivial. */\n    routes: [number, number][];\n    public: boolean;\n    immutable: boolean;\n    noFullSync: boolean;\n    rawDisk: boolean;\n    readerDiskLimit?: number;\n};\n\nfunction mergeRoutes(routes: ([number, number] | undefined)[]): [number, number][] {\n    let list = routes.map(x => x || FULL_ROUTE).map(x => [x[0], x[1]] as [number, number]);\n    sort(list, x => x[0]);\n    let merged: [number, number][] = [];\n    for (let route of list) {\n        let last = merged[merged.length - 1];\n        if (last && route[0] <= last[1]) {\n            last[1] = Math.max(last[1], route[1]);\n            continue;\n        }\n        merged.push(route);\n    }\n    return merged;\n}\n\nfunction summarizeSelf(selfEntries: HostedConfig[], now: number): SelfSummary | undefined {\n    let current = selfEntries.filter(x => x.validWindow[0] <= now && now < x.validWindow[1]);\n    if (!current.length) {\n        let nearest = selectEntryAt(selfEntries, now);\n        current = nearest && [nearest] || [];\n    }\n    if (!current.length) {\n        return undefined;\n    }\n    return {\n        routes: mergeRoutes(current.map(x => x.route)),\n        public: current.some(x => x.public),\n        immutable: current.some(x => x.immutable),\n        noFullSync: current.some(x => x.noFullSync),\n        rawDisk: current.some(x => x.rawDisk),\n        readerDiskLimit: current.find(x => x.readerDiskLimit !== undefined)?.readerDiskLimit,\n    };\n}\n\nexport type StoreSourceSpec = { sourceConfig?: SourceConfig; validWindows: [number, number][]; route?: [number, number]; noFullSync?: boolean };\nexport type StorePlanStore = {\n    routeKey: string;\n    route?: [number, number];\n    entries: HostedConfig[];\n    rawDisk: boolean;\n    readerDiskLimit?: number;\n    sourceSpecs: StoreSourceSpec[];\n};\nexport type StorePlan = {\n    selfEntries: HostedConfig[];\n    self: SelfSummary | undefined;\n    stores: StorePlanStore[];\n    structureKey: string;\n};\n\nexport function computeStorePlan(account: string, bucketName: string, routing: RemoteConfig): StorePlan {\n    let selfIndexes = findSelfIndexes(routing, account, bucketName);\n    let selfEntries = selfIndexes.map(i => routing.sources[i] as HostedConfig);\n    let self = summarizeSelf(selfEntries, Date.now());\n    let ownIndexes = new Set(selfIndexes);\n    // One store per distinct route among ALL our entries - past and future windows included, so historical route folders keep serving their data and upcoming routes sync ahead of their window\n    let groups = new Map<string, { route?: [number, number]; entries: HostedConfig[]; firstIndex: number }>();\n    for (let i of selfIndexes) {\n        let entry = routing.sources[i] as HostedConfig;\n        let routeKey = JSON.stringify(entry.route || FULL_ROUTE);\n        let group = groups.get(routeKey);\n        if (!group) {\n            group = { route: entry.route, entries: [], firstIndex: i };\n            groups.set(routeKey, group);\n        }\n        group.entries.push(entry);\n    }\n    let stores: StorePlanStore[] = [];\n    for (let [routeKey, group] of groups) {\n        let anchor = selectEntryAt(group.entries, Date.now());\n        let diskWindow: [number, number] = [0, 0];\n        if (anchor) {\n            let [start, end] = anchor.validWindow;\n            let merged = true;\n            while (merged) {\n                merged = false;\n                for (let entry of group.entries) {\n                    let [entryStart, entryEnd] = entry.validWindow;\n                    if (entryStart > end || entryEnd < start) continue;\n                    if (entryStart < start || entryEnd > end) {\n                        start = Math.min(start, entryStart);\n                        end = Math.max(end, entryEnd);\n                        merged = true;\n                    }\n                }\n            }\n            diskWindow = [start, end];\n        }\n        let sourceSpecs: StoreSourceSpec[] = [{ validWindows: [diskWindow] }];\n        let noFullSync = group.entries.some(x => x.noFullSync);\n        // The same peer endpoint (url+route+flags) can appear under several windows at once (a switchover splits one window around an intermediate). It is ONE sync source that carries ALL those windows - never several sources, which would double-scan it and, worse, make matching a request depend on which window the caller happened to hold.\n        let peerByKey = new Map<string, StoreSourceSpec>();\n        for (let i = group.firstIndex + 1; i < routing.sources.length; i++) {\n            let source = routing.sources[i];\n            if (typeof source === \"string\" || ownIndexes.has(i)) continue;\n            let sharedRoute = routeIntersection(group.route, source.route);\n            if (!sharedRoute) continue;\n            let key = JSON.stringify({ ...source, validWindow: undefined });\n            let spec = peerByKey.get(key);\n            if (!spec) {\n                spec = { sourceConfig: source, validWindows: [], route: sharedRoute, noFullSync: source.noFullSync || noFullSync };\n                peerByKey.set(key, spec);\n                sourceSpecs.push(spec);\n            }\n            spec.validWindows.push(source.validWindow);\n        }\n        stores.push({\n            routeKey,\n            route: group.route,\n            entries: group.entries,\n            rawDisk: group.entries.some(x => x.rawDisk),\n            readerDiskLimit: group.entries.find(x => x.readerDiskLimit !== undefined)?.readerDiskLimit,\n            sourceSpecs,\n        });\n    }\n    if (!stores.length) {\n        // Not in the config at all: still serve whatever the plain folder holds, through one inert full-route store\n        stores.push({ routeKey: JSON.stringify(FULL_ROUTE), route: undefined, entries: [], rawDisk: false, readerDiskLimit: undefined, sourceSpecs: [{ validWindows: [[0, 0]] }] });\n    }\n    let structureKey = JSON.stringify(stores.map(s => ({ routeKey: s.routeKey, rawDisk: s.rawDisk, readerDiskLimit: s.readerDiskLimit })));\n    return { selfEntries, self, stores, structureKey };\n}\n"]}
- /* _JS_SOURCE_HASH = "de02e6db6f6d1447f4a3b26c37f95ce8a86b8f1d3dd558e60fca94e7a7974c9f"; */
+exports.planSelfStores = planSelfStores;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"storePlan.js","sourceRoot":"","sources":["storePlan.ts"],"names":[],"mappings":"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","sourcesContent":["import { sort } from \"socket-function/src/misc\";\nimport { RemoteConfig, HostedConfig, SourceConfig, FULL_ROUTE } from \"../IArchives\";\nimport { parseHostedUrl, routeContains, routeIntersection } from \"./remoteConfig\";\nimport { isOwnAddress } from \"./serverConfig\";\n\n// Turns a bucket's routing config into this server's store plan: which of the entries are us, what stores (one per route) we run, and which peers each store synchronizes from.\n\n/** Whether a config entry is THIS server's copy of this bucket - the same account and bucket, at an address this process answers on. */\nexport function isSelfSource(source: SourceConfig, account: string, bucketName: string): boolean {\n    if (source.type !== \"remote\") return false;\n    let parsed = parseHostedUrl(source.url);\n    if (parsed.account !== account || parsed.bucketName !== bucketName) return false;\n    return isOwnAddress(parsed.address, parsed.port);\n}\n\nexport function findSelfIndexes(routing: RemoteConfig, account: string, bucketName: string): number[] {\n    let indexes: number[] = [];\n    for (let i = 0; i < routing.sources.length; i++) {\n        let source = routing.sources[i];\n        if (typeof source === \"string\") continue;\n        if (isSelfSource(source, account, bucketName)) {\n            indexes.push(i);\n        }\n    }\n    return indexes;\n}\n\nexport function selectEntryAt(entries: HostedConfig[], time: number, route?: number): HostedConfig | undefined {\n    if (route !== undefined) {\n        let covering = entries.filter(x => routeContains(x.route, route));\n        if (covering.length) {\n            entries = covering;\n        }\n    }\n    let containing = entries.find(x => x.validWindow[0] <= time && time < x.validWindow[1]);\n    if (containing) return containing;\n    let best: HostedConfig | undefined;\n    let bestDistance = Infinity;\n    for (let entry of entries) {\n        let distance = Math.min(Math.abs(time - entry.validWindow[0]), Math.abs(time - entry.validWindow[1]));\n        if (distance < bestDistance) {\n            bestDistance = distance;\n            best = entry;\n        }\n    }\n    return best;\n}\n\n/** The parts of `ranges` that `cut` does not cover, plus the single range spanning what it did. Routes are half-open [start, end), so subtracting one from another leaves at most a piece on each side. */\nfunction subtractRoute(ranges: [number, number][], cut: [number, number]): { remaining: [number, number][]; claimed?: [number, number] } {\n    let remaining: [number, number][] = [];\n    let claimed: [number, number] | undefined;\n    for (let range of ranges) {\n        let overlap = routeIntersection(range, cut);\n        if (!overlap) {\n            remaining.push(range);\n            continue;\n        }\n        claimed = claimed && [Math.min(claimed[0], overlap[0]), Math.max(claimed[1], overlap[1])] as [number, number] || overlap;\n        if (range[0] < overlap[0]) remaining.push([range[0], overlap[0]]);\n        if (overlap[1] < range[1]) remaining.push([overlap[1], range[1]]);\n    }\n    return { remaining, claimed };\n}\n\n/** What one of our stores has to pull in at a valid-window boundary, so the writes that landed just before the handover are not missed. */\nexport type BoundaryHandover = {\n    // The store that needs the data: the name of the self entry taking over at the boundary\n    name: string;\n    // The route it is taking over, which is the slice of the key space the pulls below are limited to\n    route: [number, number];\n    // We held part of this route in the previous window too, so those writes are already in our own folder and a disk rescan finds them\n    scanOwnDisk: boolean;\n    // Per source index in the config, the slice of our route THAT source held in the previous window - a boundary scan pulls its recent changes\n    remotes: Map<number, [number, number]>;\n};\n\n/**\n * Who held each slice of our route in the window before windowStart, for every self entry whose\n * window starts exactly then. This is the whole of \"who do we take over from\": a store taking over a\n * route may be taking it from several previous owners at once (their shards need not line up with\n * ours), and from itself for the parts it already held.\n *\n * A self entry is skipped when an EARLIER entry valid at the boundary already covers its whole route:\n * config order is priority, so that entry is the write target and we are not the one taking over.\n * Owners are then resolved in config order too, each claiming the part of our route still unclaimed -\n * the same first-match-wins rule that picks a write target at any other moment.\n *\n * Pure: config in, plan out. Nothing here reads a store, a clock, or the network.\n */\nexport function previousWindowOwners(config: RemoteConfig, windowStart: number, selfIndexes: number[]): BoundaryHandover[] {\n    let selfIndexSet = new Set(selfIndexes);\n    let previousTime = windowStart - 1;\n    let validAt = (source: SourceConfig, time: number) => source.validWindow[0] <= time && time < source.validWindow[1];\n    let byRoute = new Map<string, BoundaryHandover>();\n    for (let selfIndex of selfIndexes) {\n        let self = config.sources[selfIndex];\n        if (typeof self === \"string\" || self.validWindow[0] !== windowStart) continue;\n        let selfRoute = self.route || FULL_ROUTE;\n        let shadowed = false;\n        for (let i = 0; i < selfIndex; i++) {\n            let other = config.sources[i];\n            if (typeof other === \"string\" || !validAt(other, windowStart)) continue;\n            let route = other.route || FULL_ROUTE;\n            if (route[0] <= selfRoute[0] && selfRoute[1] <= route[1]) {\n                shadowed = true;\n                break;\n            }\n        }\n        if (shadowed) continue;\n        // Keyed by both: one name can take over several routes at the same boundary, and each is pulled separately\n        let handoverKey = `${self.name}|${JSON.stringify(selfRoute)}`;\n        let handover = byRoute.get(handoverKey);\n        if (!handover) {\n            handover = { name: self.name, route: selfRoute, scanOwnDisk: false, remotes: new Map() };\n            byRoute.set(handoverKey, handover);\n        }\n        let unclaimed: [number, number][] = [[selfRoute[0], selfRoute[1]]];\n        for (let i = 0; i < config.sources.length && unclaimed.length; i++) {\n            let other = config.sources[i];\n            if (typeof other === \"string\" || !validAt(other, previousTime)) continue;\n            let { remaining, claimed } = subtractRoute(unclaimed, other.route || FULL_ROUTE);\n            unclaimed = remaining;\n            if (!claimed) continue;\n            if (selfIndexSet.has(i)) {\n                handover.scanOwnDisk = true;\n                continue;\n            }\n            let existing = handover.remotes.get(i);\n            handover.remotes.set(i, existing && [Math.min(existing[0], claimed[0]), Math.max(existing[1], claimed[1])] as [number, number] || claimed);\n        }\n    }\n    return [...byRoute.values()].filter(x => x.scanOwnDisk || x.remotes.size);\n}\n\n/** Our role in a bucket's routing config, summarized across ALL currently-valid self entries. Stored instead of a single representative HostedConfig, so nothing can accidentally use one entry's route or flags where the union is required - the standard config has the same URL twice: a routed write-shard entry plus an unrouted read-everything entry. */\nexport type SelfSummary = {\n    /** The union of the current entries' routes, with overlapping/adjacent ranges combined - which commonly collapses to a single full range, making matching trivial. */\n    routes: [number, number][];\n    public: boolean;\n    immutable: boolean;\n    noFullSync: boolean;\n    readerDiskLimit?: number;\n};\n\nfunction mergeRoutes(routes: ([number, number] | undefined)[]): [number, number][] {\n    let list = routes.map(x => x || FULL_ROUTE).map(x => [x[0], x[1]] as [number, number]);\n    sort(list, x => x[0]);\n    let merged: [number, number][] = [];\n    for (let route of list) {\n        let last = merged[merged.length - 1];\n        if (last && route[0] <= last[1]) {\n            last[1] = Math.max(last[1], route[1]);\n            continue;\n        }\n        merged.push(route);\n    }\n    return merged;\n}\n\nfunction summarizeSelf(selfEntries: HostedConfig[], now: number): SelfSummary | undefined {\n    let current = selfEntries.filter(x => x.validWindow[0] <= now && now < x.validWindow[1]);\n    if (!current.length) {\n        let nearest = selectEntryAt(selfEntries, now);\n        current = nearest && [nearest] || [];\n    }\n    if (!current.length) {\n        return undefined;\n    }\n    return {\n        routes: mergeRoutes(current.map(x => x.route)),\n        public: current.some(x => x.public),\n        immutable: current.some(x => x.immutable),\n        noFullSync: current.some(x => x.noFullSync),\n        readerDiskLimit: current.find(x => x.readerDiskLimit !== undefined)?.readerDiskLimit,\n    };\n}\n\n/** One store this server runs for a bucket: the name that IS the store, and the entries that name it. What it synchronizes with is NOT decided here - the store reads its own copy of the config and works that out itself (see BlobStore.applyRoutingConfig). */\nexport type SelfStore = {\n    name: string;\n    entries: HostedConfig[];\n};\n\n/** Which stores this server runs for a bucket, by name. Nothing more: a store is found by name, and configures itself. */\nexport function planSelfStores(account: string, bucketName: string, routing: RemoteConfig): { selfEntries: HostedConfig[]; self: SelfSummary | undefined; stores: SelfStore[] } {\n    let selfIndexes = findSelfIndexes(routing, account, bucketName);\n    let selfEntries = selfIndexes.map(i => routing.sources[i] as HostedConfig);\n    let self = summarizeSelf(selfEntries, Date.now());\n    // One store per NAME among ALL our entries - past and future windows included, so a name we no longer write to keeps serving its data and a name we are about to use exists ahead of its window\n    let byName = new Map<string, HostedConfig[]>();\n    for (let entry of selfEntries) {\n        let entries = byName.get(entry.name);\n        if (!entries) {\n            entries = [];\n            byName.set(entry.name, entries);\n        }\n        entries.push(entry);\n    }\n    // Not in the config at all: no name means no store here\n    return { selfEntries, self, stores: [...byName].map(([name, entries]) => ({ name, entries })) };\n}\n"]}
+ /* _JS_SOURCE_HASH = "34bdac815bba6b0da86e3b712610c28994f577faf6bb0acd7d09b73d2d301e81"; */

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.applySourceConfig = exports.createStoreSource = exports.createApiArchives = void 0;
+const ArchivesDisk_1 = require("../ArchivesDisk");
+const backblaze_1 = require("../backblaze");
+const ArchivesRemote_1 = require("./ArchivesRemote");
+const remoteConfig_1 = require("./remoteConfig");
+const ArchivesDelayed_1 = require("./ArchivesDelayed");
+// ONE source, talked to directly - the counterpart of createArchives, which resolves a whole routing config into a chain that falls back and re-resolves across many sources. Nothing here picks a source or retries against another one: the caller (a chain, or a store's synchronization) already decided which endpoint it wants, and gets a client bound to exactly that endpoint. Source identity and config updates live here too, because they are the same question - which endpoint is this, and what policy are we applying to it.
+/** The client for one configured source: backblaze, or a storage server - including this one. */
+function createApiArchives(source) {
+    if (source.type === "backblaze") {
+        return new backblaze_1.ArchivesBackblaze({ bucketName: (0, remoteConfig_1.parseBackblazeUrl)(source.url).bucketName, public: source.public, immutable: source.immutable, allowedOrigins: source.allowedOrigins });
+    }
+    // Including when that server is us: a call to ourselves is a WebSocket to our own port, which authenticates as this machine (so it is always allowed) and costs a round trip on loopback. Not worth a second implementation of every operation to avoid.
+    return new ArchivesRemote_1.ArchivesRemote({ url: source.url, waitForAccess: false, sourceConfig: source });
+}
+exports.createApiArchives = createApiArchives;
+/** The ONE place a store's source is built. Every source a store synchronizes with is one of exactly two things: a configured peer, or the store's own disk folder (no sourceConfig). writeDelay wraps it so its writes are buffered in memory for that long (see ArchivesDelayed) - the whole of "fast writes", per source, decided here. */
+function createStoreSource(config) {
+    let source;
+    if (!config.sourceConfig) {
+        source = new ArchivesDisk_1.ArchivesDisk(config.folder);
+    }
+    else {
+        source = createApiArchives(config.sourceConfig);
+    }
+    if (config.writeDelay) {
+        source = new ArchivesDelayed_1.ArchivesDelayed(source, config.writeDelay);
+    }
+    return source;
+}
+exports.createStoreSource = createStoreSource;
+/** Applies a changed config to an ALREADY RUNNING source (same endpoint, see sourceIdentity - only policy moved). Sources that carry their config into every request MUST be updated in place, or they keep sending the old one: the server matches the config it is handed against its own entries, so a source left holding a stale config eventually stops resolving to a store at all. The write delay is policy too, so it moves here as well. */
+function applySourceConfig(source, sourceConfig, writeDelay) {
+    var _a;
+    if (writeDelay !== undefined) {
+        (_a = (0, ArchivesDelayed_1.asDelayed)(source)) === null || _a === void 0 ? void 0 : _a.setDelay(writeDelay);
+    }
+    // The store's own disk has no config to apply - only a delay
+    if (!sourceConfig)
+        return;
+    // The config belongs to the source itself, not to the delay wrapped around it
+    let configurable = (0, ArchivesDelayed_1.unwrapDelayed)(source);
+    if (typeof configurable.updateSourceConfig !== "function")
+        return;
+    configurable.updateSourceConfig(sourceConfig);
+}
+exports.applySourceConfig = applySourceConfig;
+//# sourceMappingURL=data:application/json;base64,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
+ /* _JS_SOURCE_HASH = "d1518847ce26e2daa489a3b4e30465cd9bfe8e12506437f087d5fe0e81d5755d"; */