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

a20c8978f9d7e8e0117bc383a73845cbbc82fe90

Cohee <18619528+Cohee1207@users.noreply.github.com>

Parents: 50340103dea13e19a42ba6d3a11a0431b0a7d226

src/endpoints/characters.js+41 -54 Viewed

 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 {
     /**
      * @typedeftype {objectstring} CacheRemovalQueueItem
 -     * @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} */
     #removalIntervalsyncInterval;
     /**
      * Queue forof removaluser ofhandles cacheto entriessync.
      * @type {CacheRemovalQueueItem[]Set<string>}
 +     * @readonly
      */
     removalQueuesyncQueue = []new Set();
     /**
      * Path to the cache directory.

+    }
     /**
      * Processes the removalsynchronization queue.
      * @returns {Promise<void>}
      */
     async #removeCacheEntriessyncCacheEntries() {
 -        // 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.removalQueuesyncQueue.lengthsize === 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 removingsynchronizing cache entries:', error);
+        }
+    }

         this.#instance = storage.create({ dir: this.cachePath, ttl: false });
         await this.#instance.init();
         this.#removalIntervalsyncInterval = setInterval(this.#removeCacheEntriessyncCacheEntries.bind(this), DiskCache.REMOVAL_INTERVALSYNC_INTERVAL);
         return this.#instance;
+    }

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

@@ -163,8 +137,8 @@ class DiskCache {
163	137	}
164	138
165	139	dispose() {
166	140	if (this.#removalIntervalsyncInterval) {
167	141	clearInterval(this.#removalIntervalsyncInterval);
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 statcacheKey = fs.statSyncgetCacheKey(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	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	213	* Read the image, resize, and save it as a PNG into the buffer.