a20c8978 · permissionBRICK/SillyTavern

 import { readWorldInfoFile } from './worldinfo.js';
 import { invalidateThumbnail } from './thumbnails.js';
 import { importRisuSprites } from './sprites.js';
+import { getUserDirectories } from '../users.js';
 const defaultAvatarPath = './public/img/ai4.png';
 // With 100 MB limit it would take roughly 3000 characters to reach this limit

 class DiskCache {
     /**
-     * @typedef {object} CacheRemovalQueueItem
+     * @type {string}
-     * @property {string} item Path to the character file
+     * @readonly
-     * @property {number} timestamp Timestamp of the last access
      */
-    /** @type {string} */
     static DIRECTORY = 'characters';
-    /** @type {number} */
+    /**
-    static REMOVAL_INTERVAL = 5 * 60 * 1000;
+     * @type {number}
+     * @readonly
+     */
+    static SYNC_INTERVAL = 5 * 60 * 1000;
     /** @type {import('node-persist').LocalStorage} */
     #instance;
     /** @type {NodeJS.Timeout} */
-    #removalInterval;
+    #syncInterval;
     /**
-     * Queue for removal of cache entries.
+     * Queue of user handles to sync.
-     * @type {CacheRemovalQueueItem[]}
+     * @type {Set<string>}
+     * @readonly
      */
-    removalQueue = [];
+    syncQueue = new Set();
     /**
      * Path to the cache directory.

+    }
     /**
-     * Processes the removal queue.
+     * Processes the synchronization queue.
      * @returns {Promise<void>}
      */
-    async #removeCacheEntries() {
+    async #syncCacheEntries() {
-        // TODO: consider running this.verify() for a user instead as getting all cache keys
-        // is a heavy operation, since it requires to read all files in the disk cache.
         try {
-            if (!useDiskCache || this.removalQueue.length === 0) {
+            if (!useDiskCache || this.syncQueue.size === 0) {
                 return;
+            }
-            /** @type {Map<string, number>} */
+            const directories = [...this.syncQueue].map(entry => getUserDirectories(entry));
-            const latestTimestamps = new Map();
+            this.syncQueue.clear();
-            for (const { item, timestamp } of this.removalQueue) {
-                if (!latestTimestamps.has(item) || timestamp > (latestTimestamps.get(item) ?? 0)) {
-                    latestTimestamps.set(item, timestamp);
-                }
-            }
-            this.removalQueue.length = 0;
-            const cache = await this.instance();
-            const keys = await cache.keys();
-            for (const [item, timestamp] of latestTimestamps.entries()) {
+            await this.verify(directories);
-                const itemKeys = keys.filter(k => k.startsWith(item));
-                if (!itemKeys.length) {
-                    continue;
-                }
-                for (const key of itemKeys) {
-                    const datumPath = cache.getDatumPath(key);
-                    if (!fs.existsSync(datumPath)) {
-                        continue;
-                    }
-                    const stat = fs.statSync(datumPath);
-                    if (stat.mtimeMs > timestamp) {
-                        continue;
-                    }
-                    await cache.removeItem(key);
-                }
-            }
         } catch (error) {
-            console.error('Error while removing cache entries:', error);
+            console.error('Error while synchronizing cache entries:', error);
+        }
+    }

         this.#instance = storage.create({ dir: this.cachePath, ttl: false });
         await this.#instance.init();
-        this.#removalInterval = setInterval(this.#removeCacheEntries.bind(this), DiskCache.REMOVAL_INTERVAL);
+        this.#syncInterval = setInterval(this.#syncCacheEntries.bind(this), DiskCache.SYNC_INTERVAL);
         return this.#instance;
+    }

@@ -151,8 +125,8 @@ class DiskCache {
151	const files = fs.readdirSync(dir.characters, { withFileTypes: true });	125	const files = fs.readdirSync(dir.characters, { withFileTypes: true });
152	for (const file of files.filter(f => f.isFile() && path.extname(f.name) === '.png')) {	126	for (const file of files.filter(f => f.isFile() && path.extname(f.name) === '.png')) {
153	const filePath = path.join(dir.characters, file.name);	127	const filePath = path.join(dir.characters, file.name);
154	const stat = fs.statSync(filePath);	128	const cacheKey = getCacheKey(filePath);
155	validKeys.add(path.parse(cache.getDatumPath(`${filePath}-${stat.mtimeMs}`)).base);	129	validKeys.add(path.parse(cache.getDatumPath(cacheKey)).base);
156	}	130	}
157	}	131	}
158	for (const key of this.hashedKeys) {	132	for (const key of this.hashedKeys) {

@@ -163,8 +137,8 @@ class DiskCache {
163	}	137	}
164		138
165	dispose() {	139	dispose() {
166	if (this.#removalInterval) {	140	if (this.#syncInterval) {
167	clearInterval(this.#removalInterval);	141	clearInterval(this.#syncInterval);
168	}	142	}
169	}	143	}
170	}	144	}

 export const diskCache = new DiskCache();
 /**
+ * Gets the cache key for the specified image file.
+ * @param {string} inputFile - Path to the image file
+ * @returns {string} - Cache key
+ */
+function getCacheKey(inputFile) {
+    if (fs.existsSync(inputFile)) {
+        const stat = fs.statSync(inputFile);
+        return `${inputFile}-${stat.mtimeMs}`;
+    }
+    return inputFile;
+}
+/**
  * Reads the character card from the specified image file.
  * @param {string} inputFile - Path to the image file
  * @param {string} inputFormat - 'png'
  * @returns {Promise<string | undefined>} - Character card data
  */
 async function readCharacterData(inputFile, inputFormat = 'png') {
-    const stat = fs.statSync(inputFile);
+    const cacheKey = getCacheKey(inputFile);
-    const cacheKey = `${inputFile}-${stat.mtimeMs}`;
     if (memoryCache.has(cacheKey)) {
         return memoryCache.get(cacheKey);
+    }

@@ -220,7 +207,7 @@ async function writeCharacterData(inputFile, data, outputFile, request, crop = u
220	}	207	}
221	}	208	}
222	if (useDiskCache && !Buffer.isBuffer(inputFile)) {	209	if (useDiskCache && !Buffer.isBuffer(inputFile)) {
223	diskCache.removalQueue.push({ item: inputFile, timestamp: Date.now() });	210	diskCache.syncQueue.add(request.user.profile.handle);
224	}	211	}
225	/**	212	/**
226	* Read the image, resize, and save it as a PNG into the buffer.	213	* Read the image, resize, and save it as a PNG into the buffer.

Refactor DiskCache to use a synchronization queue and update cache key generation