sliftutils 1.7.12 → 1.7.14

package/storage/remoteStorage/deployTakeover.ts

@@ -0,0 +1,373 @@
+import fs from "fs";
+import path from "path";
+import { exec } from "child_process";
+import { RemoteConfig, RemoteConfigBase, HostedConfig } from "../IArchives";
+import { parseHostedUrl, replaceHostedUrlPort } from "./remoteConfig";
+
+// Deploy takeover: the deploy manager (querysub's parametersTimeline) writes <n>-parameters.json
+// files into our instance folder describing when each version runs and when it is shut down. Old
+// and new version overlap for the overlap time (O = oldEnd - newStart). We turn that overlap into
+// an atomic write handoff by REINTERPRETING every routing source that points at us: its valid
+// window is split so that the middle of the overlap ([S + 0.5*O, S + 1.5*O]) points at the new
+// process's temporary alternate port. The existing valid-window machinery then does everything -
+// the old process starts rejecting fresh writes at the first boundary, clients re-resolve, and the
+// new process (which recognizes the alternate port as itself) takes over. The remap is an
+// INTERPRETATION OVERLAY, applied where routing configs are used (see applyDeployRemap callers) -
+// it is never written to disk, never synchronized, and never part of any stored configuration.
+//
+// Everything here is recomputed idempotently from its inputs (timeline files, the port registry,
+// our ancestor pids, the clock) - files can appear or change at any moment, and we can start at
+// any point during a switchover.
+
+const PARAMETERS_TIMELINE_FILE_REGEX = /^(\d+)-parameters\.json$/;
+const ALIVE_WINDOW_FOREVER = Number.MAX_SAFE_INTEGER;
+const TIMELINE_POLL_INTERVAL = 60 * 1000;
+// Processes listening on an alternate port register it here (sibling of the storage folder), keyed
+// by their actual pid; content includes their ancestor pids so the timeline entry pid (a shell
+// ancestor of the process) can be matched to a registry entry
+const PORT_REGISTRY_FOLDER_NAME = "storagePortRegistry";
+// Main-port acquisition attempts run this often, tightening near the predecessor's scheduled death
+const ACQUIRE_SLOW_DELAY = 30 * 1000;
+const ACQUIRE_FAST_DELAY = 5 * 1000;
+const ACQUIRE_FAST_WINDOW = 60 * 1000;
+// Disk rescans fire this far before and after the write handoff, catching files the other process
+// wrote (the BulkDatabase2 index is atomic but its entries land at write time, not file time)
+const SWITCH_SCAN_LEAD = 10 * 1000;
+// The dying process must have flushed everything before the handoff: fast-write delays never
+// extend past S + overlap * this fraction, and after that point fast writes flush immediately
+const FLUSH_DEADLINE_FRACTION = 0.25;
+const BOUNDARY_A_FRACTION = 0.5;
+const BOUNDARY_B_FRACTION = 1.5;
+const REMAP_EXPIRE_FRACTION = 2;
+
+type TimelineEntry = {
+    pid?: number;
+    aliveWindow: [number, number];
+    parameters: unknown;
+};
+
+type TakeoverComputed = {
+    // We are scheduled to die with a successor overlapping us (known from the files alone, before
+    // the successor's port is discovered - the flush deadline applies immediately)
+    dying?: { successorStart: number; overlap: number };
+    // The window reinterpretation, once the middle window's port is known (the successor's
+    // registered alternate port - or our own, when we ARE the successor)
+    remap?: { boundaryA: number; boundaryB: number; expire: number; altPort: number };
+    // When our predecessor dies and frees the main port (for acquisition pacing)
+    predecessorEnd?: number;
+};
+
+export type TakeoverEvent = "remapChanged" | "diskScan";
+
+let initialized: { domain: string; mainPort: number; storageFolder: string } | undefined;
+let ancestorPids = new Set<number>();
+let timelineFolder: string | undefined;
+let ourAltPort: number | undefined;
+let current: TakeoverComputed = {};
+let currentKey = JSON.stringify(current);
+let eventListeners: ((event: TakeoverEvent) => void)[] = [];
+let eventTimers: ReturnType<typeof setTimeout>[] = [];
+
+function execText(command: string): Promise<string> {
+    return new Promise((resolve, reject) => {
+        exec(command, (error, stdout) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve(stdout);
+        });
+    });
+}
+
+// The timeline entry pid is the screen shell that spawned us - an ancestor - so we walk our whole
+// ancestor chain to find which entry is us
+async function getAncestorPids(): Promise<Set<number>> {
+    let pids = new Set<number>([process.pid]);
+    let currentPid = process.pid;
+    while (true) {
+        let ppid: number;
+        if (currentPid === process.pid && process.ppid) {
+            ppid = process.ppid;
+        } else {
+            try {
+                ppid = parseInt((await execText(`ps -o ppid= -p ${currentPid}`)).trim());
+            } catch {
+                break;
+            }
+        }
+        if (!ppid || Number.isNaN(ppid) || ppid <= 1 || pids.has(ppid)) break;
+        pids.add(ppid);
+        currentPid = ppid;
+    }
+    return pids;
+}
+
+async function findTimelineFolder(): Promise<string | undefined> {
+    let dir = process.cwd();
+    while (true) {
+        let files: string[] = [];
+        try {
+            files = await fs.promises.readdir(dir);
+        } catch { }
+        if (files.some(file => PARAMETERS_TIMELINE_FILE_REGEX.test(file))) {
+            return dir.replaceAll("\\", "/") + "/";
+        }
+        let parent = path.dirname(dir);
+        if (parent === dir) return undefined;
+        dir = parent;
+    }
+}
+
+function pidAlive(pid: number): boolean {
+    try {
+        process.kill(pid, 0);
+        return true;
+    } catch (e) {
+        return (e as { code?: string }).code === "EPERM";
+    }
+}
+
+function getRegistryFolder(): string {
+    if (!initialized) {
+        throw new Error(`Deploy takeover is not initialized`);
+    }
+    return path.join(path.dirname(path.resolve(initialized.storageFolder)), PORT_REGISTRY_FOLDER_NAME);
+}
+
+type RegistryEntry = { pid: number; port: number; ancestorPids: number[] };
+
+async function readPortRegistry(): Promise<RegistryEntry[]> {
+    let folder = getRegistryFolder();
+    let files: string[] = [];
+    try {
+        files = await fs.promises.readdir(folder);
+    } catch {
+        return [];
+    }
+    let entries: RegistryEntry[] = [];
+    for (let file of files) {
+        let match = /^(\d+)\.json$/.exec(file);
+        if (!match) continue;
+        let pid = parseInt(match[1]);
+        if (!pidAlive(pid)) {
+            try {
+                await fs.promises.unlink(path.join(folder, file));
+            } catch { }
+            continue;
+        }
+        try {
+            let entry = JSON.parse(await fs.promises.readFile(path.join(folder, file), "utf8")) as RegistryEntry;
+            entries.push({ ...entry, pid });
+        } catch { }
+    }
+    return entries;
+}
+
+async function readTimelineEntries(): Promise<TimelineEntry[]> {
+    if (!timelineFolder) return [];
+    let entries: TimelineEntry[] = [];
+    for (let file of await fs.promises.readdir(timelineFolder)) {
+        if (!PARAMETERS_TIMELINE_FILE_REGEX.test(file)) continue;
+        try {
+            entries.push(JSON.parse(await fs.promises.readFile(timelineFolder + file, "utf8")) as TimelineEntry);
+        } catch (e) {
+            console.warn(`Could not read deploy timeline file ${timelineFolder + file}: ${(e as Error).stack ?? e}`);
+        }
+    }
+    return entries;
+}
+
+function makeRemap(successorStart: number, overlap: number, altPort: number): TakeoverComputed["remap"] {
+    return {
+        boundaryA: successorStart + overlap * BOUNDARY_A_FRACTION,
+        boundaryB: successorStart + overlap * BOUNDARY_B_FRACTION,
+        expire: successorStart + overlap * REMAP_EXPIRE_FRACTION,
+        altPort,
+    };
+}
+
+function emit(event: TakeoverEvent): void {
+    for (let listener of eventListeners) {
+        try {
+            listener(event);
+        } catch (e) {
+            console.error(`Deploy takeover listener failed: ${(e as Error).stack ?? e}`);
+        }
+    }
+}
+
+function scheduleEvents(): void {
+    for (let timer of eventTimers) {
+        clearTimeout(timer);
+    }
+    eventTimers = [];
+    let now = Date.now();
+    let schedule = (time: number, fnc: () => void) => {
+        if (time <= now) return;
+        let timer = setTimeout(fnc, time - now);
+        (timer as { unref?: () => void }).unref?.();
+        eventTimers.push(timer);
+    };
+    let remap = current.remap;
+    if (remap) {
+        schedule(remap.boundaryA - SWITCH_SCAN_LEAD, () => emit("diskScan"));
+        schedule(remap.boundaryA + SWITCH_SCAN_LEAD, () => emit("diskScan"));
+        schedule(remap.expire, () => void recompute().catch((e: Error) => console.error(`Deploy takeover recompute failed: ${e.stack ?? e}`)));
+    }
+}
+
+async function recompute(): Promise<void> {
+    if (!initialized || !timelineFolder) return;
+    let now = Date.now();
+    let entries = await readTimelineEntries();
+    let registry = await readPortRegistry();
+    let us: TimelineEntry | undefined;
+    for (let entry of entries) {
+        if (entry.pid && ancestorPids.has(entry.pid)) {
+            us = entry;
+        }
+    }
+    let computed: TakeoverComputed = {};
+    if (us) {
+        let usStart = us.aliveWindow[0];
+        let next: TimelineEntry | undefined;
+        let prev: TimelineEntry | undefined;
+        for (let entry of entries) {
+            if (entry === us) continue;
+            if (entry.aliveWindow[0] > usStart && (!next || entry.aliveWindow[0] < next.aliveWindow[0])) {
+                next = entry;
+            }
+            if (entry.aliveWindow[0] < usStart && (!prev || entry.aliveWindow[0] > prev.aliveWindow[0])) {
+                prev = entry;
+            }
+        }
+        if (next && us.aliveWindow[1] !== ALIVE_WINDOW_FOREVER && next.aliveWindow[0] <= us.aliveWindow[1]) {
+            let overlap = us.aliveWindow[1] - next.aliveWindow[0];
+            let successorStart = next.aliveWindow[0];
+            if (overlap > 0 && now < successorStart + overlap * REMAP_EXPIRE_FRACTION) {
+                computed.dying = { successorStart, overlap };
+                const successorPid = next.pid;
+                if (successorPid) {
+                    let successorEntry = registry.find(x => x.ancestorPids.includes(successorPid));
+                    if (successorEntry) {
+                        computed.remap = makeRemap(successorStart, overlap, successorEntry.port);
+                    }
+                }
+            }
+        }
+        if (prev && prev.aliveWindow[1] > usStart) {
+            let overlap = prev.aliveWindow[1] - usStart;
+            computed.predecessorEnd = prev.aliveWindow[1];
+            if (overlap > 0 && ourAltPort && now < usStart + overlap * REMAP_EXPIRE_FRACTION && !computed.remap) {
+                computed.remap = makeRemap(usStart, overlap, ourAltPort);
+            }
+        }
+    }
+    let key = JSON.stringify(computed);
+    if (key === currentKey) return;
+    current = computed;
+    currentKey = key;
+    console.log(`Deploy takeover state changed: ${key}`);
+    scheduleEvents();
+    emit("remapChanged");
+}
+
+/** Starts the takeover machinery. Returns whether a deploy timeline exists - when it doesn't,
+ *  everything here stays inert (and the caller must NOT fall back to alternate ports, since a busy
+ *  port then means a real misconfiguration, not a deploy). */
+export async function initDeployTakeover(config: { domain: string; mainPort: number; storageFolder: string }): Promise<boolean> {
+    initialized = config;
+    ancestorPids = await getAncestorPids();
+    timelineFolder = await findTimelineFolder();
+    if (!timelineFolder) return false;
+    await recompute();
+    let poll = setInterval(() => {
+        void recompute().catch((e: Error) => console.error(`Deploy takeover recompute failed: ${e.stack ?? e}`));
+    }, TIMELINE_POLL_INTERVAL);
+    (poll as { unref?: () => void }).unref?.();
+    return true;
+}
+
+/** Called when we had to listen on an alternate port (the main port was still held by our
+ *  predecessor): registers it so the predecessor can route the middle overlap window to us. */
+export async function registerAltPort(port: number): Promise<void> {
+    ourAltPort = port;
+    let folder = getRegistryFolder();
+    await fs.promises.mkdir(folder, { recursive: true });
+    let entry: RegistryEntry = { pid: process.pid, port, ancestorPids: [...ancestorPids] };
+    await fs.promises.writeFile(path.join(folder, `${process.pid}.json`), JSON.stringify(entry));
+    await recompute();
+}
+
+export function onTakeoverEvent(listener: (event: TakeoverEvent) => void): void {
+    eventListeners.push(listener);
+}
+
+/** The interpretation overlay: splits every source pointing at our domain+main port so the middle
+ *  of the deploy overlap points at the alternate port. Pure, in-memory only - the stored routing
+ *  config is never modified, and this must never be applied to data that gets persisted. */
+export function applyDeployRemap(routing: RemoteConfig): RemoteConfig {
+    let remap = current.remap;
+    let init = initialized;
+    if (!remap || !init) return routing;
+    let sources: RemoteConfigBase[] = [];
+    let slice = (source: HostedConfig, start: number, end: number, url?: string): HostedConfig => {
+        return { ...source, url: url || source.url, validWindow: [start, end] };
+    };
+    for (let source of routing.sources) {
+        if (typeof source === "string" || source.type !== "remote") {
+            sources.push(source);
+            continue;
+        }
+        let parsed: { address: string; port: number };
+        try {
+            parsed = parseHostedUrl(source.url);
+        } catch {
+            sources.push(source);
+            continue;
+        }
+        if (parsed.address !== init.domain || parsed.port !== init.mainPort) {
+            sources.push(source);
+            continue;
+        }
+        let [start, end] = source.validWindow;
+        let a = Math.max(start, Math.min(remap.boundaryA, end));
+        let b = Math.max(start, Math.min(remap.boundaryB, end));
+        let added = false;
+        if (a > start) {
+            sources.push(slice(source, start, a));
+            added = true;
+        }
+        if (b > a) {
+            sources.push(slice(source, a, b, replaceHostedUrlPort(source.url, remap.altPort)));
+            added = true;
+        }
+        if (end > b) {
+            sources.push(slice(source, b, end));
+            added = true;
+        }
+        if (!added) {
+            sources.push(source);
+        }
+    }
+    return { version: routing.version, sources };
+}
+
+/** For the dying process: fast-write flush delays must never extend past this time, and after it
+ *  fast writes flush immediately - so nothing is left in memory when the write window transfers. */
+export function getFlushDeadline(): number | undefined {
+    let dying = current.dying;
+    if (!dying) return undefined;
+    return dying.successorStart + dying.overlap * FLUSH_DEADLINE_FRACTION;
+}
+
+/** How long to wait between main-port acquisition attempts: tight around the predecessor's
+ *  scheduled death (when the port actually frees), relaxed otherwise. */
+export function getMainPortAcquireDelay(): number {
+    let end = current.predecessorEnd;
+    if (end !== undefined && Math.abs(Date.now() - end) <= ACQUIRE_FAST_WINDOW) {
+        return ACQUIRE_FAST_DELAY;
+    }
+    return ACQUIRE_SLOW_DELAY;
+}

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
 //exports.ArchivesUrl = void 0;
 module.allowclient = true;
