misskey/packages/backend/src/misc/cache.ts

395 lines
10 KiB
TypeScript
Raw Normal View History

/*
* SPDX-FileCopyrightText: syuilo and other misskey contributors
* SPDX-License-Identifier: AGPL-3.0-only
*/
2023-04-14 04:50:05 +00:00
import * as Redis from 'ioredis';
import { bindThis } from '@/decorators.js';
2023-04-04 08:32:09 +00:00
export class RedisKVCache<T> {
private redisClient: Redis.Redis;
private name: string;
private lifetime: number;
private memoryCache: MemoryKVCache<T>;
2023-04-05 01:21:10 +00:00
private fetcher: (key: string) => Promise<T>;
private toRedisConverter: (value: T) => string;
2023-04-12 08:02:54 +00:00
private fromRedisConverter: (value: string) => T | undefined;
2023-04-04 08:32:09 +00:00
2023-04-05 01:21:10 +00:00
constructor(redisClient: RedisKVCache<T>['redisClient'], name: RedisKVCache<T>['name'], opts: {
lifetime: RedisKVCache<T>['lifetime'];
memoryCacheLifetime: number;
fetcher: RedisKVCache<T>['fetcher'];
toRedisConverter: RedisKVCache<T>['toRedisConverter'];
fromRedisConverter: RedisKVCache<T>['fromRedisConverter'];
}) {
2023-04-04 08:32:09 +00:00
this.redisClient = redisClient;
this.name = name;
2023-04-05 01:21:10 +00:00
this.lifetime = opts.lifetime;
this.memoryCache = new MemoryKVCache(opts.memoryCacheLifetime);
this.fetcher = opts.fetcher;
this.toRedisConverter = opts.toRedisConverter;
this.fromRedisConverter = opts.fromRedisConverter;
2023-04-04 08:32:09 +00:00
}
@bindThis
public async set(key: string, value: T): Promise<void> {
this.memoryCache.set(key, value);
if (this.lifetime === Infinity) {
await this.redisClient.set(
`kvcache:${this.name}:${key}`,
2023-04-05 01:21:10 +00:00
this.toRedisConverter(value),
2023-04-04 08:32:09 +00:00
);
} else {
await this.redisClient.set(
`kvcache:${this.name}:${key}`,
2023-04-05 01:21:10 +00:00
this.toRedisConverter(value),
2023-04-14 04:50:05 +00:00
'EX', Math.round(this.lifetime / 1000),
2023-04-04 08:32:09 +00:00
);
}
}
@bindThis
2023-04-05 01:21:10 +00:00
public async get(key: string): Promise<T | undefined> {
2023-04-04 08:32:09 +00:00
const memoryCached = this.memoryCache.get(key);
if (memoryCached !== undefined) return memoryCached;
const cached = await this.redisClient.get(`kvcache:${this.name}:${key}`);
if (cached == null) return undefined;
2023-04-05 01:21:10 +00:00
return this.fromRedisConverter(cached);
2023-04-04 08:32:09 +00:00
}
@bindThis
public async delete(key: string): Promise<void> {
this.memoryCache.delete(key);
await this.redisClient.del(`kvcache:${this.name}:${key}`);
}
/**
2023-04-05 01:21:10 +00:00
* fetcherを呼び出して結果をキャッシュ&
*/
2023-04-04 08:32:09 +00:00
@bindThis
2023-04-05 01:21:10 +00:00
public async fetch(key: string): Promise<T> {
2023-04-04 08:32:09 +00:00
const cachedValue = await this.get(key);
if (cachedValue !== undefined) {
2023-04-05 01:21:10 +00:00
// Cache HIT
return cachedValue;
2023-04-04 08:32:09 +00:00
}
// Cache MISS
2023-04-05 01:21:10 +00:00
const value = await this.fetcher(key);
2023-04-04 08:32:09 +00:00
this.set(key, value);
return value;
}
2023-04-05 01:21:10 +00:00
@bindThis
public async refresh(key: string) {
const value = await this.fetcher(key);
this.set(key, value);
// TODO: イベント発行して他プロセスのメモリキャッシュも更新できるようにする
}
@bindThis
public gc() {
this.memoryCache.gc();
}
@bindThis
public dispose() {
this.memoryCache.dispose();
}
2023-04-04 08:32:09 +00:00
}
export class RedisSingleCache<T> {
private redisClient: Redis.Redis;
private name: string;
private lifetime: number;
private memoryCache: MemorySingleCache<T>;
private fetcher: () => Promise<T>;
private toRedisConverter: (value: T) => string;
2023-04-12 08:02:54 +00:00
private fromRedisConverter: (value: string) => T | undefined;
constructor(redisClient: RedisSingleCache<T>['redisClient'], name: RedisSingleCache<T>['name'], opts: {
lifetime: RedisSingleCache<T>['lifetime'];
memoryCacheLifetime: number;
fetcher: RedisSingleCache<T>['fetcher'];
toRedisConverter: RedisSingleCache<T>['toRedisConverter'];
fromRedisConverter: RedisSingleCache<T>['fromRedisConverter'];
}) {
this.redisClient = redisClient;
this.name = name;
this.lifetime = opts.lifetime;
this.memoryCache = new MemorySingleCache(opts.memoryCacheLifetime);
this.fetcher = opts.fetcher;
this.toRedisConverter = opts.toRedisConverter;
this.fromRedisConverter = opts.fromRedisConverter;
}
@bindThis
public async set(value: T): Promise<void> {
this.memoryCache.set(value);
if (this.lifetime === Infinity) {
await this.redisClient.set(
`singlecache:${this.name}`,
this.toRedisConverter(value),
);
} else {
await this.redisClient.set(
`singlecache:${this.name}`,
this.toRedisConverter(value),
2023-04-14 04:50:05 +00:00
'EX', Math.round(this.lifetime / 1000),
);
}
}
@bindThis
public async get(): Promise<T | undefined> {
const memoryCached = this.memoryCache.get();
if (memoryCached !== undefined) return memoryCached;
const cached = await this.redisClient.get(`singlecache:${this.name}`);
if (cached == null) return undefined;
return this.fromRedisConverter(cached);
}
@bindThis
public async delete(): Promise<void> {
this.memoryCache.delete();
await this.redisClient.del(`singlecache:${this.name}`);
}
/**
* fetcherを呼び出して結果をキャッシュ&
*/
@bindThis
public async fetch(): Promise<T> {
const cachedValue = await this.get();
if (cachedValue !== undefined) {
// Cache HIT
return cachedValue;
}
// Cache MISS
const value = await this.fetcher();
this.set(value);
return value;
}
@bindThis
public async refresh() {
const value = await this.fetcher();
this.set(value);
// TODO: イベント発行して他プロセスのメモリキャッシュも更新できるようにする
}
}
2023-02-04 03:40:40 +00:00
// TODO: メモリ節約のためあまり参照されないキーを定期的に削除できるようにする?
function nothingToDo<T, V = T>(value: T): V {
return value as unknown as V;
}
export class MemoryKVCache<T, V = T> {
public cache: Map<string, { date: number; value: V; }>;
2021-03-18 01:49:14 +00:00
private lifetime: number;
private gcIntervalHandle: NodeJS.Timeout;
private toMapConverter: (value: T) => V;
private fromMapConverter: (cached: V) => T | undefined;
constructor(lifetime: MemoryKVCache<never>['lifetime'], options: {
toMapConverter: (value: T) => V;
fromMapConverter: (cached: V) => T | undefined;
} = {
toMapConverter: nothingToDo,
fromMapConverter: nothingToDo,
}) {
2021-03-18 01:54:39 +00:00
this.cache = new Map();
2021-03-18 01:49:14 +00:00
this.lifetime = lifetime;
this.toMapConverter = options.toMapConverter;
this.fromMapConverter = options.fromMapConverter;
this.gcIntervalHandle = setInterval(() => {
this.gc();
}, 1000 * 60 * 3);
2021-03-18 01:49:14 +00:00
}
@bindThis
2023-04-04 08:32:09 +00:00
public set(key: string, value: T): void {
2021-03-18 01:49:14 +00:00
this.cache.set(key, {
date: Date.now(),
value: this.toMapConverter(value),
2021-03-18 01:49:14 +00:00
});
}
@bindThis
2023-04-04 08:32:09 +00:00
public get(key: string): T | undefined {
2021-03-18 01:49:14 +00:00
const cached = this.cache.get(key);
if (cached == null) return undefined;
2021-03-18 01:49:14 +00:00
if ((Date.now() - cached.date) > this.lifetime) {
this.cache.delete(key);
return undefined;
2021-03-18 01:49:14 +00:00
}
return this.fromMapConverter(cached.value);
2021-03-18 01:49:14 +00:00
}
@bindThis
public delete(key: string): void {
this.cache.delete(key);
}
2022-03-20 16:22:00 +00:00
/**
* fetcherを呼び出して結果をキャッシュ&
* optional: キャッシュが存在してもvalidatorでfalseを返すとキャッシュ無効扱いにします
* fetcherの引数はcacheに保存されている値があれば渡されます
2022-03-20 16:22:00 +00:00
*/
@bindThis
public async fetch(key: string, fetcher: (value: V | undefined) => Promise<T>, validator?: (cachedValue: T) => boolean): Promise<T> {
const cachedValue = this.get(key);
if (cachedValue !== undefined) {
2022-03-20 16:22:00 +00:00
if (validator) {
if (validator(cachedValue)) {
// Cache HIT
return cachedValue;
}
} else {
// Cache HIT
return cachedValue;
}
}
// Cache MISS
const value = await fetcher(this.cache.get(key)?.value);
this.set(key, value);
return value;
}
/**
* fetcherを呼び出して結果をキャッシュ&
* optional: キャッシュが存在してもvalidatorでfalseを返すとキャッシュ無効扱いにします
* fetcherの引数はcacheに保存されている値があれば渡されます
*/
@bindThis
public async fetchMaybe(key: string, fetcher: (value: V | undefined) => Promise<T | undefined>, validator?: (cachedValue: T) => boolean): Promise<T | undefined> {
const cachedValue = this.get(key);
if (cachedValue !== undefined) {
if (validator) {
if (validator(cachedValue)) {
// Cache HIT
return cachedValue;
}
} else {
// Cache HIT
return cachedValue;
}
}
// Cache MISS
const value = await fetcher(this.cache.get(key)?.value);
if (value !== undefined) {
this.set(key, value);
}
return value;
}
@bindThis
public gc(): void {
const now = Date.now();
for (const [key, { date }] of this.cache.entries()) {
if ((now - date) > this.lifetime) {
this.cache.delete(key);
}
}
}
@bindThis
public dispose(): void {
clearInterval(this.gcIntervalHandle);
}
2021-03-18 01:49:14 +00:00
}
2023-03-24 07:43:42 +00:00
export class MemorySingleCache<T> {
2023-03-24 07:43:42 +00:00
private cachedAt: number | null = null;
private value: T | undefined;
private lifetime: number;
constructor(lifetime: MemorySingleCache<never>['lifetime']) {
2023-03-24 07:43:42 +00:00
this.lifetime = lifetime;
}
@bindThis
public set(value: T): void {
this.cachedAt = Date.now();
this.value = value;
}
@bindThis
public get(): T | undefined {
if (this.cachedAt == null) return undefined;
if ((Date.now() - this.cachedAt) > this.lifetime) {
this.value = undefined;
this.cachedAt = null;
return undefined;
}
return this.value;
}
@bindThis
public delete() {
this.value = undefined;
this.cachedAt = null;
}
/**
* fetcherを呼び出して結果をキャッシュ&
* optional: キャッシュが存在してもvalidatorでfalseを返すとキャッシュ無効扱いにします
*/
@bindThis
public async fetch(fetcher: () => Promise<T>, validator?: (cachedValue: T) => boolean): Promise<T> {
const cachedValue = this.get();
if (cachedValue !== undefined) {
if (validator) {
if (validator(cachedValue)) {
// Cache HIT
return cachedValue;
}
} else {
// Cache HIT
return cachedValue;
}
}
// Cache MISS
const value = await fetcher();
this.set(value);
return value;
}
/**
* fetcherを呼び出して結果をキャッシュ&
* optional: キャッシュが存在してもvalidatorでfalseを返すとキャッシュ無効扱いにします
*/
@bindThis
public async fetchMaybe(fetcher: () => Promise<T | undefined>, validator?: (cachedValue: T) => boolean): Promise<T | undefined> {
const cachedValue = this.get();
if (cachedValue !== undefined) {
if (validator) {
if (validator(cachedValue)) {
// Cache HIT
return cachedValue;
}
} else {
// Cache HIT
return cachedValue;
}
}
// Cache MISS
const value = await fetcher();
if (value !== undefined) {
this.set(value);
}
return value;
}
}