sliftutils 0.10.0 → 0.12.0

package/storage/dist/TransactionStorage.ts.cache

@@ -0,0 +1,421 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.TransactionStorage = void 0;
+const misc_1 = require("socket-function/src/misc");
+const zip_1 = require("../misc/zip");
+const batching_1 = require("socket-function/src/batching");
+const format_1 = require("socket-function/src/formatting/format");
+const PendingManager_1 = require("./PendingManager");
+const buildFlag_1 = require("../../buildFlag");
+/*
+// Spec:
+//      - Zip individual large values
+//      - Stores a transaction log
+//          - Transaction log has a header, which is JSON, for things such as "zipped"
+//          - Transaction log uses length prefixed values, with a special 8 bytes to denote the end,
+//              and 8 for the start.
+//          - When transaction log is iterated on, if the bytes at the end (using the length prefix)
+//              don't match the end bytes OR the start bytes are wrong, we skip the start bytes,
+//              and iterating until we find new start bytes that match our special bytes. Then we try
+//              to read these values.
+//          - Each transaction entry has a byte for flags, one bit which denotes if the value is zipped or not.
+//      - Compresses the log after there are 3X entries than keys (and > 100)
+//          - Both dedupe keys, and zip
+//      - Assumes all files in rawStorage ending with .tx are transaction logs
+//      - Names files like `${generation}.tx`
+//          - When compressing, we increment the generation, and write to a new file, and delete
+//              any generations that are older than the new one
+//          - On reading, we read from all generation files that exist, in case some are corrupted
+//      - On load, loads in all transaction logs, and stores all values in a Map<string, Buffer>
+//      - On writes immediately updates the in memory Map, and then writes to the transaction log
+//      - Caches the last transaction file name in memory
+//      - Makes sure all file system writes (but not Map updates) are done with fileLockSection,
+//          so they never overlap.
+//      - Buffers pending appends in memory, so they can written all at once (after the first one
+//          is blocking in fileLockSection).
+
+UPDATE now we use chunks, because append is too slow.
+
+IMPORTANT! If there are multiple writers, we clobber writes from other writers when we compress
+*/
+const FILE_CHUNK_SIZE = 1024 * 1024;
+const FILE_ZIP_THRESHOLD = 16 * 1024 * 1024;
+const ZIP_THRESHOLD = 4096;
+const START_BYTES = Buffer.from([236, 49, 112, 121, 27, 127, 227, 63]);
+const END_BYTES = Buffer.from([220, 111, 243, 202, 200, 79, 213, 63]);
+// Delay writes, so we batch better, and thrash the disk less
+const WRITE_DELAY = 500;
+const fileLockSection = (0, batching_1.runInSerial)(async (fnc) => {
+    await fnc();
+});
+const CHUNK_EXT = ".chunk";
+const ourId = Date.now() + Math.random();
+class TransactionStorage {
+    constructor(rawStorage, debugName, writeDelay = WRITE_DELAY) {
+        this.rawStorage = rawStorage;
+        this.debugName = debugName;
+        this.writeDelay = writeDelay;
+        this.cache = new Map();
+        this.currentChunk = 0;
+        this.currentChunkSize = 0;
+        this.entryCount = 0;
+        this.init = this.loadAllTransactions();
+        this.pendingAppends = [];
+        this.extraAppends = 0;
+        this.updatePendingAppends = (0, misc_1.throttleFunction)(100, async () => {
+            let appendCount = this.pendingAppends.length + this.extraAppends;
+            let group = `Transaction (${this.debugName})`;
+            //console.log(`Update pending appends ${group}: ${appendCount}`);
+            if (!appendCount) {
+                (0, PendingManager_1.setPending)(group, "");
+                return;
+            }
+            (0, PendingManager_1.setPending)(group, `Pending appends: ${appendCount}`);
+        });
+        this.compressing = false;
+        TransactionStorage.allStorage.push(this);
+    }
+    // Helps get rid of parse errors which constantly log. Also, uses less space
+    static async compressAll() {
+        for (let storage of TransactionStorage.allStorage) {
+            await storage.compressTransactionLog(true);
+        }
+    }
+    getChunk(chunk) { return `${chunk}_${ourId}${CHUNK_EXT}`; }
+    async get(key) {
+        await this.init;
+        const value = this.cache.get(key);
+        if (value && value.isZipped && value.value) {
+            value.value = await zip_1.Zip.gunzip(value.value);
+            value.isZipped = false;
+        }
+        return value === null || value === void 0 ? void 0 : value.value;
+    }
+    async set(key, value) {
+        if (this.init)
+            await this.init;
+        // Time is set on disk write, as Date.now() is too slow
+        let entry = { key, value, isZipped: false, time: 0 };
+        this.cache.set(key, entry);
+        if (value.length >= ZIP_THRESHOLD) {
+            value = await zip_1.Zip.gzip(value);
+            entry.value = value;
+            entry.isZipped = true;
+        }
+        await this.pushAppend(entry);
+    }
+    async remove(key) {
+        if (this.init)
+            await this.init;
+        this.cache.delete(key);
+        await this.pushAppend({ key, value: undefined, isZipped: false, time: 0 });
+    }
+    async getInfo(key) {
+        await this.init;
+        const value = this.cache.get(key);
+        if (!(value === null || value === void 0 ? void 0 : value.value))
+            return undefined;
+        return { size: value.value.length, lastModified: value.time };
+    }
+    async pushAppend(entry) {
+        this.entryCount++;
+        this.pendingAppends.push(entry);
+        void this.updatePendingAppends();
+        if (this.pendingWrite)
+            return this.pendingWrite;
+        this.pendingWrite = fileLockSection(async () => {
+            // Delay to allow batching, and deduping
+            await new Promise(resolve => setTimeout(resolve, this.writeDelay));
+            let curAppends = this.pendingAppends;
+            this.pendingAppends = [];
+            this.pendingWrite = undefined;
+            {
+                let appendsDeduped = new Map();
+                for (const entry of curAppends) {
+                    appendsDeduped.set(entry.key, entry);
+                }
+                curAppends = Array.from(appendsDeduped.values());
+            }
+            this.extraAppends += curAppends.length;
+            void this.updatePendingAppends();
+            if (curAppends.length === 0)
+                return;
+            try {
+                let time = Date.now();
+                for (let entry of curAppends) {
+                    entry.time = time;
+                }
+                let newSum = 0;
+                let buffers = [];
+                for (const entry of curAppends) {
+                    let buffer = this.serializeTransactionEntry(entry);
+                    buffers.push(buffer);
+                    newSum += buffer.length;
+                }
+                let newChunks = this.chunkBuffers(buffers);
+                for (let chunk of newChunks) {
+                    let file = this.getChunk(this.currentChunk);
+                    if (!await this.rawStorage.get(file)) {
+                        let { header, headerBuffer } = this.getHeader(false);
+                        await this.rawStorage.set(file, headerBuffer);
+                    }
+                    let content = chunk.buffer;
+                    await this.rawStorage.append(file, content);
+                    this.currentChunkSize += content.length;
+                    if (this.currentChunkSize >= FILE_CHUNK_SIZE) {
+                        this.currentChunk++;
+                        this.currentChunkSize = 0;
+                    }
+                }
+                await this.compressTransactionLog();
+            }
+            finally {
+                this.extraAppends -= curAppends.length;
+                void this.updatePendingAppends();
+            }
+        });
+        await this.pendingWrite;
+    }
+    async getKeys() {
+        if (this.init)
+            await this.init;
+        return Array.from(this.cache.keys());
+    }
+    async loadAllTransactions() {
+        if ((0, buildFlag_1.isInBuild)())
+            return;
+        let time = Date.now();
+        const keys = await this.rawStorage.getKeys();
+        const transactionFiles = keys.filter(key => key.endsWith(CHUNK_EXT));
+        (0, misc_1.sort)(transactionFiles, x => parseInt(x));
+        let size = 0;
+        for (const file of transactionFiles) {
+            let chunk = parseInt(file);
+            let curSize = await this.loadTransactionFile(file);
+            if (chunk >= this.currentChunk) {
+                this.currentChunk = chunk;
+                this.currentChunkSize = curSize;
+            }
+            size += curSize;
+        }
+        time = Date.now() - time;
+        if (time > 50) {
+            console.log(`Loaded ${this.debugName} in ${(0, format_1.formatTime)(time)}, ${(0, format_1.formatNumber)(this.cache.size)} keys, ${(0, format_1.formatNumber)(size)}B`);
+        }
+        this.init = undefined;
+    }
+    async loadTransactionFile(filename) {
+        const fullFile = await this.rawStorage.get(filename);
+        if (!fullFile)
+            return 0;
+        if (fullFile.length < 4) {
+            //console.error(`Transaction in ${this.debugName} file ${filename} is too small, skipping`);
+            return 0;
+        }
+        let headerSize = fullFile.readUInt32LE(0);
+        let headerBuffer = fullFile.slice(4, 4 + headerSize);
+        let header;
+        try {
+            header = JSON.parse(headerBuffer.toString());
+        }
+        catch (e) {
+            console.error(`Failed to parse header of transaction file in ${this.debugName}, ${filename}`);
+            return 0;
+        }
+        let content = fullFile.slice(4 + headerSize);
+        if (header.zipped) {
+            content = await zip_1.Zip.gunzip(content);
+        }
+        let offset = 0;
+        let entries = [];
+        while (offset < content.length) {
+            if (!content.slice(offset, offset + START_BYTES.length).equals(START_BYTES)) {
+                let s = offset;
+                while (offset < content.length && !content.slice(offset, offset + START_BYTES.length).equals(START_BYTES)) {
+                    offset++;
+                }
+                let len = offset - s;
+                console.warn(`Found bad bytes in ${filename}, skipping ${len} bytes at offset ${s}. Total file bytes ${content.length}, read ${entries.length} entries`);
+                if (offset >= content.length)
+                    break;
+            }
+            let entryObj;
+            try {
+                entryObj = this.readTransactionEntry(content, offset);
+            }
+            catch (e) {
+                if (e.message.includes("Read past end of buffer")) {
+                    offset += 1;
+                    continue;
+                }
+                throw e;
+            }
+            if (!entryObj) {
+                console.warn(`Failed to read transaction entry in in ${this.debugName}, file ${filename} at offset ${offset}, skipping bad bytes, reading remainder of file`);
+                offset++;
+                continue;
+            }
+            this.entryCount++;
+            let { entry } = entryObj;
+            offset = entryObj.offset;
+            entries.push(entry);
+            if (entry.value === undefined) {
+                this.cache.delete(entry.key);
+            }
+            else {
+                let prev = this.cache.get(entry.key);
+                if (prev && (prev.time > entry.time)) {
+                    continue;
+                }
+                this.cache.set(entry.key, entry);
+            }
+        }
+        return fullFile.length;
+    }
+    readTransactionEntry(buffer, offset) {
+        function readSlice(count) {
+            const slice = buffer.slice(offset, offset + count);
+            if (slice.length < count)
+                throw new Error(`Read past end of buffer at offset ${offset}/${buffer.length}`);
+            offset += count;
+            return slice;
+        }
+        if (!readSlice(START_BYTES.length).equals(START_BYTES))
+            return undefined;
+        const keyLength = readSlice(4).readUInt32LE(0);
+        const valueLength = readSlice(4).readUInt32LE(0);
+        const time = readSlice(8).readDoubleLE(0);
+        const flags = readSlice(1).readUInt8(0);
+        const key = readSlice(keyLength).toString();
+        let value = readSlice(valueLength);
+        if (!readSlice(END_BYTES.length).equals(END_BYTES))
+            return undefined;
+        let isZipped = (flags & 1) === 1;
+        let isDelete = (flags & 2) === 2;
+        let entry = { key, value, isZipped, time };
+        if (isDelete) {
+            entry.value = undefined;
+        }
+        return { entry, offset };
+    }
+    // TODO: Make this directly go from TransactionEntry[] to Buffer, by pre-allocating, so it is more efficient
+    serializeTransactionEntry(entry) {
+        var _a;
+        let keyBuffer = Buffer.from(entry.key);
+        const buffer = Buffer.alloc(START_BYTES.length + 4 + 4 + 8 + 1 + keyBuffer.length + (((_a = entry.value) === null || _a === void 0 ? void 0 : _a.length) || 0) + END_BYTES.length);
+        let offset = 0;
+        START_BYTES.copy(buffer, offset);
+        offset += START_BYTES.length;
+        buffer.writeUInt32LE(keyBuffer.length, offset);
+        offset += 4;
+        buffer.writeUInt32LE(entry.value ? entry.value.length : 0, offset);
+        offset += 4;
+        buffer.writeDoubleLE(entry.time, offset);
+        offset += 8;
+        let flags = 0;
+        if (entry.isZipped)
+            flags |= 1;
+        if (entry.value === undefined)
+            flags |= 2;
+        buffer.writeUInt8(flags, offset);
+        offset += 1;
+        keyBuffer.copy(buffer, offset);
+        offset += keyBuffer.length;
+        if (entry.value) {
+            entry.value.copy(buffer, offset);
+            offset += entry.value.length;
+        }
+        END_BYTES.copy(buffer, offset);
+        offset += END_BYTES.length;
+        return buffer;
+    }
+    getHeader(zip) {
+        const header = { zipped: zip };
+        let headerBuffer = Buffer.from(JSON.stringify(header));
+        let headerSize = Buffer.alloc(4);
+        headerSize.writeUInt32LE(headerBuffer.length, 0);
+        return { header, headerBuffer: Buffer.concat([headerSize, headerBuffer]) };
+    }
+    chunkBuffers(buffers) {
+        let newChunks = [];
+        newChunks.push({ buffers: [], size: 0 });
+        for (const buffer of buffers) {
+            if (newChunks[newChunks.length - 1].size + buffer.length >= FILE_CHUNK_SIZE) {
+                newChunks.push({ buffers: [], size: 0 });
+            }
+            newChunks[newChunks.length - 1].buffers.push(buffer);
+            newChunks[newChunks.length - 1].size += buffer.length;
+        }
+        return newChunks.map(x => ({ buffer: Buffer.concat(x.buffers), size: x.size }));
+    }
+    async compressTransactionLog(force) {
+        if (this.compressing)
+            return;
+        this.compressing = true;
+        let existingDiskEntries = await this.rawStorage.getKeys();
+        existingDiskEntries = existingDiskEntries.filter(x => x.endsWith(CHUNK_EXT));
+        let compressNow = force || (this.entryCount > 100 && this.entryCount > this.cache.size * 3
+            // NOTE: This compress check breaks down if we only have very large values, but... those
+            //  don't work ANYWAYS (it is better to use one file per value instead).
+            //  - Maybe we should throw, or at least warn, on sets of value > 1MB,
+            //      at which point they should just use a file per value
+            || existingDiskEntries.length > Math.max(10, Math.ceil(this.entryCount / 1000))
+            || existingDiskEntries.length > 1000 * 10);
+        if (!compressNow)
+            return;
+        console.log(`Compressing ${this.debugName} transaction log, ${this.entryCount} entries, ${this.cache.size} keys`);
+        // Load off disk, in case there are other writes. We still race with them, but at least
+        //  this reduces the race condition considerably
+        (0, misc_1.sort)(existingDiskEntries, x => parseInt(x));
+        for (let entry of existingDiskEntries) {
+            await this.loadTransactionFile(entry);
+        }
+        this.entryCount = this.cache.size;
+        let nextStart = Math.max(...existingDiskEntries.map(x => parseInt(x))) + 1;
+        let buffers = [];
+        for (const entry of this.cache.values()) {
+            let buffer = this.serializeTransactionEntry(entry);
+            buffers.push(buffer);
+        }
+        let newChunks = this.chunkBuffers(buffers);
+        let curChunk = nextStart;
+        for (let chunk of newChunks) {
+            let file = this.getChunk(curChunk++);
+            let content = chunk.buffer;
+            let { header, headerBuffer } = this.getHeader(
+            // AND, never compress the last one, otherwise we can't append to it!
+            content.length >= FILE_ZIP_THRESHOLD && chunk !== newChunks[newChunks.length - 1]);
+            if (header.zipped) {
+                content = await zip_1.Zip.gzip(content);
+            }
+            let buffer = Buffer.concat([headerBuffer, content]);
+            await this.rawStorage.set(file, buffer);
+        }
+        // This is the ONLY time we can delete old files, as we know for sure the new file has all of our data.
+        //  Any future readers won't know this, unless they write it themselves (or unless they audit it against
+        //      the other generations, which is annoying).
+        for (const file of existingDiskEntries) {
+            await this.rawStorage.remove(file);
+        }
+        this.currentChunk = curChunk;
+    }
+    async reset() {
+        await fileLockSection(async () => {
+            let existingDiskEntries = await this.rawStorage.getKeys();
+            existingDiskEntries = existingDiskEntries.filter(x => x.endsWith(CHUNK_EXT));
+            try {
+                await Promise.allSettled(existingDiskEntries.map(x => this.rawStorage.remove(x)));
+            }
+            catch (_a) { }
+            this.pendingAppends = [];
+            this.cache.clear();
+            this.currentChunk = 0;
+            this.currentChunkSize = 0;
+            this.entryCount = 0;
+        });
+    }
+}
+exports.TransactionStorage = TransactionStorage;
+TransactionStorage.allStorage = [];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"TransactionStorage.js","sourceRoot":"","sources":["TransactionStorage.ts"],"names":[],"mappings":"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","sourcesContent":["import { PromiseObj, sort, throttleFunction } from \"socket-function/src/misc\";\nimport { IStorage, IStorageRaw } from \"./IStorage\";\nimport { Zip } from \"../misc/zip\";\nimport { runInSerial } from \"socket-function/src/batching\";\nimport { formatNumber, formatTime } from \"socket-function/src/formatting/format\";\nimport { setPending } from \"./PendingManager\";\nimport { isInBuild } from \"../../buildFlag\";\n\n/*\n// Spec:\n//      - Zip individual large values\n//      - Stores a transaction log\n//          - Transaction log has a header, which is JSON, for things such as \"zipped\"\n//          - Transaction log uses length prefixed values, with a special 8 bytes to denote the end,\n//              and 8 for the start.\n//          - When transaction log is iterated on, if the bytes at the end (using the length prefix)\n//              don't match the end bytes OR the start bytes are wrong, we skip the start bytes,\n//              and iterating until we find new start bytes that match our special bytes. Then we try\n//              to read these values.\n//          - Each transaction entry has a byte for flags, one bit which denotes if the value is zipped or not.\n//      - Compresses the log after there are 3X entries than keys (and > 100)\n//          - Both dedupe keys, and zip\n//      - Assumes all files in rawStorage ending with .tx are transaction logs\n//      - Names files like `${generation}.tx`\n//          - When compressing, we increment the generation, and write to a new file, and delete\n//              any generations that are older than the new one\n//          - On reading, we read from all generation files that exist, in case some are corrupted\n//      - On load, loads in all transaction logs, and stores all values in a Map<string, Buffer>\n//      - On writes immediately updates the in memory Map, and then writes to the transaction log\n//      - Caches the last transaction file name in memory\n//      - Makes sure all file system writes (but not Map updates) are done with fileLockSection,\n//          so they never overlap.\n//      - Buffers pending appends in memory, so they can written all at once (after the first one\n//          is blocking in fileLockSection).\n\nUPDATE now we use chunks, because append is too slow.\n\nIMPORTANT! If there are multiple writers, we clobber writes from other writers when we compress\n*/\n\n\nconst FILE_CHUNK_SIZE = 1024 * 1024;\n\nconst FILE_ZIP_THRESHOLD = 16 * 1024 * 1024;\n\nconst ZIP_THRESHOLD = 4096;\nconst START_BYTES = Buffer.from([236, 49, 112, 121, 27, 127, 227, 63]);\nconst END_BYTES = Buffer.from([220, 111, 243, 202, 200, 79, 213, 63]);\n// Delay writes, so we batch better, and thrash the disk less\nconst WRITE_DELAY = 500;\n\ninterface TransactionEntry {\n    key: string;\n    value: Buffer | undefined;\n    isZipped: boolean;\n    time: number;\n}\n\ninterface TransactionHeader {\n    zipped: boolean;\n}\n\nconst fileLockSection = runInSerial(async (fnc: () => Promise<void>) => {\n    await fnc();\n});\n\nconst CHUNK_EXT = \".chunk\";\nconst ourId = Date.now() + Math.random();\n\nexport class TransactionStorage implements IStorage<Buffer> {\n    public cache: Map<string, TransactionEntry> = new Map();\n    private currentChunk = 0;\n    private currentChunkSize = 0;\n    private entryCount = 0;\n\n    private static allStorage: TransactionStorage[] = [];\n\n    constructor(\n        private rawStorage: IStorageRaw,\n        private debugName: string,\n        private writeDelay = WRITE_DELAY\n    ) {\n        TransactionStorage.allStorage.push(this);\n    }\n    // Helps get rid of parse errors which constantly log. Also, uses less space\n    public static async compressAll() {\n        for (let storage of TransactionStorage.allStorage) {\n            await storage.compressTransactionLog(true);\n        }\n    }\n\n    private init: Promise<void> | undefined = this.loadAllTransactions();\n\n    private getChunk(chunk: number) { return `${chunk}_${ourId}${CHUNK_EXT}`; }\n\n    public async get(key: string): Promise<Buffer | undefined> {\n        await this.init;\n        const value = this.cache.get(key);\n        if (value && value.isZipped && value.value) {\n            value.value = await Zip.gunzip(value.value);\n            value.isZipped = false;\n        }\n        return value?.value;\n    }\n\n    public async set(key: string, value: Buffer): Promise<void> {\n        if (this.init) await this.init;\n\n        // Time is set on disk write, as Date.now() is too slow\n        let entry: TransactionEntry = { key, value, isZipped: false, time: 0 };\n        this.cache.set(key, entry);\n\n        if (value.length >= ZIP_THRESHOLD) {\n            value = await Zip.gzip(value);\n            entry.value = value;\n            entry.isZipped = true;\n        }\n        await this.pushAppend(entry);\n    }\n\n    public async remove(key: string): Promise<void> {\n        if (this.init) await this.init;\n        this.cache.delete(key);\n\n        await this.pushAppend({ key, value: undefined, isZipped: false, time: 0 });\n    }\n\n    public async getInfo(key: string): Promise<{ size: number; lastModified: number } | undefined> {\n        await this.init;\n        const value = this.cache.get(key);\n        if (!value?.value) return undefined;\n        return { size: value.value.length, lastModified: value.time };\n    }\n\n    private pendingAppends: TransactionEntry[] = [];\n    private extraAppends = 0;\n    private pendingWrite: Promise<void> | undefined;\n    async pushAppend(entry: TransactionEntry): Promise<void> {\n        this.entryCount++;\n        this.pendingAppends.push(entry);\n        void this.updatePendingAppends();\n        if (this.pendingWrite) return this.pendingWrite;\n        this.pendingWrite = fileLockSection(async () => {\n            // Delay to allow batching, and deduping\n            await new Promise(resolve => setTimeout(resolve, this.writeDelay));\n            let curAppends = this.pendingAppends;\n            this.pendingAppends = [];\n            this.pendingWrite = undefined;\n            {\n                let appendsDeduped: Map<string, TransactionEntry> = new Map();\n                for (const entry of curAppends) {\n                    appendsDeduped.set(entry.key, entry);\n                }\n                curAppends = Array.from(appendsDeduped.values());\n            }\n            this.extraAppends += curAppends.length;\n            void this.updatePendingAppends();\n            if (curAppends.length === 0) return;\n            try {\n\n                let time = Date.now();\n                for (let entry of curAppends) {\n                    entry.time = time;\n                }\n\n                let newSum = 0;\n                let buffers: Buffer[] = [];\n                for (const entry of curAppends) {\n                    let buffer = this.serializeTransactionEntry(entry);\n                    buffers.push(buffer);\n                    newSum += buffer.length;\n                }\n\n                let newChunks = this.chunkBuffers(buffers);\n                for (let chunk of newChunks) {\n                    let file = this.getChunk(this.currentChunk);\n                    if (!await this.rawStorage.get(file)) {\n                        let { header, headerBuffer } = this.getHeader(false);\n                        await this.rawStorage.set(file, headerBuffer);\n                    }\n                    let content = chunk.buffer;\n                    await this.rawStorage.append(file, content);\n                    this.currentChunkSize += content.length;\n                    if (this.currentChunkSize >= FILE_CHUNK_SIZE) {\n                        this.currentChunk++;\n                        this.currentChunkSize = 0;\n                    }\n                }\n\n                await this.compressTransactionLog();\n            } finally {\n                this.extraAppends -= curAppends.length;\n                void this.updatePendingAppends();\n            }\n        });\n        await this.pendingWrite;\n    }\n\n    private updatePendingAppends = throttleFunction(100, async () => {\n        let appendCount = this.pendingAppends.length + this.extraAppends;\n        let group = `Transaction (${this.debugName})`;\n        //console.log(`Update pending appends ${group}: ${appendCount}`);\n        if (!appendCount) {\n            setPending(group, \"\");\n            return;\n        }\n        setPending(group, `Pending appends: ${appendCount}`);\n    });\n\n    public async getKeys(): Promise<string[]> {\n        if (this.init) await this.init;\n        return Array.from(this.cache.keys());\n    }\n\n\n    private async loadAllTransactions(): Promise<void> {\n        if (isInBuild()) return;\n        let time = Date.now();\n        const keys = await this.rawStorage.getKeys();\n        const transactionFiles = keys.filter(key => key.endsWith(CHUNK_EXT));\n\n        sort(transactionFiles, x => parseInt(x));\n\n        let size = 0;\n        for (const file of transactionFiles) {\n            let chunk = parseInt(file);\n            let curSize = await this.loadTransactionFile(file);\n            if (chunk >= this.currentChunk) {\n                this.currentChunk = chunk;\n                this.currentChunkSize = curSize;\n            }\n            size += curSize;\n        }\n        time = Date.now() - time;\n        if (time > 50) {\n            console.log(`Loaded ${this.debugName} in ${formatTime(time)}, ${formatNumber(this.cache.size)} keys, ${formatNumber(size)}B`);\n        }\n\n        this.init = undefined;\n    }\n\n    private async loadTransactionFile(filename: string): Promise<number> {\n        const fullFile = await this.rawStorage.get(filename);\n        if (!fullFile) return 0;\n        if (fullFile.length < 4) {\n            //console.error(`Transaction in ${this.debugName} file ${filename} is too small, skipping`);\n            return 0;\n        }\n        let headerSize = fullFile.readUInt32LE(0);\n        let headerBuffer = fullFile.slice(4, 4 + headerSize);\n        let header: TransactionHeader;\n        try {\n            header = JSON.parse(headerBuffer.toString());\n        } catch (e) {\n            console.error(`Failed to parse header of transaction file in ${this.debugName}, ${filename}`);\n            return 0;\n        }\n        let content = fullFile.slice(4 + headerSize);\n        if (header.zipped) {\n            content = await Zip.gunzip(content);\n        }\n\n        let offset = 0;\n        let entries: TransactionEntry[] = [];\n        while (offset < content.length) {\n            if (!content.slice(offset, offset + START_BYTES.length).equals(START_BYTES)) {\n                let s = offset;\n                while (offset < content.length && !content.slice(offset, offset + START_BYTES.length).equals(START_BYTES)) {\n                    offset++;\n                }\n                let len = offset - s;\n                console.warn(`Found bad bytes in ${filename}, skipping ${len} bytes at offset ${s}. Total file bytes ${content.length}, read ${entries.length} entries`);\n                if (offset >= content.length) break;\n            }\n            let entryObj: { entry: TransactionEntry, offset: number } | undefined;\n            try {\n                entryObj = this.readTransactionEntry(content, offset);\n            } catch (e: any) {\n                if (e.message.includes(\"Read past end of buffer\")) {\n                    offset += 1;\n                    continue;\n                }\n                throw e;\n            }\n            if (!entryObj) {\n                console.warn(`Failed to read transaction entry in in ${this.debugName}, file ${filename} at offset ${offset}, skipping bad bytes, reading remainder of file`);\n                offset++;\n                continue;\n            }\n            this.entryCount++;\n            let { entry } = entryObj;\n            offset = entryObj.offset;\n            entries.push(entry);\n\n            if (entry.value === undefined) {\n                this.cache.delete(entry.key);\n            } else {\n                let prev = this.cache.get(entry.key);\n                if (prev && (prev.time > entry.time)) {\n                    continue;\n                }\n                this.cache.set(entry.key, entry);\n            }\n        }\n        return fullFile.length;\n    }\n\n    private readTransactionEntry(buffer: Buffer, offset: number): {\n        entry: TransactionEntry;\n        offset: number;\n    } | undefined {\n        function readSlice(count: number) {\n            const slice = buffer.slice(offset, offset + count);\n            if (slice.length < count) throw new Error(`Read past end of buffer at offset ${offset}/${buffer.length}`);\n            offset += count;\n            return slice;\n        }\n        if (!readSlice(START_BYTES.length).equals(START_BYTES)) return undefined;\n\n        const keyLength = readSlice(4).readUInt32LE(0);\n        const valueLength = readSlice(4).readUInt32LE(0);\n        const time = readSlice(8).readDoubleLE(0);\n        const flags = readSlice(1).readUInt8(0);\n\n        const key = readSlice(keyLength).toString();\n        let value = readSlice(valueLength);\n\n        if (!readSlice(END_BYTES.length).equals(END_BYTES)) return undefined;\n\n        let isZipped = (flags & 1) === 1;\n        let isDelete = (flags & 2) === 2;\n\n        let entry: TransactionEntry = { key, value, isZipped, time };\n        if (isDelete) {\n            entry.value = undefined;\n        }\n        return { entry, offset };\n    }\n\n    // TODO: Make this directly go from TransactionEntry[] to Buffer, by pre-allocating, so it is more efficient\n    private serializeTransactionEntry(entry: TransactionEntry): Buffer {\n        let keyBuffer = Buffer.from(entry.key);\n        const buffer = Buffer.alloc(\n            START_BYTES.length + 4 + 4 + 8 + 1 + keyBuffer.length + (entry.value?.length || 0) + END_BYTES.length\n        );\n        let offset = 0;\n\n        START_BYTES.copy(buffer, offset);\n        offset += START_BYTES.length;\n\n        buffer.writeUInt32LE(keyBuffer.length, offset);\n        offset += 4;\n\n        buffer.writeUInt32LE(entry.value ? entry.value.length : 0, offset);\n        offset += 4;\n\n        buffer.writeDoubleLE(entry.time, offset);\n        offset += 8;\n\n        let flags = 0;\n        if (entry.isZipped) flags |= 1;\n        if (entry.value === undefined) flags |= 2;\n        buffer.writeUInt8(flags, offset);\n        offset += 1;\n\n        keyBuffer.copy(buffer, offset);\n        offset += keyBuffer.length;\n\n        if (entry.value) {\n            entry.value.copy(buffer, offset);\n            offset += entry.value.length;\n        }\n\n        END_BYTES.copy(buffer, offset);\n        offset += END_BYTES.length;\n\n        return buffer;\n    }\n\n    private getHeader(zip: boolean) {\n        const header: TransactionHeader = { zipped: zip };\n        let headerBuffer = Buffer.from(JSON.stringify(header));\n        let headerSize = Buffer.alloc(4);\n        headerSize.writeUInt32LE(headerBuffer.length, 0);\n        return { header, headerBuffer: Buffer.concat([headerSize, headerBuffer]) };\n    }\n\n    private chunkBuffers(buffers: Buffer[]) {\n        let newChunks: {\n            buffers: Buffer[];\n            size: number;\n        }[] = [];\n        newChunks.push({ buffers: [], size: 0 });\n        for (const buffer of buffers) {\n            if (newChunks[newChunks.length - 1].size + buffer.length >= FILE_CHUNK_SIZE) {\n                newChunks.push({ buffers: [], size: 0 });\n            }\n            newChunks[newChunks.length - 1].buffers.push(buffer);\n            newChunks[newChunks.length - 1].size += buffer.length;\n        }\n        return newChunks.map(x => ({ buffer: Buffer.concat(x.buffers), size: x.size }));\n    }\n\n\n    private compressing = false;\n    private async compressTransactionLog(force?: boolean): Promise<void> {\n        if (this.compressing) return;\n        this.compressing = true;\n\n        let existingDiskEntries = await this.rawStorage.getKeys();\n        existingDiskEntries = existingDiskEntries.filter(x => x.endsWith(CHUNK_EXT));\n        let compressNow = force || (\n            this.entryCount > 100 && this.entryCount > this.cache.size * 3\n            // NOTE: This compress check breaks down if we only have very large values, but... those\n            //  don't work ANYWAYS (it is better to use one file per value instead).\n            //  - Maybe we should throw, or at least warn, on sets of value > 1MB,\n            //      at which point they should just use a file per value\n            || existingDiskEntries.length > Math.max(10, Math.ceil(this.entryCount / 1000))\n            || existingDiskEntries.length > 1000 * 10\n        );\n        if (!compressNow) return;\n        console.log(`Compressing ${this.debugName} transaction log, ${this.entryCount} entries, ${this.cache.size} keys`);\n\n        // Load off disk, in case there are other writes. We still race with them, but at least\n        //  this reduces the race condition considerably\n\n        sort(existingDiskEntries, x => parseInt(x));\n        for (let entry of existingDiskEntries) {\n            await this.loadTransactionFile(entry);\n        }\n\n        this.entryCount = this.cache.size;\n\n        let nextStart = Math.max(...existingDiskEntries.map(x => parseInt(x))) + 1;\n\n        let buffers: Buffer[] = [];\n        for (const entry of this.cache.values()) {\n            let buffer = this.serializeTransactionEntry(entry);\n            buffers.push(buffer);\n        }\n\n        let newChunks = this.chunkBuffers(buffers);\n\n        let curChunk = nextStart;\n        for (let chunk of newChunks) {\n            let file = this.getChunk(curChunk++);\n            let content = chunk.buffer;\n            let { header, headerBuffer } = this.getHeader(\n                // AND, never compress the last one, otherwise we can't append to it!\n                content.length >= FILE_ZIP_THRESHOLD && chunk !== newChunks[newChunks.length - 1]\n            );\n            if (header.zipped) {\n                content = await Zip.gzip(content);\n            }\n            let buffer = Buffer.concat([headerBuffer, content]);\n            await this.rawStorage.set(file, buffer);\n        }\n\n        // This is the ONLY time we can delete old files, as we know for sure the new file has all of our data.\n        //  Any future readers won't know this, unless they write it themselves (or unless they audit it against\n        //      the other generations, which is annoying).\n        for (const file of existingDiskEntries) {\n            await this.rawStorage.remove(file);\n        }\n\n        this.currentChunk = curChunk;\n    }\n\n    public async reset() {\n        await fileLockSection(async () => {\n            let existingDiskEntries = await this.rawStorage.getKeys();\n            existingDiskEntries = existingDiskEntries.filter(x => x.endsWith(CHUNK_EXT));\n\n            try {\n                await Promise.allSettled(existingDiskEntries.map(x => this.rawStorage.remove(x)));\n            } catch { }\n\n            this.pendingAppends = [];\n            this.cache.clear();\n            this.currentChunk = 0;\n            this.currentChunkSize = 0;\n            this.entryCount = 0;\n        });\n    }\n}"]}
+ /* _JS_SOURCE_HASH = "d6b565522e0199b1511007a3ea7bb1eef1a46c338996c583da6090466f49bf59"; */