+const https_1 = require("socket-function/src/https");
 const remoteConfig_1 = require("./remoteConfig");
 // Read-only IArchives over a public bucket's plain-URL form (our storage server's
 // /file/<account>/<bucketName>/... route, or a backblaze friendly URL). Used when we have no API
@@ -28,26 +29,30 @@ class ArchivesUrl {
         if (range) {
             headers["Range"] = `bytes=${range.start}-${range.end - 1}`;
         }
-        let response = await fetch(url, { headers });
-        if (response.status === 404)
-            return undefined;
-        if (!response.ok) {
-            throw new Error(`Read of ${url} failed: ${response.status} ${response.statusText}`);
+        let response = { headers: {} };
+        let data;
+        try {
+            data = await (0, https_1.httpsRequest)(url, undefined, "GET", false, { headers, outResponse: response });
+        }
+        catch (e) {
+            // httpsRequest throws on any non-2xx; a missing file is a normal absent result, not an error.
+            if (response.statusCode === 404)
+                return undefined;
+            throw e;
         }
-        let data = Buffer.from(await response.arrayBuffer());
         // A real 206 only returns the requested slice, so the full size lives in Content-Range's total.
         let size = data.length;
-        let contentRange = response.headers.get("content-range");
+        let contentRange = response.headers["content-range"];
         let total = contentRange && Number(contentRange.split("/")[1]);
         if (total && Number.isFinite(total)) {
             size = total;
         }
         // Servers that don't support ranges return the full file with a 200 (ours serves real
         // 206s, but backblaze friendly URLs and proxies may not)
-        if (range && response.status === 200) {
+        if (range && response.statusCode === 200) {
             data = data.subarray(Math.min(range.start, data.length), Math.min(range.end, data.length));
         }
-        let lastModified = response.headers.get("last-modified");
+        let lastModified = response.headers["last-modified"];
         let writeTime = lastModified && new Date(lastModified).getTime() || 0;
         return { data, writeTime, size };
     }
@@ -81,5 +86,5 @@ class ArchivesUrl {
     }
 }
 exports.ArchivesUrl = ArchivesUrl;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ArchivesUrl.js","sourceRoot":"","sources":["ArchivesUrl.ts"],"names":[],"mappings":"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","sourcesContent":["module.allowclient = true;\n\nimport { IArchives, ArchiveFileInfo, ArchivesConfig } from \"../IArchives\";\nimport { buildFileUrl } from \"./remoteConfig\";\n\n// Read-only IArchives over a public bucket's plain-URL form (our storage server's\n// /file/<account>/<bucketName>/... route, or a backblaze friendly URL). Used when we have no API\n// access to a source. Only single-file reads work: there is no listing, and writes always throw.\n\nexport class ArchivesUrl implements IArchives {\n    // base is the bucket's public base URL, e.g. https://host:port/file/<account>/<bucketName>\n    constructor(private base: string) { }\n\n    public getDebugName() {\n        return `url/${this.base}`;\n    }\n\n    private readOnlyError(operation: string): Error {\n        return new Error(`${operation} is not supported over URL-form access (no API access to this source, only public URL reads). Source: ${this.base}`);\n    }\n\n    public async get(fileName: string, config?: { range?: { start: number; end: number } }): Promise<Buffer | undefined> {\n        let result = await this.get2(fileName, config);\n        return result && result.data || undefined;\n    }\n    public async get2(fileName: string, config?: { range?: { start: number; end: number } }): Promise<{ data: Buffer; writeTime: number; size: number } | undefined> {\n        let url = buildFileUrl(this.base, fileName);\n        let headers: Record<string, string> = {};\n        let range = config?.range;\n        if (range) {\n            headers[\"Range\"] = `bytes=${range.start}-${range.end - 1}`;\n        }\n        let response = await fetch(url, { headers });\n        if (response.status === 404) return undefined;\n        if (!response.ok) {\n            throw new Error(`Read of ${url} failed: ${response.status} ${response.statusText}`);\n        }\n        let data = Buffer.from(await response.arrayBuffer());\n        // A real 206 only returns the requested slice, so the full size lives in Content-Range's total.\n        let size = data.length;\n        let contentRange = response.headers.get(\"content-range\");\n        let total = contentRange && Number(contentRange.split(\"/\")[1]);\n        if (total && Number.isFinite(total)) {\n            size = total;\n        }\n        // Servers that don't support ranges return the full file with a 200 (ours serves real\n        // 206s, but backblaze friendly URLs and proxies may not)\n        if (range && response.status === 200) {\n            data = data.subarray(Math.min(range.start, data.length), Math.min(range.end, data.length));\n        }\n        let lastModified = response.headers.get(\"last-modified\");\n        let writeTime = lastModified && new Date(lastModified).getTime() || 0;\n        return { data, writeTime, size };\n    }\n    public async getInfo(fileName: string): Promise<{ writeTime: number; size: number } | undefined> {\n        let result = await this.get2(fileName);\n        return result && { writeTime: result.writeTime, size: result.size } || undefined;\n    }\n\n    public async set(fileName: string, data: Buffer, config?: { lastModified?: number }): Promise<void> {\n        throw this.readOnlyError(\"set\");\n    }\n    public async del(fileName: string): Promise<void> {\n        throw this.readOnlyError(\"del\");\n    }\n    public async setLargeFile(config: { path: string; getNextData(): Promise<Buffer | undefined> }): Promise<void> {\n        throw this.readOnlyError(\"setLargeFile\");\n    }\n    public async find(prefix: string, config?: { shallow?: boolean; type: \"files\" | \"folders\" }): Promise<string[]> {\n        throw this.readOnlyError(\"find (listing)\");\n    }\n    public async findInfo(prefix: string, config?: { shallow?: boolean; type: \"files\" | \"folders\" }): Promise<ArchiveFileInfo[]> {\n        throw this.readOnlyError(\"findInfo (listing)\");\n    }\n\n    public async getURL(path: string): Promise<string> {\n        return buildFileUrl(this.base, path);\n    }\n    public async getConfig(): Promise<ArchivesConfig> {\n        return {};\n    }\n\n    public async hasWriteAccess(): Promise<boolean> {\n        return false;\n    }\n}\n"]}
