querysub 0.451.0 → 0.453.0

package/src/-a-archives/archiveCache.ts

@@ -1,35 +1,50 @@
-import { getStorageDir, getSubFolder } from "../fs";
 import { Archives, createArchivesOverride } from "./archives";
 import fs from "fs";
 import os from "os";
 
-import { list, nextId, timeInHour, timeInMinute } from "socket-function/src/misc";
+import { nextId, sort, timeInHour, timeInMinute } from "socket-function/src/misc";
 import { cache, lazy } from "socket-function/src/caching";
 import { runInParallel, runInSerial, runInfinitePoll } from "socket-function/src/batching";
 import { sha256 } from "js-sha256";
-import child_process from "child_process";
-import { getPPID } from "../misc/getParentProcessId";
 import { Args } from "socket-function/src/types";
-import { getArchivesBackblaze } from "./archivesBackBlaze";
-import { formatNumber } from "socket-function/src/formatting/format";
 import { SizeLimiter } from "../diagnostics/SizeLimiter";
 import { isPublic } from "../config";
-import { measureWrap } from "socket-function/src/profiling/measure";
 
-const SIZE_LIMIT = new SizeLimiter({
-    diskRoot: getStorageDir(),
+const SIZE_LIMIT = lazy(() => new SizeLimiter({
+    diskRoot: getCacheDir(),
     maxBytes: isPublic() ? 1024 * 1024 * 1024 * 250 : 1024 * 1024 * 1024 * 100,
     // Anything less than this and we can't even load enough weights models for a single task
     minBytes: 1024 * 1024 * 1024 * 8,
     maxDiskFraction: 0.3,
-    maxTotalDiskFraction: 0.95,
+    // Add margin, as multiple processes don't sync the cache state often.
+    maxTotalDiskFraction: 0.75,
     maxFiles: 1000 * 25,
-});
+}));
 
 const UPDATE_METRICS_INTERVAL = timeInMinute * 30;
-const cacheArchives2 = getSubFolder("cache");
+const ATIME_BUMP_INTERVAL = timeInMinute * 5;
+
+const lastAtimeBump = new Map<string, number>();
+function bumpAtimeIfStale(path: string) {
+    let now = Date.now();
+    let last = lastAtimeBump.get(path) ?? 0;
+    if (now - last < ATIME_BUMP_INTERVAL) return;
+    lastAtimeBump.set(path, now);
+    let when = new Date(now);
+    fs.promises.utimes(path, when, when).catch((e: any) => {
+        if (e?.code === "ENOENT") return;
+        console.warn(`Failed to bump atime for ${path}:`, (e as Error).stack ?? e);
+    });
+}
+
+const getCacheDir = lazy(() => {
+    let dir = os.homedir().replaceAll("\\", "/") + "/.querysub-cache/";
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    return dir;
+});
 
-const LOCK_SUFFIX = ".lock";
 const TEMP_SUFFIX = ".tmp";
 const TEMP_THRESHOLD = timeInHour * 3;
 
