Sharkey/packages/backend/src/core/FederatedInstanceService.ts

91 lines
2.7 KiB
TypeScript
Raw Normal View History

import { Inject, Injectable, OnApplicationShutdown } from '@nestjs/common';
2023-04-14 07:50:05 +03:00
import * as Redis from 'ioredis';
2022-09-20 23:33:11 +03:00
import type { InstancesRepository } from '@/models/index.js';
2022-09-17 21:27:08 +03:00
import type { Instance } from '@/models/entities/Instance.js';
import { MemoryKVCache, RedisKVCache } from '@/misc/cache.js';
2022-09-17 21:27:08 +03:00
import { IdService } from '@/core/IdService.js';
import { DI } from '@/di-symbols.js';
2022-12-04 03:16:03 +02:00
import { UtilityService } from '@/core/UtilityService.js';
import { bindThis } from '@/decorators.js';
2022-09-17 21:27:08 +03:00
@Injectable()
export class FederatedInstanceService implements OnApplicationShutdown {
public federatedInstanceCache: RedisKVCache<Instance | null>;
2022-09-17 21:27:08 +03:00
constructor(
@Inject(DI.redis)
private redisClient: Redis.Redis,
2022-09-17 21:27:08 +03:00
@Inject(DI.instancesRepository)
private instancesRepository: InstancesRepository,
private utilityService: UtilityService,
private idService: IdService,
) {
this.federatedInstanceCache = new RedisKVCache<Instance | null>(this.redisClient, 'federatedInstance', {
lifetime: 1000 * 60 * 30, // 30m
memoryCacheLifetime: 1000 * 60 * 3, // 3m
fetcher: (key) => this.instancesRepository.findOneBy({ host: key }),
toRedisConverter: (value) => JSON.stringify(value),
fromRedisConverter: (value) => {
const parsed = JSON.parse(value);
if (parsed == null) return null;
return {
...parsed,
firstRetrievedAt: new Date(parsed.firstRetrievedAt),
latestRequestReceivedAt: parsed.latestRequestReceivedAt ? new Date(parsed.latestRequestReceivedAt) : null,
infoUpdatedAt: parsed.infoUpdatedAt ? new Date(parsed.infoUpdatedAt) : null,
};
},
});
2022-09-17 21:27:08 +03:00
}
@bindThis
2023-01-03 02:32:36 +02:00
public async fetch(host: string): Promise<Instance> {
2022-09-17 21:27:08 +03:00
host = this.utilityService.toPuny(host);
const cached = await this.federatedInstanceCache.get(host);
2022-09-17 21:27:08 +03:00
if (cached) return cached;
2022-09-17 21:27:08 +03:00
const index = await this.instancesRepository.findOneBy({ host });
2022-09-17 21:27:08 +03:00
if (index == null) {
const i = await this.instancesRepository.insert({
id: this.idService.genId(),
host,
firstRetrievedAt: new Date(),
2022-09-17 21:27:08 +03:00
}).then(x => this.instancesRepository.findOneByOrFail(x.identifiers[0]));
this.federatedInstanceCache.set(host, i);
2022-09-17 21:27:08 +03:00
return i;
} else {
this.federatedInstanceCache.set(host, index);
2022-09-17 21:27:08 +03:00
return index;
}
}
2023-01-03 02:32:36 +02:00
@bindThis
public async update(id: Instance['id'], data: Partial<Instance>): Promise<void> {
2023-04-22 14:12:41 +03:00
const result = await this.instancesRepository.createQueryBuilder().update()
.set(data)
.where('id = :id', { id })
.returning('*')
.execute()
.then((response) => {
return response.raw[0];
});
this.federatedInstanceCache.set(result.host, result);
2023-01-03 02:32:36 +02:00
}
@bindThis
public dispose(): void {
this.federatedInstanceCache.dispose();
}
@bindThis
public onApplicationShutdown(signal?: string | undefined): void {
this.dispose();
}
2022-09-17 21:27:08 +03:00
}