- /* _JS_SOURCE_HASH = "3b08e87dc92fd46752eef014c02d0b938c7e7ae588bb1d9582446c2f1b980993"; */
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ArchivesUrl.js","sourceRoot":"","sources":["ArchivesUrl.ts"],"names":[],"mappings":"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","sourcesContent":["module.allowclient = true;\n\nimport { httpsRequest, HttpsResponseInfo } from \"socket-function/src/https\";\nimport { IArchives, ArchiveFileInfo, ArchivesConfig } from \"../IArchives\";\nimport { buildFileUrl } from \"./remoteConfig\";\n\n// Read-only IArchives over a public bucket's plain-URL form (our storage server's\n// /file/<account>/<bucketName>/... route, or a backblaze friendly URL). Used when we have no API\n// access to a source. Only single-file reads work: there is no listing, and writes always throw.\n\nexport class ArchivesUrl implements IArchives {\n    // base is the bucket's public base URL, e.g. https://host:port/file/<account>/<bucketName>\n    constructor(private base: string) { }\n\n    public getDebugName() {\n        return `url/${this.base}`;\n    }\n\n    private readOnlyError(operation: string): Error {\n        return new Error(`${operation} is not supported over URL-form access (no API access to this source, only public URL reads). Source: ${this.base}`);\n    }\n\n    public async get(fileName: string, config?: { range?: { start: number; end: number } }): Promise<Buffer | undefined> {\n        let result = await this.get2(fileName, config);\n        return result && result.data || undefined;\n    }\n    public async get2(fileName: string, config?: { range?: { start: number; end: number } }): Promise<{ data: Buffer; writeTime: number; size: number } | undefined> {\n        let url = buildFileUrl(this.base, fileName);\n        let headers: Record<string, string> = {};\n        let range = config?.range;\n        if (range) {\n            headers[\"Range\"] = `bytes=${range.start}-${range.end - 1}`;\n        }\n        let response: HttpsResponseInfo = { headers: {} };\n        let data: Buffer;\n        try {\n            data = await httpsRequest(url, undefined, \"GET\", false, { headers, outResponse: response });\n        } catch (e) {\n            // httpsRequest throws on any non-2xx; a missing file is a normal absent result, not an error.\n            if (response.statusCode === 404) return undefined;\n            throw e;\n        }\n        // A real 206 only returns the requested slice, so the full size lives in Content-Range's total.\n        let size = data.length;\n        let contentRange = response.headers[\"content-range\"];\n        let total = contentRange && Number(contentRange.split(\"/\")[1]);\n        if (total && Number.isFinite(total)) {\n            size = total;\n        }\n        // Servers that don't support ranges return the full file with a 200 (ours serves real\n        // 206s, but backblaze friendly URLs and proxies may not)\n        if (range && response.statusCode === 200) {\n            data = data.subarray(Math.min(range.start, data.length), Math.min(range.end, data.length));\n        }\n        let lastModified = response.headers[\"last-modified\"];\n        let writeTime = lastModified && new Date(lastModified).getTime() || 0;\n        return { data, writeTime, size };\n    }\n    public async getInfo(fileName: string): Promise<{ writeTime: number; size: number } | undefined> {\n        let result = await this.get2(fileName);\n        return result && { writeTime: result.writeTime, size: result.size } || undefined;\n    }\n\n    public async set(fileName: string, data: Buffer, config?: { lastModified?: number }): Promise<void> {\n        throw this.readOnlyError(\"set\");\n    }\n    public async del(fileName: string): Promise<void> {\n        throw this.readOnlyError(\"del\");\n    }\n    public async setLargeFile(config: { path: string; getNextData(): Promise<Buffer | undefined> }): Promise<void> {\n        throw this.readOnlyError(\"setLargeFile\");\n    }\n    public async find(prefix: string, config?: { shallow?: boolean; type: \"files\" | \"folders\" }): Promise<string[]> {\n        throw this.readOnlyError(\"find (listing)\");\n    }\n    public async findInfo(prefix: string, config?: { shallow?: boolean; type: \"files\" | \"folders\" }): Promise<ArchiveFileInfo[]> {\n        throw this.readOnlyError(\"findInfo (listing)\");\n    }\n\n    public async getURL(path: string): Promise<string> {\n        return buildFileUrl(this.base, path);\n    }\n    public async getConfig(): Promise<ArchivesConfig> {\n        return {};\n    }\n\n    public async hasWriteAccess(): Promise<boolean> {\n        return false;\n    }\n}\n"]}
+ /* _JS_SOURCE_HASH = "b0345ca711863e65ce4fc8deaf0a642cdaf6ab861e3630f423ced0350b56666a"; */