Files
lolympus-tournament-support/apps/api/src/modules/riot-job-queue/riot-job-worker.service.ts
T

276 lines
8.2 KiB
TypeScript

import {
Injectable,
Logger,
OnModuleDestroy,
OnModuleInit,
} from '@nestjs/common';
import mongoose from 'mongoose';
import { ConnectionService } from '../global/database/connection.service';
import { GarnetService, StreamEntry } from '../global/garnet/garnet.service';
import { LegacyImportService } from '../legacy-import/legacy-import.service';
import type { LegacyImportMemberJob } from '../legacy-import/legacy-import.types';
import { RiotAccountEnrichmentService } from '../riot/riot-account-enrichment.service';
import { RiotRecentMatchesService } from '../riot/riot-recent-matches.service';
import { TournamentResultService } from '../tournament-result/tournament-result.service';
import type { PollTournamentResultJob } from '../tournament-result/tournament-result.types';
import {
RIOT_JOB_GROUP,
RIOT_JOB_HIGH_STREAM,
RIOT_JOB_LOW_STREAM,
RiotJobPayload,
RiotRefreshSubJob,
} from './riot-job-queue.types';
import { RiotJobQueueService } from './riot-job-queue.service';
import { RiotRefreshGateway } from './riot-refresh.gateway';
const LEADER_KEY = 'riot:worker:leader';
const LEADER_TTL_SECONDS = 60;
@Injectable()
export class RiotJobWorkerService implements OnModuleInit, OnModuleDestroy {
private readonly logger = new Logger(RiotJobWorkerService.name);
private readonly consumer = `${process.pid}:${Math.random().toString(36).slice(2)}`;
private stopped = false;
constructor(
private readonly garnetService: GarnetService,
private readonly jobQueueService: RiotJobQueueService,
private readonly recentMatchesService: RiotRecentMatchesService,
private readonly connectionService: ConnectionService,
private readonly refreshGateway: RiotRefreshGateway,
private readonly tournamentResultService: TournamentResultService,
private readonly legacyImportService: LegacyImportService,
private readonly enrichmentService: RiotAccountEnrichmentService,
) {}
public async onModuleInit() {
await this.ensureConsumerGroups();
void this.loop();
}
public onModuleDestroy() {
this.stopped = true;
}
private async loop(): Promise<void> {
while (!this.stopped) {
try {
const isLeader = await this.tryBecomeLeader();
if (!isLeader) {
await this.sleep(1_000);
continue;
}
await this.jobQueueService.promoteDueScheduledJobs();
const entry =
(await this.readOne(RIOT_JOB_HIGH_STREAM, 100)) ??
(await this.readOne(RIOT_JOB_LOW_STREAM, 1_000));
if (!entry) continue;
await this.processEntry(entry.stream, entry.message);
} catch (error) {
this.logger.warn(
`Riot job worker loop failed: ${
error instanceof Error ? error.message : error
}`,
);
await this.sleep(1_000);
}
}
}
private async processEntry(
stream: string,
entry: StreamEntry,
): Promise<void> {
const job = this.parseJob(entry);
if (!job) {
await this.acknowledgeAndDelete(stream, entry.id);
return;
}
try {
if (this.isTournamentResultJob(job)) {
await this.tournamentResultService.processPollJob(job);
return;
}
if (this.isLegacyImportJob(job)) {
await this.legacyImportService.processMemberJob(job);
return;
}
await this.jobQueueService.markProcessing(job);
for (const queueId of job.queueIds) {
await this.recentMatchesService.ensureFreshForQueue({
puuid: job.puuid,
region: job.region,
queueId,
});
}
await this.refreshLeagueEntries(job);
await this.markUserFetchedAt(job);
const event = await this.jobQueueService.markCompleted(job);
this.refreshGateway.broadcastRefreshEvent(event);
} catch (error) {
if (this.isTournamentResultJob(job)) {
this.logger.warn(
`Tournament result poll job failed ${job.jobId}: ${
error instanceof Error ? error.message : error
}`,
);
return;
}
if (this.isLegacyImportJob(job)) {
this.logger.warn(
`Legacy import member job failed ${job.jobId}: ${
error instanceof Error ? error.message : error
}`,
);
return;
}
const event = await this.jobQueueService.markFailed(job, error);
this.refreshGateway.broadcastRefreshEvent(event);
this.logger.warn(
`Riot refresh job failed ${job.jobId}: ${
error instanceof Error ? error.message : error
}`,
);
} finally {
await this.acknowledgeAndDelete(stream, entry.id);
}
}
private async acknowledgeAndDelete(
stream: string,
id: string,
): Promise<void> {
await this.garnetService.acknowledgeStream(stream, RIOT_JOB_GROUP, id);
await this.deleteAcknowledgedEntry(stream, id);
}
private async deleteAcknowledgedEntry(
stream: string,
id: string,
): Promise<void> {
try {
await this.garnetService.deleteStreamEntries(stream, id);
} catch (error) {
this.logger.warn(
`Failed to delete acknowledged Riot job stream entry ${stream} ${id}: ${
error instanceof Error ? error.message : error
}`,
);
}
}
private async refreshLeagueEntries(job: RiotRefreshSubJob): Promise<void> {
try {
const result = await this.enrichmentService.refreshLeagueEntries({
userId: new mongoose.Types.ObjectId(job.userId),
puuid: job.puuid,
platform: job.platform,
});
if (result !== 'failed') return;
this.logger.warn(
`Riot league refresh failed ${job.jobId}: puuid=${job.puuid}`,
);
} catch (error) {
this.logger.warn(
`Riot league refresh failed ${job.jobId}: ${
error instanceof Error ? error.message : error
}`,
);
}
}
private async markUserFetchedAt(job: RiotRefreshSubJob): Promise<void> {
const UserModel = await this.connectionService.getModel('user');
const now = new Date();
const $set: Record<string, Date> = {
'riotAccounts.$.matchIdsFetchedAt': now,
};
for (const queueId of job.queueIds) {
$set[`riotAccounts.$.matchIdsByQueueFetchedAt.${queueId}`] = now;
}
await UserModel.updateOne(
{
_id: new mongoose.Types.ObjectId(job.userId),
'riotAccounts.puuid': job.puuid,
},
{ $set },
).exec();
}
private parseJob(entry: StreamEntry): RiotJobPayload | null {
const raw = entry.message.job;
if (!raw) return null;
try {
return JSON.parse(raw) as RiotJobPayload;
} catch {
return null;
}
}
private isTournamentResultJob(
job: RiotJobPayload,
): job is PollTournamentResultJob {
return job.kind === 'poll-tournament-result';
}
private isLegacyImportJob(job: RiotJobPayload): job is LegacyImportMemberJob {
return job.kind === 'legacy-import-member';
}
private async readOne(
stream: string,
blockMs: number,
): Promise<{ stream: string; message: StreamEntry } | null> {
const result = await this.garnetService.readGroup(
stream,
RIOT_JOB_GROUP,
this.consumer,
'>',
{ count: 1, blockMs },
);
const message = result?.[0]?.messages[0];
return message ? { stream, message } : null;
}
private async ensureConsumerGroups(): Promise<void> {
await Promise.all(
[RIOT_JOB_HIGH_STREAM, RIOT_JOB_LOW_STREAM].map(async (stream) => {
try {
await this.garnetService.createConsumerGroup(stream, RIOT_JOB_GROUP);
} catch (error) {
const message =
error instanceof Error ? error.message : String(error);
if (!message.includes('BUSYGROUP')) throw error;
}
}),
);
}
private async tryBecomeLeader(): Promise<boolean> {
const current = await this.garnetService.getString(LEADER_KEY);
if (current === this.consumer) {
await this.garnetService.setString(
LEADER_KEY,
this.consumer,
LEADER_TTL_SECONDS,
);
return true;
}
if (current) return false;
return this.garnetService.setStringIfAbsent(
LEADER_KEY,
this.consumer,
LEADER_TTL_SECONDS,
);
}
private sleep(ms: number): Promise<void> {
return new Promise((resolve) => setTimeout(resolve, ms));
}
}