@@ -47,7 +62,7 @@ export function getArchiveCachePath(archives: Archives, key: string): string {
     let name = fullFileName.replace(/[<>:"\/\\|?*\x00-\x1F]/g, "_");
     // Remove spaces, as I think they are causing some issues if they are at the end
     name = name.replaceAll(" ", "");
-    return cacheArchives2 + hash.slice(0, 16) + "." + name.slice(0, 128) + CACHE_SUFFIX;
+    return getCacheDir() + hash.slice(0, 16) + "." + name.slice(0, 128) + CACHE_SUFFIX;
 }
 
 const getDiskMetricsBase = async () => {
@@ -61,19 +76,9 @@ const getDiskMetricsBase = async () => {
 
     let usedCacheBytes = 0;
     let usedCacheFiles = 0;
-    let cacheFiles = await fs.promises.readdir(cacheArchives2);
+    let cacheFiles = await fs.promises.readdir(getCacheDir());
     async function processFile(file: string) {
-        if (file.endsWith(LOCK_SUFFIX)) {
-            let base = file.slice(0, -LOCK_SUFFIX.length);
-            if (!fs.existsSync(base) && !await isLocked(cacheArchives2 + base)) {
-                try {
-                    // NOTE: This races, it might not be locked when we check, but a lock
-                    //  might be added right here. But... what else can we do? We need
-                    //  to cleanup unused locks at some point...
-                    await fs.promises.unlink(cacheArchives2 + file);
-                } catch { }
-            }
-        } else if (file.endsWith(CACHE_SUFFIX)) {
+        if (file.endsWith(CACHE_SUFFIX)) {
             let info: fs.Stats | undefined;
             try {
                 info = await fs.promises.stat(file);
@@ -90,11 +95,11 @@ const getDiskMetricsBase = async () => {
             try {
                 // TEMP files, and... any files?
                 // If it's too old, delete it
-                let stat = await fs.promises.stat(cacheArchives2 + file);
+                let stat = await fs.promises.stat(getCacheDir() + file);
                 let threshold = Date.now() - TEMP_THRESHOLD;
                 if (stat.mtimeMs < threshold) {
                     try {
-                        await fs.promises.unlink(cacheArchives2 + file);
+                        await fs.promises.unlink(getCacheDir() + file);
                     } catch { }
                 }
                 // If we can't stat it, someone else deleted it, so that's fine...
@@ -104,10 +109,10 @@ const getDiskMetricsBase = async () => {
     let processFileParallel = runInParallel({ parallelCount: 32 }, processFile);
     await Promise.all(cacheFiles.map(processFileParallel));
 
-    let { remove, availableBytes, availableFiles } = await SIZE_LIMIT.limit(fileSizes);
+    let { remove, availableBytes, availableFiles } = await SIZE_LIMIT().limit(fileSizes);
     for (let file of remove) {
         try {
-            await fs.promises.unlink(cacheArchives2 + file.path);
+            await fs.promises.unlink(getCacheDir() + file.path);
         } catch { }
     }
 
@@ -138,19 +143,25 @@ const getDiskMetricsBase = async () => {
         let sourceTempFileStat = await fs.promises.stat(sourceTempFile);
         availableBytes -= sourceTempFileStat.size;
         availableFiles--;
-        while ((availableBytes < 0 || availableFiles < 0) && fileSizes.length > 0) {
-            let leastRecentlyAccessed = fileSizes[0];
-            for (let file of fileSizes) {
-                if (file.time < leastRecentlyAccessed.time) {
-                    leastRecentlyAccessed = file;
+        sort(fileSizes, x => x.time);
+        for (let i = 0; i < fileSizes.length;) {
+            if (availableBytes >= 0 && availableFiles >= 0) break;
+            let file = fileSizes[i];
+            let deleted = false;
+            try {
+                await fs.promises.unlink(file.path);
+                deleted = true;
+            } catch (e: any) {
+                if (e?.code === "ENOENT") {
+                    deleted = true;
+                } else {
+                    console.warn(`Failed to evict cache file ${file.path}:`, (e as Error).stack ?? e);
                 }
             }
-            let size = 0;
-            try {
-                size = (await fs.promises.stat(leastRecentlyAccessed.path)).size;
-            } catch { }
-            if (await deleteCacheFile(leastRecentlyAccessed.path)) {
-                removeFile(leastRecentlyAccessed.path);
+            if (deleted) {
+                removeFile(file.path);
+            } else {
+                i++;
             }
         }
         fileSizes.push({
@@ -200,15 +211,10 @@ const getDiskMetricsBase = async () => {
         }
         if (buffer) {
             updateAccessTime(path);
+            bumpAtimeIfStale(path);
         }
         return buffer;
     }
-    async function getPathAndLock(archives: Archives, key: string): Promise<string> {
-        let path = getArchiveCachePath(archives, key);
-        await lockFile(path);
-        updateAccessTime(path);
-        return path;
-    }
     async function delCacheFile(archives: Archives, key: string): Promise<void> {
         let path = getArchiveCachePath(archives, key);
         if (removeFile(path)) {
@@ -225,7 +231,6 @@ const getDiskMetricsBase = async () => {
         addCacheFile: runInSerial(addCacheFile),
         getCacheFile,
         delCacheFile,
-        getPathAndLock,
     };
 };
 let curSeqNum = 1;
@@ -242,23 +247,6 @@ const ensureDiskMetricsUpdated = lazy(() => {
     });
 });
 
-export type LockFncs = {
-    // Get a path to the file locally, locking it so it won't be garbage collected until lockRegion completes
-    //  - If the file isn't in the archives, returns undefined, and doesn't lock it
-    getPathAndLock(fileName: string): Promise<string | undefined>;
-    // Gets it, and only checks the cache, not the archives. Faster, but means it might be deleted in
-    //  the archives and we will still use it locally.
-    getPathAndLockFast(fileName: string): Promise<string | undefined>;
-    getPathAndLockCacheOnly(fileName: string): Promise<string | undefined>;
-    // MOVES the sourceFileName to the archives (so sourceFileName will be deleted after this runs),
-    //  and locks the archives file until lockRegion completes
-    moveFileAndLock(config: {
-        archivesFilename: string;
-        sourceFileName: string;
-        onlyCache?: boolean;
-    }): Promise<string>;
-};
-
 let cacheArchivesSymbol = Symbol("cacheArchives");
 /** IMPORTANT! The cache assumes the files contents immutable, and they will only be created
  *      and deleted, never mutated.
@@ -266,14 +254,6 @@ let cacheArchivesSymbol = Symbol("cacheArchives");
 export function wrapArchivesWithCache(archives: Archives, rootConfig?: {
     immutable?: boolean;
 }): Archives & {
-    // NOTE: lockRegion / path based functions are preferred for external accesses, as they ensure files
-    //  won't be garbage collected, and uses paths, which will be required for external processes.
-    //  - Locks only protect the local cache. The values can still be deleted explicitly.
-    lockRegion<T>(
-        code: (
-            fncs: LockFncs
-        ) => Promise<T>
-    ): Promise<T>;
     debugGetPath(key: string): string;
 } {
     if (cacheArchivesSymbol in archives) {
@@ -303,7 +283,6 @@ export function wrapArchivesWithCache(archives: Archives, rootConfig?: {
         await metrics.addCacheFile(archives, config.path, tempPath);
         let cachePath = getArchiveCachePath(archives, config.path);
 
-        await lockFile(cachePath);
         let pos = 0;
         let cacheHandle: fs.promises.FileHandle = await fs.promises.open(cachePath, "r");
         let data = Buffer.alloc(LARGE_FILE_CHUNK);
@@ -329,185 +308,8 @@ export function wrapArchivesWithCache(archives: Archives, rootConfig?: {
             });
         } finally {
             await cacheHandle.close();
-            await unlockFile(cachePath);
         }
     }
-    function createGetPathAndLock(locked: string[]) {
-        return async function getPathAndLock(fileName: string) {
-            const info = await archives.getInfo(fileName);
-            if (!info) return undefined;
-
-            let path = getArchiveCachePath(archives, fileName);
-            await lockFile(path);
-            locked.push(path);
-
-            try {
-                let cacheStat = await fs.promises.stat(path);
-                // NOTE: We check the size, and not just the existence, in case the file
-                //  is partially populated? Even though this isn't a real thing, as we rename
-                //  when we copy it...
-                if (cacheStat.size === info.size) {
-                    return path;
-                }
-            } catch {
-                // It doesn't exist, so read it in
-            }
-
-            let startRead = Date.now();
-
-            let readPos = 0;
-            let getNextDataBase = async (): Promise<Buffer | undefined> => {
-                if (readPos >= info.size) return undefined;
-                let curPos = readPos;
-                readPos += LARGE_FILE_CHUNK;
-                let end = Math.min(readPos, info.size);
-                let data = await archives.get(fileName, { range: { start: curPos, end } });
-                if (!data?.length) return undefined;
-                return data;
-            };
-
-            let nextWriteIndex = 0;
-            let buffers: (Buffer | { error: Error } | null | undefined | (() => void))[] = [];
-
-            async function getThread() {
-                while (true) {
-                    let index = nextWriteIndex++;
-                    let next: typeof buffers[number];
-                    try {
-                        next = await getNextDataBase();
-                    } catch (e: any) {
-                        next = { error: e };
-                    }
-                    let prev = buffers[index];
-                    buffers[index] = next || null;
-                    if (typeof prev === "function") {
-                        prev();
-                    }
-                    if (!next || "error" in next) break;
-                }
-            }
-            // Read in parallel, for faster read times, and so we can read from backblaze
-            //  while writing to disk.
-            void list(8).map(getThread);
-
-            let nextReadIndex = 0;
-            let getNextData = async (): Promise<Buffer | undefined> => {
-                let index = nextReadIndex++;
-                if (buffers[index] === null) return undefined;
-                if (!buffers[index]) {
-                    await new Promise<void>(resolve => {
-                        buffers[index] = resolve;
-                    });
-                }
-                let result = buffers[index] as any;
-                // Clear it, so we don't store all buffers in memory
-                buffers[index] = undefined;
-                return result;
-            };
-
-            let size = 0;
-            const tempPath = getTempFilePath();
-            let handle: fs.promises.FileHandle | undefined;
-            try {
-                handle = await fs.promises.open(tempPath, "w");
-                while (true) {
-                    let data = await getNextData();
-                    if (!data?.length) break;
-                    await handle.write(data, 0, data.length, size);
-                    size += data.length;
-                }
-            } finally {
-                if (handle) {
-                    try {
-                        await handle.close();
-                    } catch { }
-                }
-            }
-            let totalRead = Date.now() - startRead;
-            console.log(`Read ${formatNumber(info.size)}B at ${formatNumber(info.size / totalRead)}B/s into cache (${fileName})`);
-
-            let metrics = await getDiskMetrics();
-            await metrics.addCacheFile(archives, fileName, tempPath);
-
-            return path;
-        };
-    }
-    function createGetPathAndLockFast(locked: string[]) {
-        return async function getPathAndLockFast(fileName: string) {
-            let path = getArchiveCachePath(archives, fileName);
-            await lockFile(path);
-            locked.push(path);
-            try {
-                // If it exists in the cache, just return the path. Otherwise, we might have to read it in
-                await fs.promises.stat(path);
-                return path;
-            } catch {
-                return createGetPathAndLock(locked)(fileName);
-            }
-        };
-    }
-    function createMovePathFromFileAndLock(locked: string[]) {
-        return async function movePathFromFileAndLock(config: {
-            archivesFilename: string;
-            sourceFileName: string;
-            onlyCache?: boolean;
-        }): Promise<string> {
-            let { archivesFilename, sourceFileName } = config;
-            if (!config.onlyCache) {
-                // NOTE: While we COULD use a rename to quickly move the file... we have to at least copy
-                //  it to the underlying archives, so... moving it piece by piece is fine...
-
-                let handle: fs.promises.FileHandle = await fs.promises.open(sourceFileName, "r");
-                let data = Buffer.alloc(LARGE_FILE_CHUNK);
-                let pos = 0;
-                async function getNextData(): Promise<Buffer | undefined> {
-                    try {
-                        let read = await handle.read(data, 0, LARGE_FILE_CHUNK, pos);
-                        if (read.bytesRead === 0) return undefined;
-                        if (read.bytesRead < LARGE_FILE_CHUNK) {
-                            data = data.slice(0, read.bytesRead);
-                        }
-                        pos += read.bytesRead;
-                        return data;
-                    } catch {
-                        return undefined;
-                    }
-                }
-                try {
-                    await setLargeFile({
-                        path: archivesFilename,
-                        getNextData,
-                    });
-                    await handle.close();
-                    handle = undefined as any;
-                    await fs.promises.unlink(sourceFileName);
-                } finally {
-                    if (handle) {
-                        await handle.close();
-                    }
-                }
-            } else {
-                await fs.promises.rename(sourceFileName, getArchiveCachePath(archives, archivesFilename));
-            }
-            let path = getArchiveCachePath(archives, archivesFilename);
-            await lockFile(path);
-            locked.push(path);
-            return path;
-        };
-    }
-    function createGetPathAndLockCacheOnly(locked: string[]) {
-        return async function getPathAndLockCacheOnly(fileName: string) {
-            let path = getArchiveCachePath(archives, fileName);
-            await lockFile(path);
-            locked.push(path);
-            try {
-                await fs.promises.stat(path);
-                return path;
-            } catch {
-                return undefined;
-            }
-        };
-    }
     function debugGetPath(key: string) {
         return getArchiveCachePath(archives, key);
     }
@@ -592,351 +394,5 @@ export function wrapArchivesWithCache(archives: Archives, rootConfig?: {
             await archives.move(config);
         },
         getBaseArchives: () => archives.getBaseArchives?.() ?? ({ archives: archives, parentPath: "" }),
-
-        async lockRegion<T>(code: (fncs: LockFncs) => Promise<T>) {
-            let locked: string[] = [];
-            let fncs = {
-                getPathAndLock: createGetPathAndLock(locked),
-                getPathAndLockFast: createGetPathAndLockFast(locked),
-                moveFileAndLock: createMovePathFromFileAndLock(locked),
-                getPathAndLockCacheOnly: createGetPathAndLockCacheOnly(locked),
-            };
-            try {
-                return await code(fncs);
-            } finally {
-                for (let path of locked) {
-                    await unlockFile(path);
-                }
-            }
-        },
-    });
-}
-
-
-function lockFilePath(path: string): string {
-    return path + LOCK_SUFFIX;
-}
-
-function getUniqueId() {
-    return process.pid + " " + process.ppid;
-}
-
-let lockCache = new Map<string, number>();
-async function lockFile(path: string): Promise<void> {
-    // NOTE: If we don't stop ourself from locking it multiple times, a single process
-    //  could use up the fill lock file limit, which would break the system.
-    let prevCount = lockCache.get(path);
-    if (prevCount) {
-        lockCache.set(path, prevCount + 1);
-        return;
-    }
-    if (!prevCount) {
-        const lockPath = lockFilePath(path);
-        // NOTE: Locking is taking WAY too long, so... we're not going to wait. This should still
-        //  be mostly fine, due to how we maintain transactions files.
-        lockRetryLoop(async function appendFile() {
-            await fs.promises.appendFile(lockPath, "lock " + getUniqueId() + "\n");
-        }).catch(e => console.error("Error appending file lock for", path, e));
-    }
-    prevCount = lockCache.get(path) || 0;
-    lockCache.set(path, prevCount + 1);
-}
-
-async function unlockFile(path: string): Promise<void> {
-    let prevCount = lockCache.get(path);
-    if (!prevCount) {
-        console.warn(`Unlocking a file that wasn't locked: ${path}`);
-    } else {
-        prevCount--;
-        lockCache.set(path, prevCount);
-        if (prevCount <= 0) {
-            lockCache.delete(path);
-        }
-    }
-    if (!prevCount) {
-        await isLocked(path, { type: "unlock", lock: "lock " + getUniqueId() });
-    }
-}
-
-async function lockRetryLoop<T>(code: () => Promise<T>): Promise<T> {
-    while (true) {
-        try {
-            return await code();
-        } catch (error: any) {
-            if (error.code === "EBUSY") {
-                console.log("Lock file busy, retrying in 1 second");
-                await new Promise(r => setTimeout(r, 1000));
-                continue;
-            }
-            throw error;
-        }
-    }
-}
-
-async function getHandle(path: string) {
-    while (true) {
-        try {
-            return await fs.promises.open(path, "r+");
-        } catch (error: any) {
-            if (error.code === "ENOENT") {
-                try {
-                    return await fs.promises.open(path, "wx+");
-                } catch (error: any) {
-                    if (error.code === "EEXIST") {
-                        continue;
-                    }
-                    throw error;
-                }
-            }
-            throw error;
-        }
-    }
-}
-
-
-/** NOTE: This inherently has a race condition, as anything you do based on isLocked
- *      could be invalidated by the time you do it. But... this should be good enough
- *      for our use case...
- */
-async function isLocked(path: string, operation?: {
-    type: "delete";
-} | {
-    type: "unlock";
-    lock: string;
-}): Promise<number> {
-    const lockPath = lockFilePath(path);
-
-    async function filterToValidState(locks: string[]): Promise<string[]> {
-        let existingLocks: string[] = [];
-        for (let lock of locks) {
-            if (lock.startsWith("lock ")) {
-                let [_, pid, ppid] = lock.split(" ");
-                const invalid = (
-                    !await isProcessAlive(+pid)
-                    || !await isProcessAlive(+ppid)
-                    || await getPPID(+pid) !== +ppid
-                );
-                await getPPID(+pid);
-                if (!invalid) {
-                    existingLocks.push(lock);
-                }
-            } else {
-                continue;
-            }
-        }
-        return Array.from(existingLocks);
-    }
-
-    return await lockRetryLoop(async function isLocked() {
-        let handle = await getHandle(lockPath);
-        try {
-            const { flock } = await import("fs-ext");
-            await new Promise<void>((r, e) => flock(handle.fd, "ex", err => err ? e(err) : r()));
-            let contents = (await handle.readFile()).toString();
-            let locks = contents.toString().replaceAll("\0", "").trim().split("\n").filter(x => x);
-            let validLocks = await filterToValidState(locks);
-            if (operation?.type === "unlock") {
-                let index = validLocks.indexOf(operation.lock);
-                if (index >= 0) {
-                    validLocks.splice(index, 1);
-                }
-            }
-            if (validLocks.length !== locks.length) {
-                //console.log(`Lock count changed from ${locks.length} to ${validLocks.length}`);
-                let newContents = Buffer.from(validLocks.map(x => x + "\n").join(""));
-                if (newContents.length < contents.length) {
-                    newContents = Buffer.concat([newContents, Buffer.alloc(contents.length - newContents.length)]);
-                }
-                await handle.write(newContents, 0, newContents.length, 0);
-            } else {
-                //console.log(`Lock count unchanged: ${validLocks.length}`);
-            }
-            if (operation?.type === "delete") {
-                if (validLocks.length === 0) {
-                    await fs.promises.unlink(path);
-                }
-            }
-            return validLocks.length;
-        } catch (error: any) {
-            if (error.code === "ENOENT") {
-                return 0; // Lock file doesn't exist
-            }
-            throw error; // Unexpected error, rethrow
-        } finally {
-            await handle.close();
-        }
-    });
-}
-async function execPromise(command: string, args: string[]): Promise<string> {
-    return new Promise((resolve, reject) => {
-        child_process.execFile(command, args, (error, stdout, stderr) => {
-            if (error) {
-                reject(error);
-                return;
-            }
-            resolve(stdout);
-        });
-    });
-}
-
-
-async function isProcessAlive(pid: number): Promise<boolean> {
-    try {
-        process.kill(pid, 0);
-        return true;
-    } catch (error) {
-        return false;
-    }
-}
-
-
-async function atomicRead(path: string) {
-    while (true) {
-        let stat0 = fs.statSync(path);
-        let contents = fs.readFileSync(path);
-        let stat1 = fs.statSync(path);
-        if (stat0.mtimeMs === stat1.mtimeMs) {
-            return contents;
-        }
-    }
-};
-
-async function lockCacheFile(archives: Archives, key: string): Promise<void> {
-    await lockFile(getArchiveCachePath(archives, key));
-}
-async function unlockCacheFile(archives: Archives, key: string): Promise<void> {
-    await unlockFile(getArchiveCachePath(archives, key));
-}
-// Returns true if it was deleted
-async function deleteCacheFile(path: string): Promise<boolean> {
-    let cannotDelete = await isLocked(path, { type: "delete" });
-    return !cannotDelete;
-}
-
-// for i in {1..100}; do yarn typenode src/-b-archives/archiveCache.ts & done
-
-async function testLocks() {
-    let testFiles = ["a", "b", "c"].map(x => cacheArchives2 + x);
-    function getAFile() {
-        let file = testFiles[Math.floor(Math.random() * testFiles.length)];
-        console.log(file);
-        return file;
-    }
-
-    function assert(condition: unknown, message: string) {
-        if (!condition) {
-            throw new Error(message);
-        }
-    }
-
-    async function test1() {
-        let file = getAFile();
-        await lockFile(file);
-        let locked = await isLocked(file);
-        assert(locked, "File should be locked");
-        await new Promise(r => setTimeout(r, 100));
-        await unlockFile(file);
-        console.log(await fs.promises.readFile(file + LOCK_SUFFIX, "utf8"));
-    }
-    async function test2() {
-        let file = getAFile();
-        let notDeleted = await isLocked(file, { type: "delete" });
-        if (notDeleted) {
-            console.log("File was not deleted, as it was locked");
-        } else {
-            console.log("File was deleted");
-        }
-    }
-    async function test3() {
-        let count = 10;
-        let file = getAFile();
-        console.log(`Lock count before: ${await isLocked(file)}`);
-        for (let i = 0; i < count; i++) {
-            await lockFile(file);
-        }
-        for (let i = 0; i < count; i++) {
-            await unlockFile(file);
-        }
-        console.log(`Lock count after: ${await isLocked(file)}`);
-    }
-    async function test4() {
-        let file = getAFile();
-        await lockFile(file);
-        let notDeleted = await isLocked(file, { type: "delete" });
-        assert(notDeleted, "File should not be deleted if it is locked");
-        await unlockFile(file);
-    }
-
-
-    async function runRandomTest() {
-        let testFn = [test1, test2, test3, test4][Math.floor(Math.random() * 4)];
-        console.log(`Running test: ${testFn.name}`);
-        await testFn();
-    }
-    for (let i = 0; i < 1000; i++) {
-        await runRandomTest();
-    }
-}
-//testLocks().catch(console.error).finally(() => process.exit(0));
-
-
-async function testLargeFiles() {
-    const largeFile = "E:/downloads/Weird.Science.1985.EXTENDED.1080p.BluRay.H264.AAC-RARBG/weirdscience.mp4";
-    let test = wrapArchivesWithCache(getArchivesBackblaze("querysub.com-testbucket"));
-
-    /*
-    let cacheHandle: fs.promises.FileHandle = await fs.promises.open(largeFile, "r");
-    let data = Buffer.alloc(LARGE_FILE_CHUNK);
-    let pos = 0;
-    async function getNextData(): Promise<Buffer | undefined> {
-        try {
-            let read = await cacheHandle.read(data, 0, LARGE_FILE_CHUNK, pos);
-            if (read.bytesRead === 0) return undefined;
-            if (read.bytesRead < LARGE_FILE_CHUNK) {
-                data = data.slice(0, read.bytesRead);
-            }
-            pos += read.bytesRead;
-            return data;
-        } catch {
-            return undefined;
-        }
-    }
-
-    await test.setLargeFile({
-        path: "test.mp4",
-        getNextData,
-    });
-    */
-
-
-    await test.lockRegion(async fncs => {
-        let newPath = await fncs.getPathAndLock("copy.mp4");
-        console.log({ newPath });
     });
-
-
-    /*
-    logErrors((async () => {
-        while (true) {
-            let first100Bytes = await test.get("copy.mp4", { range: { start: 0, end: 100 } });
-            console.log({ first100Bytes });
-            await delay(5000);
-        }
-    })());
-
-    {
-        let pos = 0;
-        async function getNextData(): Promise<Buffer | undefined> {
-            let data = await test.get("test.mp4", { range: { start: pos, end: pos + LARGE_FILE_CHUNK } });
-            if (!data?.length) return undefined;
-            pos += data.length;
-            return data;
-        }
-        await test.setLargeFile({
-            path: "copy.mp4",
-            getNextData,
-        });
-    }
-    */
 }
-//testLargeFiles().catch(console.error).finally(() => process.exit(0));