package/storage/dist/fileSystemPointer.ts.cache

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.getFileSystemPointer = exports.deleteFileSystemPointer = exports.storeFileSystemPointer = void 0;
+const caching_1 = require("socket-function/src/caching");
+const misc_1 = require("socket-function/src/misc");
+const objectStoreName = "fileSystemPointerDB";
+const db = (0, caching_1.lazy)(async () => {
+    let db = indexedDB.open("fileSystemPointerDB_f298e962-bd8a-46b9-8098-25db633f4ed3", 1);
+    db.addEventListener("upgradeneeded", () => {
+        db.result.createObjectStore(objectStoreName, {});
+    });
+    await new Promise(resolve => db.addEventListener("success", resolve));
+    return db.result;
+});
+async function getTransaction() {
+    let database = await db();
+    if (!database)
+        return undefined;
+    return database.transaction(objectStoreName, "readwrite").objectStore(objectStoreName);
+}
+async function write(key, value) {
+    let transaction = await getTransaction();
+    if (!transaction)
+        return;
+    let req = transaction.put(value, key);
+    await new Promise((resolve, reject) => {
+        req.addEventListener("success", resolve);
+        req.addEventListener("error", reject);
+    });
+}
+async function read(key) {
+    let transaction = await getTransaction();
+    if (!transaction)
+        return;
+    let req = transaction.get(key);
+    await new Promise((resolve, reject) => {
+        req.addEventListener("success", resolve);
+        req.addEventListener("error", reject);
+    });
+    return req.result;
+}
+async function storeFileSystemPointer(config) {
+    await config.handle.requestPermission({ mode: config.mode });
+    let key = (0, misc_1.nextId)() + "_" + config.mode;
+    await write(key, config.handle);
+    return key;
+}
+exports.storeFileSystemPointer = storeFileSystemPointer;
+async function deleteFileSystemPointer(pointer) {
+    let transaction = await getTransaction();
+    if (!transaction)
+        return;
+    let req = transaction.delete(pointer);
+    await new Promise((resolve, reject) => {
+        req.addEventListener("success", resolve);
+        req.addEventListener("error", reject);
+    });
+}
+exports.deleteFileSystemPointer = deleteFileSystemPointer;
+async function getFileSystemPointer(config) {
+    const handle = await read(config.pointer);
+    if (!handle)
+        return;
+    let mode = config.pointer.split("_").at(-1);
+    return {
+        async onUserActivation(modeOverride) {
+            let testMode = await handle.queryPermission({ mode: mode });
+            if (testMode !== mode) {
+                await handle.requestPermission({ mode: modeOverride !== null && modeOverride !== void 0 ? modeOverride : mode });
+            }
+            return handle;
+        }
+    };
+}
+exports.getFileSystemPointer = getFileSystemPointer;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fileSystemPointer.js","sourceRoot":"","sources":["fileSystemPointer.ts"],"names":[],"mappings":"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","sourcesContent":["import { lazy } from \"socket-function/src/caching\";\nimport { nextId } from \"socket-function/src/misc\";\n\nconst objectStoreName = \"fileSystemPointerDB\";\nconst db = lazy(async () => {\n    let db = indexedDB.open(\"fileSystemPointerDB_f298e962-bd8a-46b9-8098-25db633f4ed3\", 1);\n    db.addEventListener(\"upgradeneeded\", () => {\n        db.result.createObjectStore(objectStoreName, {});\n    });\n    await new Promise(resolve => db.addEventListener(\"success\", resolve));\n    return db.result;\n});\nasync function getTransaction() {\n    let database = await db();\n    if (!database) return undefined;\n    return database.transaction(objectStoreName, \"readwrite\").objectStore(objectStoreName);\n}\nasync function write(key: string, value: FileSystemFileHandle | FileSystemDirectoryHandle) {\n    let transaction = await getTransaction();\n    if (!transaction) return;\n    let req = transaction.put(value, key);\n    await new Promise((resolve, reject) => {\n        req.addEventListener(\"success\", resolve);\n        req.addEventListener(\"error\", reject);\n    });\n}\nasync function read(key: string): Promise<FileSystemFileHandle | FileSystemDirectoryHandle | undefined> {\n    let transaction = await getTransaction();\n    if (!transaction) return;\n    let req = transaction.get(key);\n    await new Promise((resolve, reject) => {\n        req.addEventListener(\"success\", resolve);\n        req.addEventListener(\"error\", reject);\n    });\n    return req.result;\n}\n\nexport type FileSystemPointer = string;\nexport async function storeFileSystemPointer(config: {\n    mode: \"read\" | \"readwrite\";\n    handle: FileSystemFileHandle | FileSystemDirectoryHandle;\n}): Promise<FileSystemPointer> {\n    await (config.handle as any).requestPermission({ mode: config.mode });\n    let key = nextId() + \"_\" + config.mode;\n    await write(key, config.handle);\n    return key;\n}\nexport async function deleteFileSystemPointer(pointer: FileSystemPointer) {\n    let transaction = await getTransaction();\n    if (!transaction) return;\n    let req = transaction.delete(pointer);\n    await new Promise((resolve, reject) => {\n        req.addEventListener(\"success\", resolve);\n        req.addEventListener(\"error\", reject);\n    });\n}\n\nexport async function getFileSystemPointer(config: {\n    pointer: FileSystemPointer;\n}): Promise<{\n    // NOTE: We have to call requestPermission, so... user activation is required (as in,\n    //  this need to be called inside of a button).\n    // IMPORTANT! In some circumstances user activation is not required (with multiple tabs,\n    //      and potentially with https://developer.chrome.com/blog/persistent-permissions-for-the-file-system-access-api),\n    //      so... trying to call onUserActivation immmediately is a good idea (although it might throw).\n    onUserActivation(modeOverride?: \"read\" | \"readwrite\"): Promise<FileSystemFileHandle | FileSystemDirectoryHandle>\n} | undefined\n> {\n    const handle = await read(config.pointer);\n    if (!handle) return;\n    let mode = config.pointer.split(\"_\").at(-1);\n    return {\n        async onUserActivation(modeOverride) {\n            let testMode = await (handle as any).queryPermission({ mode: mode });\n            if (testMode !== mode) {\n                await (handle as any).requestPermission({ mode: modeOverride ?? mode });\n            }\n            return handle;\n        }\n    };\n}"]}
+ /* _JS_SOURCE_HASH = "48ea788e6857a9aab2e957d5ebef940a9cec94997aaf61e8855616fc40d95197"; */

package/storage/fileSystemPointer.d.ts

@@ -0,0 +1,11 @@
+export type FileSystemPointer = string;
+export declare function storeFileSystemPointer(config: {
+    mode: "read" | "readwrite";
+    handle: FileSystemFileHandle | FileSystemDirectoryHandle;
+}): Promise<FileSystemPointer>;
+export declare function deleteFileSystemPointer(pointer: FileSystemPointer): Promise<void>;
+export declare function getFileSystemPointer(config: {
+    pointer: FileSystemPointer;
+}): Promise<{
+    onUserActivation(modeOverride?: "read" | "readwrite"): Promise<FileSystemFileHandle | FileSystemDirectoryHandle>;
+} | undefined>;

package/tsconfig.declarations.json

@@ -10,7 +10,9 @@
         "render-utils/**/*.ts",
         "render-utils/**/*.tsx",
         "misc/**/*.ts",
-        "misc/**/*.tsx"
+        "misc/**/*.tsx",
+        "storage/**/*.ts",
+        "storage/**/*.tsx"
     ],
     "exclude": [
         "node_modules",