feat: redesign auction engine with redis sot
This commit is contained in:
1 parent
737702d78c
commit
e8bb20d988
75 files changed
+12737
-542
No files matched your search
@@ -0,0 +1,205 @@
|
||||
import { AuctionRedisService } from './redis/auction-redis.service';
|
||||
import { AuctionDeadlineScheduler } from './auction-deadline.scheduler';
|
||||
import { AuctionRedisCommandService } from './redis/auction-redis-command.service';
|
||||
import { AuctionService } from './auction.service';
|
||||
|
||||
function makeScheduler(params: {
|
||||
dueReply?: unknown;
|
||||
leaderLockAcquired?: boolean;
|
||||
expireReply?: unknown;
|
||||
completedState?: unknown;
|
||||
currentRedisTimestampMS?: number;
|
||||
}) {
|
||||
const sendCommand = jest.fn().mockResolvedValue(params.dueReply ?? []);
|
||||
const redis = {
|
||||
acquireTokenLock: jest
|
||||
.fn()
|
||||
.mockResolvedValue(params.leaderLockAcquired ?? true),
|
||||
getCurrentRedisTimestampMS: jest
|
||||
.fn()
|
||||
.mockResolvedValue(params.currentRedisTimestampMS ?? 1000),
|
||||
releaseTokenLock: jest.fn().mockResolvedValue(true),
|
||||
raw: jest.fn().mockReturnValue({ sendCommand }),
|
||||
} as unknown as jest.Mocked<AuctionRedisService>;
|
||||
const redisCommand = {
|
||||
expirePrepare: jest.fn().mockResolvedValue(
|
||||
params.expireReply ?? {
|
||||
auctionStateTransitionId: 'expire-1',
|
||||
bidRoundExpiryDecision: 'passed',
|
||||
currentServerTimestampMS: 1000,
|
||||
ok: true,
|
||||
revision: 2,
|
||||
},
|
||||
),
|
||||
} as unknown as jest.Mocked<AuctionRedisCommandService>;
|
||||
const auctionService = {
|
||||
completePreparedExpiry: jest
|
||||
.fn()
|
||||
.mockResolvedValue(params.completedState ?? { phase: 'passed' }),
|
||||
} as unknown as jest.Mocked<AuctionService>;
|
||||
return {
|
||||
auctionService,
|
||||
redis,
|
||||
redisCommand,
|
||||
scheduler: new AuctionDeadlineScheduler(
|
||||
redis,
|
||||
redisCommand,
|
||||
auctionService,
|
||||
),
|
||||
sendCommand,
|
||||
};
|
||||
}
|
||||
|
||||
describe('AuctionDeadlineScheduler', () => {
|
||||
afterEach(() => {
|
||||
jest.restoreAllMocks();
|
||||
});
|
||||
|
||||
it('starts and clears the deadline tick timer', () => {
|
||||
const setIntervalSpy = jest.spyOn(global, 'setInterval');
|
||||
const clearIntervalSpy = jest.spyOn(global, 'clearInterval');
|
||||
const { scheduler } = makeScheduler({});
|
||||
|
||||
scheduler.onModuleInit();
|
||||
scheduler.onModuleDestroy();
|
||||
|
||||
expect(setIntervalSpy).toHaveBeenCalledWith(expect.any(Function), 1000);
|
||||
expect(clearIntervalSpy).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
it('processes a deadline tick only while holding the Redis leader lock', async () => {
|
||||
const { redis, scheduler } = makeScheduler({});
|
||||
const processDueBidRoundDeadlinesSpy = jest
|
||||
.spyOn(scheduler, 'processDueBidRoundDeadlines')
|
||||
.mockResolvedValue({ completed: 0, prepared: 0, skipped: 0 });
|
||||
|
||||
await (scheduler as unknown as { safeTick: () => Promise<void> }).safeTick();
|
||||
|
||||
const leaderLockToken = redis.acquireTokenLock.mock.calls[0]?.[1];
|
||||
expect(redis.acquireTokenLock).toHaveBeenCalledWith(
|
||||
'auction:bidRoundDeadlineScheduler:leader',
|
||||
expect.any(String),
|
||||
2500,
|
||||
);
|
||||
expect(processDueBidRoundDeadlinesSpy).toHaveBeenCalledWith(20);
|
||||
expect(redis.releaseTokenLock).toHaveBeenCalledWith(
|
||||
'auction:bidRoundDeadlineScheduler:leader',
|
||||
leaderLockToken,
|
||||
);
|
||||
});
|
||||
|
||||
it('skips deadline tick work when another instance holds the leader lock', async () => {
|
||||
const { redis, scheduler } = makeScheduler({ leaderLockAcquired: false });
|
||||
const processDueBidRoundDeadlinesSpy = jest
|
||||
.spyOn(scheduler, 'processDueBidRoundDeadlines')
|
||||
.mockResolvedValue({ completed: 0, prepared: 0, skipped: 0 });
|
||||
|
||||
await (scheduler as unknown as { safeTick: () => Promise<void> }).safeTick();
|
||||
|
||||
expect(processDueBidRoundDeadlinesSpy).not.toHaveBeenCalled();
|
||||
expect(redis.releaseTokenLock).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('reads due match ids from the Redis deadline queue with a batch limit', async () => {
|
||||
const { redis, scheduler } = makeScheduler({
|
||||
dueReply: ['match-1', 'match-2'],
|
||||
});
|
||||
|
||||
await expect(scheduler.readDueMatchIds(1_000, 2)).resolves.toEqual([
|
||||
'match-1',
|
||||
'match-2',
|
||||
]);
|
||||
expect(redis.raw().sendCommand).toHaveBeenCalledWith([
|
||||
'ZRANGEBYSCORE',
|
||||
'auction:bidRoundDeadlineQueue',
|
||||
'-inf',
|
||||
'1000',
|
||||
'LIMIT',
|
||||
'0',
|
||||
'2',
|
||||
]);
|
||||
});
|
||||
|
||||
it('prepares and completes due auction deadlines', async () => {
|
||||
const matchId = '665f2f01f1f1f1f1f1f1f1f1';
|
||||
const { auctionService, redisCommand, scheduler } = makeScheduler({
|
||||
dueReply: [matchId],
|
||||
});
|
||||
|
||||
await expect(scheduler.processDueBidRoundDeadlines(10)).resolves.toEqual({
|
||||
completed: 1,
|
||||
prepared: 1,
|
||||
skipped: 0,
|
||||
});
|
||||
expect(redisCommand.expirePrepare).toHaveBeenCalledWith(
|
||||
matchId,
|
||||
expect.objectContaining({
|
||||
bidRoundExpiryRetryDelayMS: 3000,
|
||||
matchId,
|
||||
}),
|
||||
);
|
||||
expect(auctionService.completePreparedExpiry).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
it('skips noop expiry preparations', async () => {
|
||||
const { auctionService, scheduler } = makeScheduler({
|
||||
dueReply: ['665f2f01f1f1f1f1f1f1f1f1'],
|
||||
expireReply: {
|
||||
code: 'NOT_DUE',
|
||||
currentServerTimestampMS: 1000,
|
||||
noop: true,
|
||||
},
|
||||
});
|
||||
|
||||
await expect(scheduler.processDueBidRoundDeadlines(10)).resolves.toEqual({
|
||||
completed: 0,
|
||||
prepared: 0,
|
||||
skipped: 1,
|
||||
});
|
||||
expect(auctionService.completePreparedExpiry).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('removes invalid deadline queue members', async () => {
|
||||
const { scheduler, sendCommand } = makeScheduler({
|
||||
dueReply: ['not-a-match-id'],
|
||||
});
|
||||
|
||||
await expect(scheduler.processDueBidRoundDeadlines(10)).resolves.toEqual({
|
||||
completed: 0,
|
||||
prepared: 0,
|
||||
skipped: 1,
|
||||
});
|
||||
expect(sendCommand).toHaveBeenLastCalledWith([
|
||||
'ZREM',
|
||||
'auction:bidRoundDeadlineQueue',
|
||||
'not-a-match-id',
|
||||
]);
|
||||
});
|
||||
|
||||
it('continues processing later deadline items after one item fails', async () => {
|
||||
const matchIds = [
|
||||
'665f2f01f1f1f1f1f1f1f1f1',
|
||||
'665f2f02f1f1f1f1f1f1f1f1',
|
||||
];
|
||||
const { auctionService, redisCommand, scheduler } = makeScheduler({
|
||||
dueReply: matchIds,
|
||||
});
|
||||
redisCommand.expirePrepare
|
||||
.mockRejectedValueOnce(new Error('temporary redis error'))
|
||||
.mockResolvedValueOnce({
|
||||
auctionStateTransitionId: 'expire-2',
|
||||
bidRoundExpiryDecision: 'passed',
|
||||
currentServerTimestampMS: 1000,
|
||||
ok: true,
|
||||
revision: 3,
|
||||
});
|
||||
|
||||
await expect(scheduler.processDueBidRoundDeadlines(10)).resolves.toEqual({
|
||||
completed: 1,
|
||||
prepared: 1,
|
||||
skipped: 1,
|
||||
});
|
||||
expect(redisCommand.expirePrepare).toHaveBeenCalledTimes(2);
|
||||
expect(auctionService.completePreparedExpiry).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,150 @@
|
||||
import {
|
||||
Injectable,
|
||||
Logger,
|
||||
OnModuleDestroy,
|
||||
OnModuleInit,
|
||||
} from '@nestjs/common';
|
||||
import { randomUUID } from 'crypto';
|
||||
import mongoose from 'mongoose';
|
||||
import { AuctionService } from './auction.service';
|
||||
import { AuctionRedisCommandService } from './redis/auction-redis-command.service';
|
||||
import { AuctionRedisService } from './redis/auction-redis.service';
|
||||
|
||||
const BID_ROUND_DEADLINE_QUEUE_KEY = 'auction:bidRoundDeadlineQueue';
|
||||
const BID_ROUND_EXPIRY_RETRY_DELAY_MS = 3000;
|
||||
const BID_ROUND_DEADLINE_TICK_INTERVAL_MS = 1000;
|
||||
const BID_ROUND_DEADLINE_BATCH_LIMIT = 20;
|
||||
const BID_ROUND_DEADLINE_LEADER_LOCK_KEY =
|
||||
'auction:bidRoundDeadlineScheduler:leader';
|
||||
const BID_ROUND_DEADLINE_LEADER_LOCK_TTL_MS = 2500;
|
||||
|
||||
@Injectable()
|
||||
export class AuctionDeadlineScheduler implements OnModuleInit, OnModuleDestroy {
|
||||
private readonly logger = new Logger(AuctionDeadlineScheduler.name);
|
||||
private tickTimer?: NodeJS.Timeout;
|
||||
private tickInProgress = false;
|
||||
|
||||
constructor(
|
||||
private readonly auctionRedisService: AuctionRedisService,
|
||||
private readonly auctionRedisCommandService: AuctionRedisCommandService,
|
||||
private readonly auctionService: AuctionService,
|
||||
) {}
|
||||
|
||||
public onModuleInit(): void {
|
||||
this.tickTimer = setInterval(
|
||||
() => void this.safeTick(),
|
||||
BID_ROUND_DEADLINE_TICK_INTERVAL_MS,
|
||||
);
|
||||
this.tickTimer.unref?.();
|
||||
}
|
||||
|
||||
public onModuleDestroy(): void {
|
||||
if (this.tickTimer) clearInterval(this.tickTimer);
|
||||
}
|
||||
|
||||
private async safeTick(): Promise<void> {
|
||||
if (this.tickInProgress) return;
|
||||
this.tickInProgress = true;
|
||||
const leaderLockToken = randomUUID();
|
||||
let leaderLockAcquired = false;
|
||||
try {
|
||||
leaderLockAcquired = await this.auctionRedisService.acquireTokenLock(
|
||||
BID_ROUND_DEADLINE_LEADER_LOCK_KEY,
|
||||
leaderLockToken,
|
||||
BID_ROUND_DEADLINE_LEADER_LOCK_TTL_MS,
|
||||
);
|
||||
if (!leaderLockAcquired) return;
|
||||
await this.processDueBidRoundDeadlines(BID_ROUND_DEADLINE_BATCH_LIMIT);
|
||||
} catch (error) {
|
||||
this.logger.warn(
|
||||
`Auction deadline tick failed: ${
|
||||
error instanceof Error ? error.message : error
|
||||
}`,
|
||||
);
|
||||
} finally {
|
||||
if (leaderLockAcquired) {
|
||||
await this.auctionRedisService.releaseTokenLock(
|
||||
BID_ROUND_DEADLINE_LEADER_LOCK_KEY,
|
||||
leaderLockToken,
|
||||
);
|
||||
}
|
||||
this.tickInProgress = false;
|
||||
}
|
||||
}
|
||||
|
||||
public async readDueMatchIds(
|
||||
currentRedisTimestampMS: number,
|
||||
batchLimit: number,
|
||||
): Promise<string[]> {
|
||||
const reply = await this.auctionRedisService.raw().sendCommand([
|
||||
'ZRANGEBYSCORE',
|
||||
BID_ROUND_DEADLINE_QUEUE_KEY,
|
||||
'-inf',
|
||||
String(currentRedisTimestampMS),
|
||||
'LIMIT',
|
||||
'0',
|
||||
String(batchLimit),
|
||||
]);
|
||||
return Array.isArray(reply) ? reply.map(String) : [];
|
||||
}
|
||||
|
||||
public async processDueBidRoundDeadlines(batchLimit: number): Promise<{
|
||||
completed: number;
|
||||
prepared: number;
|
||||
skipped: number;
|
||||
}> {
|
||||
const currentRedisTimestampMS =
|
||||
await this.auctionRedisService.getCurrentRedisTimestampMS();
|
||||
const matchIds = await this.readDueMatchIds(
|
||||
currentRedisTimestampMS,
|
||||
batchLimit,
|
||||
);
|
||||
let prepared = 0;
|
||||
let completed = 0;
|
||||
let skipped = 0;
|
||||
|
||||
for (const matchId of matchIds) {
|
||||
if (!mongoose.isValidObjectId(matchId)) {
|
||||
skipped += 1;
|
||||
await this.removeBidRoundDeadlineQueueEntry(matchId);
|
||||
continue;
|
||||
}
|
||||
try {
|
||||
const result = await this.auctionRedisCommandService.expirePrepare(
|
||||
matchId,
|
||||
{
|
||||
auctionStateTransitionId: `expire:${matchId}:${randomUUID()}`,
|
||||
bidRoundExpiryRetryDelayMS: BID_ROUND_EXPIRY_RETRY_DELAY_MS,
|
||||
matchId,
|
||||
},
|
||||
);
|
||||
if ('noop' in result) {
|
||||
skipped += 1;
|
||||
continue;
|
||||
}
|
||||
prepared += 1;
|
||||
const completedState = await this.auctionService.completePreparedExpiry(
|
||||
new mongoose.Types.ObjectId(matchId),
|
||||
);
|
||||
if (completedState) completed += 1;
|
||||
} catch (error) {
|
||||
skipped += 1;
|
||||
this.logger.warn(
|
||||
`Auction deadline item failed for ${matchId}: ${
|
||||
error instanceof Error ? error.message : error
|
||||
}`,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
return { completed, prepared, skipped };
|
||||
}
|
||||
|
||||
private async removeBidRoundDeadlineQueueEntry(matchId: string): Promise<void> {
|
||||
await this.auctionRedisService.raw().sendCommand([
|
||||
'ZREM',
|
||||
BID_ROUND_DEADLINE_QUEUE_KEY,
|
||||
matchId,
|
||||
]);
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large.
Load diff
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,27 @@
|
||||
import { Injectable } from '@nestjs/common';
|
||||
import type { Namespace } from 'socket.io';
|
||||
import type { AuctionStateResponse } from './auction.service';
|
||||
import type { MatchSideEffectDelta } from './auction-side-effect.service';
|
||||
|
||||
@Injectable()
|
||||
export class AuctionEventBusService {
|
||||
private auctionNamespace?: Namespace;
|
||||
|
||||
public attachAuctionNamespace(namespace: Namespace): void {
|
||||
this.auctionNamespace = namespace;
|
||||
}
|
||||
|
||||
public broadcastMatchSideEffect(
|
||||
matchId: string,
|
||||
delta: MatchSideEffectDelta,
|
||||
): void {
|
||||
this.auctionNamespace?.to(matchId).emit('match-side-effect', delta);
|
||||
}
|
||||
|
||||
public broadcastState(matchId: string, state: AuctionStateResponse): void {
|
||||
this.auctionNamespace?.to(matchId).emit(
|
||||
'state',
|
||||
JSON.parse(JSON.stringify(state)),
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,101 @@
|
||||
import {
|
||||
AuctionSideEffectService,
|
||||
buildMatchSideEffectDelta,
|
||||
buildSideEffectApplicationIdentity,
|
||||
buildSideEffectLeaseAcquireUpdate,
|
||||
canAcquireSideEffectLease,
|
||||
} from './auction-side-effect.service';
|
||||
|
||||
describe('auction side effect helpers', () => {
|
||||
it('builds idempotency identity from transition and side effect type', () => {
|
||||
expect(
|
||||
buildSideEffectApplicationIdentity({
|
||||
auctionId: 'auction-1',
|
||||
auctionStateTransitionId: 'transition-1',
|
||||
sideEffectType: 'syncMatchTeams',
|
||||
}),
|
||||
).toEqual({
|
||||
auctionId: 'auction-1',
|
||||
auctionStateTransitionId: 'transition-1',
|
||||
sideEffectType: 'syncMatchTeams',
|
||||
});
|
||||
});
|
||||
|
||||
it('allows lease acquisition for pending, failed, or stale processing items only', () => {
|
||||
expect(canAcquireSideEffectLease({ state: 'pending' }, 1000)).toBe(true);
|
||||
expect(canAcquireSideEffectLease({ state: 'failed' }, 1000)).toBe(true);
|
||||
expect(
|
||||
canAcquireSideEffectLease(
|
||||
{ processingLeaseExpiresAtTimestampMS: 999, state: 'processing' },
|
||||
1000,
|
||||
),
|
||||
).toBe(true);
|
||||
expect(
|
||||
canAcquireSideEffectLease(
|
||||
{ processingLeaseExpiresAtTimestampMS: 1001, state: 'processing' },
|
||||
1000,
|
||||
),
|
||||
).toBe(false);
|
||||
expect(canAcquireSideEffectLease({ state: 'completed' }, 1000)).toBe(false);
|
||||
});
|
||||
|
||||
it('builds lease acquire update with Redis TIME timestamps', () => {
|
||||
expect(
|
||||
buildSideEffectLeaseAcquireUpdate({
|
||||
currentRedisTimestampMS: 1000,
|
||||
leaseDurationMS: 5000,
|
||||
ownerToken: 'worker-1',
|
||||
}),
|
||||
).toEqual({
|
||||
$inc: { attempts: 1 },
|
||||
$set: {
|
||||
processingLeaseExpiresAtTimestampMS: 6000,
|
||||
processingOwnerToken: 'worker-1',
|
||||
processingStartedAtTimestampMS: 1000,
|
||||
state: 'processing',
|
||||
},
|
||||
});
|
||||
});
|
||||
|
||||
it('builds side-effect socket delta independently from auction revision', () => {
|
||||
expect(
|
||||
buildMatchSideEffectDelta({
|
||||
auctionLifecycleId: 'life-1',
|
||||
currentServerTimestampMS: 1000,
|
||||
matchSideEffectRevision: 3,
|
||||
matchSideEffectStatus: 'completed',
|
||||
}),
|
||||
).toEqual({
|
||||
auctionLifecycleId: 'life-1',
|
||||
currentServerTimestampMS: 1000,
|
||||
matchSideEffectRevision: 3,
|
||||
matchSideEffectStatus: 'completed',
|
||||
});
|
||||
});
|
||||
|
||||
it('mirrors side-effect status into Redis live state with lifecycle and revision guard', async () => {
|
||||
const sendCommand = jest.fn().mockResolvedValue(1);
|
||||
const service = new AuctionSideEffectService({
|
||||
raw: jest.fn().mockReturnValue({ sendCommand }),
|
||||
} as never);
|
||||
|
||||
await expect(
|
||||
service.mirrorMatchSideEffectStatus({
|
||||
auctionLifecycleId: 'life-1',
|
||||
matchId: 'match-1',
|
||||
matchSideEffectRevision: 2,
|
||||
matchSideEffectStatus: 'completed',
|
||||
}),
|
||||
).resolves.toBe(true);
|
||||
|
||||
expect(sendCommand).toHaveBeenCalledWith([
|
||||
'EVAL',
|
||||
expect.stringContaining('auctionLifecycleId'),
|
||||
'1',
|
||||
'auction:match-1:liveAuctionState',
|
||||
'life-1',
|
||||
'2',
|
||||
'completed',
|
||||
]);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,110 @@
|
||||
import { Injectable } from '@nestjs/common';
|
||||
import type {
|
||||
AuctionMatchSideEffectStatus,
|
||||
AuctionSideEffectApplicationState,
|
||||
} from '../global/database/schema';
|
||||
import { buildAuctionRedisKeys } from './redis/auction-redis.keys';
|
||||
import { AuctionRedisService } from './redis/auction-redis.service';
|
||||
|
||||
export interface SideEffectApplicationIdentity {
|
||||
auctionId: unknown;
|
||||
auctionStateTransitionId: string;
|
||||
sideEffectType: string;
|
||||
}
|
||||
|
||||
export interface SideEffectLeaseState {
|
||||
processingLeaseExpiresAtTimestampMS?: number;
|
||||
state: AuctionSideEffectApplicationState;
|
||||
}
|
||||
|
||||
export interface BuildSideEffectLeaseAcquireUpdateParams {
|
||||
currentRedisTimestampMS: number;
|
||||
leaseDurationMS: number;
|
||||
ownerToken: string;
|
||||
}
|
||||
|
||||
export interface MatchSideEffectDelta {
|
||||
auctionLifecycleId: string;
|
||||
currentServerTimestampMS: number;
|
||||
matchSideEffectRevision: number;
|
||||
matchSideEffectStatus: AuctionMatchSideEffectStatus;
|
||||
}
|
||||
|
||||
@Injectable()
|
||||
export class AuctionSideEffectService {
|
||||
constructor(private readonly auctionRedisService: AuctionRedisService) {}
|
||||
|
||||
public async mirrorMatchSideEffectStatus(params: {
|
||||
auctionLifecycleId: string;
|
||||
matchId: string;
|
||||
matchSideEffectRevision: number;
|
||||
matchSideEffectStatus: AuctionMatchSideEffectStatus;
|
||||
}): Promise<boolean> {
|
||||
const keys = buildAuctionRedisKeys(params.matchId);
|
||||
const result = await this.auctionRedisService.raw().sendCommand([
|
||||
'EVAL',
|
||||
[
|
||||
"if redis.call('HGET', KEYS[1], 'auctionLifecycleId') ~= ARGV[1] then return 0 end",
|
||||
"local currentRevision = tonumber(redis.call('HGET', KEYS[1], 'matchSideEffectRevision') or '-1')",
|
||||
'local nextRevision = tonumber(ARGV[2])',
|
||||
'if currentRevision >= nextRevision then return 0 end',
|
||||
"redis.call('HSET', KEYS[1], 'matchSideEffectRevision', ARGV[2], 'matchSideEffectStatus', ARGV[3])",
|
||||
'return 1',
|
||||
].join('\n'),
|
||||
'1',
|
||||
keys.liveStateKey,
|
||||
params.auctionLifecycleId,
|
||||
String(params.matchSideEffectRevision),
|
||||
params.matchSideEffectStatus,
|
||||
]);
|
||||
return Number(result) === 1;
|
||||
}
|
||||
}
|
||||
|
||||
export function buildSideEffectApplicationIdentity(
|
||||
params: SideEffectApplicationIdentity,
|
||||
): SideEffectApplicationIdentity {
|
||||
return {
|
||||
auctionId: params.auctionId,
|
||||
auctionStateTransitionId: params.auctionStateTransitionId,
|
||||
sideEffectType: params.sideEffectType,
|
||||
};
|
||||
}
|
||||
|
||||
export function canAcquireSideEffectLease(
|
||||
state: SideEffectLeaseState,
|
||||
currentRedisTimestampMS: number,
|
||||
): boolean {
|
||||
if (state.state === 'pending' || state.state === 'failed') return true;
|
||||
if (state.state !== 'processing') return false;
|
||||
return (
|
||||
(state.processingLeaseExpiresAtTimestampMS ?? 0) <=
|
||||
currentRedisTimestampMS
|
||||
);
|
||||
}
|
||||
|
||||
export function buildSideEffectLeaseAcquireUpdate(
|
||||
params: BuildSideEffectLeaseAcquireUpdateParams,
|
||||
) {
|
||||
return {
|
||||
$inc: { attempts: 1 },
|
||||
$set: {
|
||||
processingLeaseExpiresAtTimestampMS:
|
||||
params.currentRedisTimestampMS + params.leaseDurationMS,
|
||||
processingOwnerToken: params.ownerToken,
|
||||
processingStartedAtTimestampMS: params.currentRedisTimestampMS,
|
||||
state: 'processing',
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
export function buildMatchSideEffectDelta(
|
||||
params: MatchSideEffectDelta,
|
||||
): MatchSideEffectDelta {
|
||||
return {
|
||||
auctionLifecycleId: params.auctionLifecycleId,
|
||||
currentServerTimestampMS: params.currentServerTimestampMS,
|
||||
matchSideEffectRevision: params.matchSideEffectRevision,
|
||||
matchSideEffectStatus: params.matchSideEffectStatus,
|
||||
};
|
||||
}
|
||||
@@ -20,7 +20,11 @@ import type { UserDocument } from '../global/database/schema';
|
||||
import { AuctionService } from './auction.service';
|
||||
import { AuctionGateway } from './auction.gateway';
|
||||
import {
|
||||
NextAuctionDto,
|
||||
OpenBiddingDto,
|
||||
PassedAuctionDto,
|
||||
PlaceBidDto,
|
||||
ResetAuctionDto,
|
||||
SoldDto,
|
||||
StartAuctionDto,
|
||||
UndoAuctionDto,
|
||||
@@ -47,18 +51,22 @@ export class AuctionController {
|
||||
return this.auctionService.start({
|
||||
matchId,
|
||||
communityId,
|
||||
startAuctionRequestId: body.startAuctionRequestId,
|
||||
actorUserId: currentUser._id,
|
||||
captains: body.captains.map((c) => ({
|
||||
teamIndex: c.teamIndex,
|
||||
userId: new mongoose.Types.ObjectId(c.userId),
|
||||
initialPoints: c.initialPoints,
|
||||
initialTeamBidPointAmount: c.initialTeamBidPointAmount,
|
||||
})),
|
||||
initialPoints: body.initialPoints ?? 1000,
|
||||
maxTimerSeconds: body.maxTimerSeconds ?? 30,
|
||||
bidExtensionSeconds: body.bidExtensionSeconds ?? 5,
|
||||
topTierThreshold: body.topTierThreshold ?? 'NONE',
|
||||
manualTopTierUserIds: (body.manualTopTierUserIds ?? []).map(
|
||||
(userId) => new mongoose.Types.ObjectId(userId),
|
||||
),
|
||||
initialTeamBidPointAmount: body.initialTeamBidPointAmount ?? 1000,
|
||||
maximumBidRoundDurationSeconds:
|
||||
body.maximumBidRoundDurationSeconds ?? 30,
|
||||
bidRoundExtensionSeconds: body.bidRoundExtensionSeconds ?? 5,
|
||||
topTierAuctionPriorityThreshold:
|
||||
body.topTierAuctionPriorityThreshold ?? 'NONE',
|
||||
manualTopTierAuctionPriorityUserIds: (
|
||||
body.manualTopTierAuctionPriorityUserIds ?? []
|
||||
).map((userId) => new mongoose.Types.ObjectId(userId)),
|
||||
});
|
||||
}
|
||||
|
||||
@@ -67,7 +75,7 @@ export class AuctionController {
|
||||
public async getAuction(
|
||||
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
||||
) {
|
||||
return this.auctionService.getByMatchId(matchId);
|
||||
return this.auctionService.getStateByMatchId(matchId);
|
||||
}
|
||||
|
||||
// 공개 — 팀장 2명만 쓸 엔드포인트(트러스트 기반, 10명 동시 관전).
|
||||
@@ -76,23 +84,26 @@ export class AuctionController {
|
||||
@HttpCode(HttpStatus.OK)
|
||||
public async openBidding(
|
||||
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
||||
@Body() body: OpenBiddingDto = {},
|
||||
) {
|
||||
return this.auctionService.openBidding(matchId);
|
||||
return this.auctionService.openBidding(matchId, body);
|
||||
}
|
||||
|
||||
@Post('bids')
|
||||
@AllowPublicAccess()
|
||||
@HttpCode(HttpStatus.OK)
|
||||
public async placeBid(
|
||||
@CurrentUser() currentUser: UserDocument | undefined,
|
||||
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
||||
@Body() body: PlaceBidDto,
|
||||
) {
|
||||
return this.auctionService.placeBid({
|
||||
matchId,
|
||||
teamIndex: body.teamIndex,
|
||||
amount: body.amount,
|
||||
bidderUserId: this.resolveBidder(currentUser, body.bidderUserId),
|
||||
teamIndex: body.bidderTeamIndex,
|
||||
amount: body.bidPointAmount,
|
||||
bidRequestId: body.bidRequestId,
|
||||
clientObservedAuctionLifecycleId: body.clientObservedAuctionLifecycleId,
|
||||
clientObservedCurrentBidRoundPlayerUserId:
|
||||
body.clientObservedCurrentBidRoundPlayerUserId,
|
||||
});
|
||||
}
|
||||
|
||||
@@ -106,16 +117,35 @@ export class AuctionController {
|
||||
return this.auctionService.markSold({
|
||||
matchId,
|
||||
assignedPosition: body.assignedPosition,
|
||||
auctionActionRequestId: body.auctionActionRequestId,
|
||||
clientObservedAuctionLifecycleId: body.clientObservedAuctionLifecycleId,
|
||||
clientObservedCurrentAuctionPlayerOrderIndex:
|
||||
body.clientObservedCurrentAuctionPlayerOrderIndex,
|
||||
clientObservedCurrentBidRoundPlayerUserId:
|
||||
body.clientObservedCurrentBidRoundPlayerUserId,
|
||||
clientObservedPhase: body.clientObservedPhase,
|
||||
clientObservedRevision: body.clientObservedRevision,
|
||||
});
|
||||
}
|
||||
|
||||
@Post('passed')
|
||||
@AllowPublicAccess()
|
||||
@HttpCode(HttpStatus.OK)
|
||||
public async markPassed(
|
||||
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
||||
@Body() body: PassedAuctionDto = {},
|
||||
) {
|
||||
return this.auctionService.markPassed(matchId, body);
|
||||
}
|
||||
|
||||
@Post('next')
|
||||
@AllowPublicAccess()
|
||||
@HttpCode(HttpStatus.OK)
|
||||
public async next(
|
||||
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
||||
@Body() body: NextAuctionDto = {},
|
||||
) {
|
||||
return this.auctionService.next(matchId);
|
||||
return this.auctionService.next(matchId, body);
|
||||
}
|
||||
|
||||
@Get('history')
|
||||
@@ -147,6 +177,14 @@ export class AuctionController {
|
||||
matchId,
|
||||
communityId,
|
||||
sequence: body.sequence,
|
||||
auctionActionRequestId: body.auctionActionRequestId,
|
||||
clientObservedAuctionLifecycleId: body.clientObservedAuctionLifecycleId,
|
||||
clientObservedCurrentAuctionPlayerOrderIndex:
|
||||
body.clientObservedCurrentAuctionPlayerOrderIndex,
|
||||
clientObservedCurrentBidRoundPlayerUserId:
|
||||
body.clientObservedCurrentBidRoundPlayerUserId,
|
||||
clientObservedPhase: body.clientObservedPhase,
|
||||
clientObservedRevision: body.clientObservedRevision,
|
||||
});
|
||||
this.auctionGateway.broadcastState(matchId.toString(), auction);
|
||||
return auction;
|
||||
@@ -161,24 +199,24 @@ export class AuctionController {
|
||||
@Param('communityId', ParseObjectIdPipe)
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
@Param('matchId', ParseObjectIdPipe) matchId: mongoose.Types.ObjectId,
|
||||
@Body() body: ResetAuctionDto = {},
|
||||
) {
|
||||
this.assertSameCommunity(currentUser, communityId);
|
||||
await this.auctionService.reset({ matchId, communityId });
|
||||
await this.auctionService.reset({
|
||||
matchId,
|
||||
communityId,
|
||||
auctionActionRequestId: body.auctionActionRequestId,
|
||||
clientObservedAuctionLifecycleId: body.clientObservedAuctionLifecycleId,
|
||||
clientObservedCurrentAuctionPlayerOrderIndex:
|
||||
body.clientObservedCurrentAuctionPlayerOrderIndex,
|
||||
clientObservedCurrentBidRoundPlayerUserId:
|
||||
body.clientObservedCurrentBidRoundPlayerUserId,
|
||||
clientObservedPhase: body.clientObservedPhase,
|
||||
clientObservedRevision: body.clientObservedRevision,
|
||||
});
|
||||
this.auctionGateway.broadcastReset(matchId.toString());
|
||||
}
|
||||
|
||||
private resolveBidder(
|
||||
currentUser: UserDocument | undefined,
|
||||
bodyBidder?: string,
|
||||
): mongoose.Types.ObjectId | undefined {
|
||||
if (currentUser) return currentUser._id;
|
||||
if (!bodyBidder) return undefined;
|
||||
if (!mongoose.isValidObjectId(bodyBidder)) {
|
||||
throw new BadRequestException('Invalid bidderUserId.');
|
||||
}
|
||||
return new mongoose.Types.ObjectId(bodyBidder);
|
||||
}
|
||||
|
||||
private assertSameCommunity(
|
||||
user: UserDocument,
|
||||
communityId: mongoose.Types.ObjectId,
|
||||
|
||||
@@ -0,0 +1,253 @@
|
||||
import mongoose from 'mongoose';
|
||||
|
||||
jest.mock('../auth/jwt.service', () => ({
|
||||
JwtService: class JwtService {},
|
||||
}));
|
||||
|
||||
import { AuctionGateway } from './auction.gateway';
|
||||
|
||||
describe('AuctionGateway', () => {
|
||||
function createGateway(params?: {
|
||||
placeBid?: jest.Mock;
|
||||
}) {
|
||||
const auctionService = {
|
||||
placeBid: params?.placeBid ?? jest.fn(),
|
||||
};
|
||||
const gateway = new AuctionGateway(
|
||||
auctionService as never,
|
||||
{ resolveDevUserById: jest.fn() } as never,
|
||||
{ verify: jest.fn() } as never,
|
||||
{ findOrCreateByOid: jest.fn() } as never,
|
||||
{ getModel: jest.fn() } as never,
|
||||
{ attachAuctionNamespace: jest.fn() } as never,
|
||||
);
|
||||
const emit = jest.fn();
|
||||
const to = jest.fn().mockReturnValue({ emit });
|
||||
(gateway as unknown as { server: { to: jest.Mock } }).server = { to };
|
||||
|
||||
return {
|
||||
auctionService,
|
||||
emit,
|
||||
gateway,
|
||||
to,
|
||||
};
|
||||
}
|
||||
|
||||
it('broadcasts a bid delta and acknowledges the matching bid request', async () => {
|
||||
const matchId = new mongoose.Types.ObjectId().toString();
|
||||
const auctionBidHistoryEntry = {
|
||||
bidderTeamIndex: 2,
|
||||
bidderUserId: 'captain-2',
|
||||
bidPlacedAtTimestampMS: 1780000000000,
|
||||
bidPointAmount: 120,
|
||||
};
|
||||
const placeBid = jest.fn().mockResolvedValue({
|
||||
auctionBidHistory: [auctionBidHistoryEntry],
|
||||
auctionLifecycleId: 'life-1',
|
||||
currentBidRoundDeadlineTimestampMS: 1780000030000,
|
||||
currentHighestBidderTeamIndex: 2,
|
||||
currentHighestBidPointAmount: 120,
|
||||
currentServerTimestampMS: 1780000000000,
|
||||
revision: 9,
|
||||
});
|
||||
const { emit, gateway, to } = createGateway({ placeBid });
|
||||
const ack = jest.fn();
|
||||
|
||||
await gateway.handleBid(
|
||||
{ data: { matchId }, emit: jest.fn() } as never,
|
||||
{
|
||||
bidPointAmount: 120,
|
||||
bidderTeamIndex: 2,
|
||||
bidRequestId: 'bid-1',
|
||||
clientObservedAuctionLifecycleId: 'life-1',
|
||||
clientObservedCurrentBidRoundPlayerUserId: 'player-1',
|
||||
},
|
||||
ack,
|
||||
);
|
||||
|
||||
expect(placeBid).toHaveBeenCalledWith({
|
||||
amount: 120,
|
||||
bidRequestId: 'bid-1',
|
||||
clientObservedAuctionLifecycleId: 'life-1',
|
||||
clientObservedCurrentBidRoundPlayerUserId: 'player-1',
|
||||
matchId: new mongoose.Types.ObjectId(matchId),
|
||||
teamIndex: 2,
|
||||
});
|
||||
expect(to).toHaveBeenCalledWith(matchId);
|
||||
expect(emit).toHaveBeenCalledWith('bid', {
|
||||
auctionBidHistoryEntry,
|
||||
auctionLifecycleId: 'life-1',
|
||||
bidRequestId: 'bid-1',
|
||||
currentBidRoundDeadlineTimestampMS: 1780000030000,
|
||||
currentHighestBidderTeamIndex: 2,
|
||||
currentHighestBidPointAmount: 120,
|
||||
currentServerTimestampMS: 1780000000000,
|
||||
revision: 9,
|
||||
});
|
||||
expect(ack).toHaveBeenCalledWith({
|
||||
bidRequestId: 'bid-1',
|
||||
ok: true,
|
||||
state: expect.objectContaining({
|
||||
auctionLifecycleId: 'life-1',
|
||||
revision: 9,
|
||||
}),
|
||||
});
|
||||
});
|
||||
|
||||
it('generates one bid request id when the client omits it', async () => {
|
||||
const matchId = new mongoose.Types.ObjectId().toString();
|
||||
const placeBid = jest.fn().mockResolvedValue({
|
||||
auctionBidHistory: [
|
||||
{
|
||||
bidderTeamIndex: 1,
|
||||
bidPointAmount: 50,
|
||||
},
|
||||
],
|
||||
auctionLifecycleId: 'life-1',
|
||||
currentHighestBidderTeamIndex: 1,
|
||||
currentHighestBidPointAmount: 50,
|
||||
revision: 3,
|
||||
});
|
||||
const { emit, gateway } = createGateway({ placeBid });
|
||||
const ack = jest.fn();
|
||||
|
||||
await gateway.handleBid(
|
||||
{ data: { matchId }, emit: jest.fn() } as never,
|
||||
{
|
||||
bidPointAmount: 50,
|
||||
bidderTeamIndex: 1,
|
||||
},
|
||||
ack,
|
||||
);
|
||||
|
||||
const generatedBidRequestId = placeBid.mock.calls[0][0].bidRequestId;
|
||||
expect(generatedBidRequestId).toEqual(expect.any(String));
|
||||
expect(generatedBidRequestId).not.toHaveLength(0);
|
||||
expect(emit).toHaveBeenCalledWith(
|
||||
'bid',
|
||||
expect.objectContaining({
|
||||
bidRequestId: generatedBidRequestId,
|
||||
}),
|
||||
);
|
||||
expect(ack).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
bidRequestId: generatedBidRequestId,
|
||||
ok: true,
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it('acknowledges bid failures with the request id used for the attempt', async () => {
|
||||
const matchId = new mongoose.Types.ObjectId().toString();
|
||||
const placeBid = jest.fn().mockRejectedValue(new Error('Bid failed'));
|
||||
const socketEmit = jest.fn();
|
||||
const { gateway } = createGateway({ placeBid });
|
||||
const ack = jest.fn();
|
||||
|
||||
await gateway.handleBid(
|
||||
{ data: { matchId }, emit: socketEmit } as never,
|
||||
{
|
||||
bidPointAmount: 50,
|
||||
bidderTeamIndex: 1,
|
||||
bidRequestId: 'bid-1',
|
||||
},
|
||||
ack,
|
||||
);
|
||||
|
||||
expect(socketEmit).toHaveBeenCalledWith('error', {
|
||||
message: 'Bid failed',
|
||||
});
|
||||
expect(ack).toHaveBeenCalledWith({
|
||||
bidRequestId: 'bid-1',
|
||||
code: 'Bid failed',
|
||||
rejected: true,
|
||||
});
|
||||
});
|
||||
|
||||
it('rate limits excessive bid requests from the same socket', async () => {
|
||||
jest.spyOn(Date, 'now').mockReturnValue(1780000000000);
|
||||
const matchId = new mongoose.Types.ObjectId().toString();
|
||||
const placeBid = jest.fn().mockResolvedValue({
|
||||
auctionBidHistory: [
|
||||
{
|
||||
bidderTeamIndex: 1,
|
||||
bidPointAmount: 50,
|
||||
},
|
||||
],
|
||||
currentHighestBidderTeamIndex: 1,
|
||||
currentHighestBidPointAmount: 50,
|
||||
revision: 3,
|
||||
});
|
||||
const socketEmit = jest.fn();
|
||||
const socket = { data: { matchId }, emit: socketEmit };
|
||||
const { gateway } = createGateway({ placeBid });
|
||||
const acknowledgements: Array<Record<string, unknown>> = [];
|
||||
|
||||
for (let index = 0; index < 9; index += 1) {
|
||||
await gateway.handleBid(
|
||||
socket as never,
|
||||
{
|
||||
bidPointAmount: 50,
|
||||
bidderTeamIndex: 1,
|
||||
bidRequestId: `bid-${index}`,
|
||||
},
|
||||
(response) => acknowledgements.push(response),
|
||||
);
|
||||
}
|
||||
|
||||
expect(placeBid).toHaveBeenCalledTimes(8);
|
||||
expect(socketEmit).toHaveBeenCalledWith('error', {
|
||||
message: '입찰 요청이 너무 많습니다. 잠시 후 다시 시도해주세요.',
|
||||
});
|
||||
expect(acknowledgements[8]).toEqual({
|
||||
bidRequestId: 'bid-8',
|
||||
code: 'BID_RATE_LIMITED',
|
||||
message: '입찰 요청이 너무 많습니다. 잠시 후 다시 시도해주세요.',
|
||||
rejected: true,
|
||||
});
|
||||
});
|
||||
|
||||
it('allows bid requests again after the rate limit window resets', async () => {
|
||||
const nowSpy = jest.spyOn(Date, 'now');
|
||||
nowSpy.mockReturnValue(1780000000000);
|
||||
const matchId = new mongoose.Types.ObjectId().toString();
|
||||
const placeBid = jest.fn().mockResolvedValue({
|
||||
auctionBidHistory: [
|
||||
{
|
||||
bidderTeamIndex: 1,
|
||||
bidPointAmount: 50,
|
||||
},
|
||||
],
|
||||
currentHighestBidderTeamIndex: 1,
|
||||
currentHighestBidPointAmount: 50,
|
||||
revision: 3,
|
||||
});
|
||||
const socket = { data: { matchId }, emit: jest.fn() };
|
||||
const { gateway } = createGateway({ placeBid });
|
||||
|
||||
for (let index = 0; index < 8; index += 1) {
|
||||
await gateway.handleBid(
|
||||
socket as never,
|
||||
{
|
||||
bidPointAmount: 50,
|
||||
bidderTeamIndex: 1,
|
||||
bidRequestId: `bid-${index}`,
|
||||
},
|
||||
jest.fn(),
|
||||
);
|
||||
}
|
||||
|
||||
nowSpy.mockReturnValue(1780000001000);
|
||||
await gateway.handleBid(
|
||||
socket as never,
|
||||
{
|
||||
bidPointAmount: 50,
|
||||
bidderTeamIndex: 1,
|
||||
bidRequestId: 'bid-reset',
|
||||
},
|
||||
jest.fn(),
|
||||
);
|
||||
|
||||
expect(placeBid).toHaveBeenCalledTimes(9);
|
||||
});
|
||||
});
|
||||
@@ -1,9 +1,11 @@
|
||||
import { Logger } from '@nestjs/common';
|
||||
import { randomUUID } from 'crypto';
|
||||
import {
|
||||
Ack,
|
||||
ConnectedSocket,
|
||||
MessageBody,
|
||||
OnGatewayConnection,
|
||||
OnGatewayDisconnect,
|
||||
OnGatewayInit,
|
||||
SubscribeMessage,
|
||||
WebSocketGateway,
|
||||
WebSocketServer,
|
||||
@@ -23,26 +25,50 @@ import type {
|
||||
UserDocument,
|
||||
} from '../global/database/schema';
|
||||
import { AuctionService } from './auction.service';
|
||||
import type { AuctionStateResponse } from './auction.service';
|
||||
import { AuctionEventBusService } from './auction-event-bus.service';
|
||||
import type { MatchSideEffectDelta } from './auction-side-effect.service';
|
||||
|
||||
interface JoinAuctionPayload {
|
||||
matchId: string;
|
||||
}
|
||||
|
||||
interface BidPayload {
|
||||
teamIndex: number;
|
||||
amount: number;
|
||||
bidderUserId?: string;
|
||||
bidderTeamIndex: number;
|
||||
bidPointAmount: number;
|
||||
bidRequestId?: string;
|
||||
clientObservedAuctionLifecycleId?: string;
|
||||
clientObservedCurrentBidRoundPlayerUserId?: string;
|
||||
}
|
||||
|
||||
interface SoldPayload {
|
||||
auctionActionRequestId?: string;
|
||||
assignedPosition?: Position;
|
||||
clientObservedAuctionLifecycleId?: string;
|
||||
clientObservedCurrentAuctionPlayerOrderIndex?: number;
|
||||
clientObservedCurrentBidRoundPlayerUserId?: string;
|
||||
clientObservedPhase?: string;
|
||||
clientObservedRevision?: number;
|
||||
}
|
||||
|
||||
type AuctionActionPayload = Omit<SoldPayload, 'assignedPosition'>;
|
||||
|
||||
interface ChatMessagePayload {
|
||||
message?: string;
|
||||
displayName?: string;
|
||||
}
|
||||
|
||||
interface BidRateLimitState {
|
||||
count: number;
|
||||
windowStartedAtTimestampMS: number;
|
||||
}
|
||||
|
||||
const BID_RATE_LIMIT_WINDOW_MS = 1000;
|
||||
const BID_RATE_LIMIT_MAX_REQUESTS_PER_WINDOW = 8;
|
||||
const BID_RATE_LIMIT_REJECTION_CODE = 'BID_RATE_LIMITED';
|
||||
const BID_RATE_LIMIT_REJECTION_MESSAGE =
|
||||
'입찰 요청이 너무 많습니다. 잠시 후 다시 시도해주세요.';
|
||||
|
||||
@WebSocketGateway({
|
||||
namespace: '/auction',
|
||||
cors: {
|
||||
@@ -52,13 +78,12 @@ interface ChatMessagePayload {
|
||||
},
|
||||
})
|
||||
export class AuctionGateway
|
||||
implements OnGatewayConnection, OnGatewayDisconnect
|
||||
implements OnGatewayConnection, OnGatewayInit
|
||||
{
|
||||
@WebSocketServer()
|
||||
private server!: Namespace;
|
||||
|
||||
private readonly logger = new Logger(AuctionGateway.name);
|
||||
private readonly roomTimers = new Map<string, NodeJS.Timeout>();
|
||||
|
||||
constructor(
|
||||
private readonly auctionService: AuctionService,
|
||||
@@ -66,8 +91,13 @@ export class AuctionGateway
|
||||
private readonly jwtService: JwtService,
|
||||
private readonly identityService: IdentityService,
|
||||
private readonly connectionService: ConnectionService,
|
||||
private readonly auctionEventBusService: AuctionEventBusService,
|
||||
) {}
|
||||
|
||||
public afterInit(server: Namespace): void {
|
||||
this.auctionEventBusService.attachAuctionNamespace(server);
|
||||
}
|
||||
|
||||
public async handleConnection(socket: Socket) {
|
||||
try {
|
||||
await this.authenticateSocket(socket);
|
||||
@@ -82,12 +112,6 @@ export class AuctionGateway
|
||||
}
|
||||
}
|
||||
|
||||
public handleDisconnect(socket: Socket) {
|
||||
const matchId = this.getSocketMatchId(socket);
|
||||
if (!matchId) return;
|
||||
this.maybeClearRoomTimer(matchId);
|
||||
}
|
||||
|
||||
@SubscribeMessage('join')
|
||||
public async handleJoin(
|
||||
@ConnectedSocket() socket: Socket,
|
||||
@@ -106,8 +130,11 @@ export class AuctionGateway
|
||||
const auction = await this.auctionService.getByMatchId(
|
||||
new mongoose.Types.ObjectId(payload.matchId),
|
||||
);
|
||||
const auctionState = await this.auctionService.getStateByMatchId(
|
||||
new mongoose.Types.ObjectId(payload.matchId),
|
||||
);
|
||||
this.emitChatHistory(socket, auction);
|
||||
this.broadcastState(payload.matchId, auction);
|
||||
this.broadcastState(payload.matchId, auctionState);
|
||||
} catch (error) {
|
||||
this.emitKnownError(socket, error);
|
||||
}
|
||||
@@ -117,41 +144,85 @@ export class AuctionGateway
|
||||
public async handleBid(
|
||||
@ConnectedSocket() socket: Socket,
|
||||
@MessageBody() payload: BidPayload,
|
||||
@Ack() ack?: (response: Record<string, unknown>) => void,
|
||||
) {
|
||||
const matchId = this.requireJoinedMatchId(socket);
|
||||
if (!matchId) return;
|
||||
|
||||
const bidderUserId = this.resolveBidderUserId(socket, payload?.bidderUserId);
|
||||
if (payload?.bidderUserId && !bidderUserId) {
|
||||
this.emitError(socket, 'Invalid bidderUserId.');
|
||||
const bidRequestId = payload.bidRequestId ?? randomUUID();
|
||||
if (!this.consumeBidRateLimit(socket)) {
|
||||
this.emitError(socket, BID_RATE_LIMIT_REJECTION_MESSAGE);
|
||||
ack?.({
|
||||
bidRequestId,
|
||||
code: BID_RATE_LIMIT_REJECTION_CODE,
|
||||
message: BID_RATE_LIMIT_REJECTION_MESSAGE,
|
||||
rejected: true,
|
||||
});
|
||||
return;
|
||||
}
|
||||
|
||||
try {
|
||||
const auction = await this.auctionService.placeBid({
|
||||
matchId: new mongoose.Types.ObjectId(matchId),
|
||||
teamIndex: payload.teamIndex,
|
||||
amount: payload.amount,
|
||||
bidderUserId,
|
||||
teamIndex: payload.bidderTeamIndex,
|
||||
amount: payload.bidPointAmount,
|
||||
bidRequestId,
|
||||
clientObservedAuctionLifecycleId:
|
||||
payload.clientObservedAuctionLifecycleId,
|
||||
clientObservedCurrentBidRoundPlayerUserId:
|
||||
payload.clientObservedCurrentBidRoundPlayerUserId,
|
||||
});
|
||||
const bidDelta = this.buildBidDeltaFromAuctionState(
|
||||
auction,
|
||||
bidRequestId,
|
||||
);
|
||||
if (bidDelta) {
|
||||
this.broadcastBid(matchId, bidDelta);
|
||||
} else {
|
||||
this.broadcastState(matchId, auction);
|
||||
}
|
||||
ack?.({
|
||||
ok: true,
|
||||
bidRequestId,
|
||||
state: this.serializeAuction(auction),
|
||||
});
|
||||
this.broadcastState(matchId, auction);
|
||||
} catch (error) {
|
||||
this.emitKnownError(socket, error);
|
||||
ack?.({
|
||||
bidRequestId,
|
||||
code: error instanceof Error ? error.message : 'UNKNOWN',
|
||||
rejected: true,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
@SubscribeMessage('open-bidding')
|
||||
public async handleOpenBidding(@ConnectedSocket() socket: Socket) {
|
||||
public async handleOpenBidding(
|
||||
@ConnectedSocket() socket: Socket,
|
||||
@MessageBody() payload: AuctionActionPayload,
|
||||
@Ack() ack?: (response: Record<string, unknown>) => void,
|
||||
) {
|
||||
const matchId = this.requireJoinedMatchId(socket);
|
||||
if (!matchId) return;
|
||||
|
||||
try {
|
||||
const auction = await this.auctionService.openBidding(
|
||||
new mongoose.Types.ObjectId(matchId),
|
||||
this.toAuctionActionRequest(payload),
|
||||
);
|
||||
this.broadcastState(matchId, auction);
|
||||
ack?.({
|
||||
auctionActionRequestId: payload?.auctionActionRequestId,
|
||||
ok: true,
|
||||
state: this.serializeAuction(auction),
|
||||
});
|
||||
} catch (error) {
|
||||
this.emitKnownError(socket, error);
|
||||
ack?.({
|
||||
auctionActionRequestId: payload?.auctionActionRequestId,
|
||||
code: error instanceof Error ? error.message : 'UNKNOWN',
|
||||
rejected: true,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
@@ -159,6 +230,7 @@ export class AuctionGateway
|
||||
public async handleSold(
|
||||
@ConnectedSocket() socket: Socket,
|
||||
@MessageBody() payload: SoldPayload,
|
||||
@Ack() ack?: (response: Record<string, unknown>) => void,
|
||||
) {
|
||||
const matchId = this.requireJoinedMatchId(socket);
|
||||
if (!matchId) return;
|
||||
@@ -167,25 +239,81 @@ export class AuctionGateway
|
||||
const auction = await this.auctionService.markSold({
|
||||
matchId: new mongoose.Types.ObjectId(matchId),
|
||||
assignedPosition: payload?.assignedPosition,
|
||||
...this.toAuctionActionRequest(payload),
|
||||
});
|
||||
this.broadcastState(matchId, auction);
|
||||
ack?.({
|
||||
auctionActionRequestId: payload?.auctionActionRequestId,
|
||||
ok: true,
|
||||
state: this.serializeAuction(auction),
|
||||
});
|
||||
} catch (error) {
|
||||
this.emitKnownError(socket, error);
|
||||
ack?.({
|
||||
auctionActionRequestId: payload?.auctionActionRequestId,
|
||||
code: error instanceof Error ? error.message : 'UNKNOWN',
|
||||
rejected: true,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
@SubscribeMessage('next')
|
||||
public async handleNext(@ConnectedSocket() socket: Socket) {
|
||||
public async handleNext(
|
||||
@ConnectedSocket() socket: Socket,
|
||||
@MessageBody() payload: AuctionActionPayload,
|
||||
@Ack() ack?: (response: Record<string, unknown>) => void,
|
||||
) {
|
||||
const matchId = this.requireJoinedMatchId(socket);
|
||||
if (!matchId) return;
|
||||
|
||||
try {
|
||||
const auction = await this.auctionService.next(
|
||||
new mongoose.Types.ObjectId(matchId),
|
||||
this.toAuctionActionRequest(payload),
|
||||
);
|
||||
this.broadcastState(matchId, auction);
|
||||
ack?.({
|
||||
auctionActionRequestId: payload?.auctionActionRequestId,
|
||||
ok: true,
|
||||
state: this.serializeAuction(auction),
|
||||
});
|
||||
} catch (error) {
|
||||
this.emitKnownError(socket, error);
|
||||
ack?.({
|
||||
auctionActionRequestId: payload?.auctionActionRequestId,
|
||||
code: error instanceof Error ? error.message : 'UNKNOWN',
|
||||
rejected: true,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
@SubscribeMessage('passed')
|
||||
public async handlePassed(
|
||||
@ConnectedSocket() socket: Socket,
|
||||
@MessageBody() payload: AuctionActionPayload,
|
||||
@Ack() ack?: (response: Record<string, unknown>) => void,
|
||||
) {
|
||||
const matchId = this.requireJoinedMatchId(socket);
|
||||
if (!matchId) return;
|
||||
|
||||
try {
|
||||
const auction = await this.auctionService.markPassed(
|
||||
new mongoose.Types.ObjectId(matchId),
|
||||
this.toAuctionActionRequest(payload),
|
||||
);
|
||||
this.broadcastState(matchId, auction);
|
||||
ack?.({
|
||||
auctionActionRequestId: payload?.auctionActionRequestId,
|
||||
ok: true,
|
||||
state: this.serializeAuction(auction),
|
||||
});
|
||||
} catch (error) {
|
||||
this.emitKnownError(socket, error);
|
||||
ack?.({
|
||||
auctionActionRequestId: payload?.auctionActionRequestId,
|
||||
code: error instanceof Error ? error.message : 'UNKNOWN',
|
||||
rejected: true,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
@@ -226,24 +354,45 @@ export class AuctionGateway
|
||||
return matchId;
|
||||
}
|
||||
|
||||
private consumeBidRateLimit(socket: Socket): boolean {
|
||||
const currentTimestampMS = Date.now();
|
||||
const previousState = socket.data
|
||||
.auctionBidRateLimit as BidRateLimitState | undefined;
|
||||
if (
|
||||
!previousState ||
|
||||
currentTimestampMS - previousState.windowStartedAtTimestampMS >=
|
||||
BID_RATE_LIMIT_WINDOW_MS
|
||||
) {
|
||||
socket.data.auctionBidRateLimit = {
|
||||
count: 1,
|
||||
windowStartedAtTimestampMS: currentTimestampMS,
|
||||
};
|
||||
return true;
|
||||
}
|
||||
|
||||
previousState.count += 1;
|
||||
socket.data.auctionBidRateLimit = previousState;
|
||||
return previousState.count <= BID_RATE_LIMIT_MAX_REQUESTS_PER_WINDOW;
|
||||
}
|
||||
|
||||
private getSocketMatchId(socket: Socket): string | undefined {
|
||||
return typeof socket.data.matchId === 'string'
|
||||
? socket.data.matchId
|
||||
: undefined;
|
||||
}
|
||||
|
||||
private resolveBidderUserId(
|
||||
socket: Socket,
|
||||
payloadBidderUserId?: string,
|
||||
): mongoose.Types.ObjectId | undefined {
|
||||
const candidate =
|
||||
payloadBidderUserId ??
|
||||
(socket.data.user as UserDocument | undefined)?._id.toString() ??
|
||||
this.readHandshakeUserId(socket);
|
||||
if (!candidate || !mongoose.isValidObjectId(candidate)) {
|
||||
return undefined;
|
||||
}
|
||||
return new mongoose.Types.ObjectId(candidate);
|
||||
private toAuctionActionRequest(payload?: AuctionActionPayload) {
|
||||
return {
|
||||
auctionActionRequestId: payload?.auctionActionRequestId,
|
||||
clientObservedAuctionLifecycleId:
|
||||
payload?.clientObservedAuctionLifecycleId,
|
||||
clientObservedCurrentAuctionPlayerOrderIndex:
|
||||
payload?.clientObservedCurrentAuctionPlayerOrderIndex,
|
||||
clientObservedCurrentBidRoundPlayerUserId:
|
||||
payload?.clientObservedCurrentBidRoundPlayerUserId,
|
||||
clientObservedPhase: payload?.clientObservedPhase,
|
||||
clientObservedRevision: payload?.clientObservedRevision,
|
||||
};
|
||||
}
|
||||
|
||||
private readHandshakeUserId(socket: Socket): string | undefined {
|
||||
@@ -359,16 +508,25 @@ export class AuctionGateway
|
||||
return typeof value === 'string' && value.length > 0 ? value : undefined;
|
||||
}
|
||||
|
||||
public broadcastState(matchId: string, auction: AuctionDocument) {
|
||||
public broadcastState(matchId: string, auction: AuctionStateResponse) {
|
||||
this.server.to(matchId).emit('state', this.serializeAuction(auction));
|
||||
this.syncRoomTimer(matchId, auction);
|
||||
}
|
||||
|
||||
public broadcastBid(matchId: string, delta: Record<string, unknown>) {
|
||||
this.server.to(matchId).emit('bid', delta);
|
||||
}
|
||||
|
||||
public broadcastReset(matchId: string) {
|
||||
this.clearRoomTimer(matchId);
|
||||
this.server.to(matchId).emit('reset', { matchId });
|
||||
}
|
||||
|
||||
public broadcastMatchSideEffect(
|
||||
matchId: string,
|
||||
delta: MatchSideEffectDelta,
|
||||
) {
|
||||
this.server.to(matchId).emit('match-side-effect', delta);
|
||||
}
|
||||
|
||||
private emitChatHistory(socket: Socket, auction: AuctionDocument) {
|
||||
socket.emit('chat-history', {
|
||||
messages: (auction.chatMessages ?? []).map((message) =>
|
||||
@@ -377,90 +535,91 @@ export class AuctionGateway
|
||||
});
|
||||
}
|
||||
|
||||
private syncRoomTimer(matchId: string, auction: AuctionDocument) {
|
||||
this.clearRoomTimer(matchId);
|
||||
if (!auction.currentDeadline) return;
|
||||
|
||||
const deadline = auction.currentDeadline;
|
||||
const deadlineIso = deadline.toISOString();
|
||||
if (Date.now() >= deadline.getTime()) {
|
||||
void this.handleDeadlineExpiry(matchId);
|
||||
return;
|
||||
}
|
||||
this.server.to(matchId).emit('tick', {
|
||||
deadline: deadlineIso,
|
||||
serverTime: new Date().toISOString(),
|
||||
});
|
||||
|
||||
const timer = setInterval(() => {
|
||||
this.server.to(matchId).emit('tick', {
|
||||
deadline: deadlineIso,
|
||||
serverTime: new Date().toISOString(),
|
||||
});
|
||||
|
||||
if (Date.now() >= deadline.getTime()) {
|
||||
this.clearRoomTimer(matchId);
|
||||
void this.handleDeadlineExpiry(matchId);
|
||||
}
|
||||
}, 1000);
|
||||
|
||||
this.roomTimers.set(matchId, timer);
|
||||
}
|
||||
|
||||
private async handleDeadlineExpiry(matchIdStr: string) {
|
||||
const matchId = new mongoose.Types.ObjectId(matchIdStr);
|
||||
const auction = await this.auctionService
|
||||
.getByMatchId(matchId)
|
||||
.catch(() => null);
|
||||
if (!auction || auction.phase !== 'bidding') return;
|
||||
if (!auction.currentDeadline || auction.currentDeadline.getTime() > Date.now()) {
|
||||
return;
|
||||
}
|
||||
|
||||
try {
|
||||
const nextAuction =
|
||||
auction.currentBid > 0
|
||||
? await this.auctionService.markSold({ matchId })
|
||||
: await this.auctionService.markPassed(matchId);
|
||||
this.broadcastState(matchIdStr, nextAuction);
|
||||
} catch (error) {
|
||||
this.emitKnownErrorToRoom(matchIdStr, error);
|
||||
}
|
||||
}
|
||||
|
||||
private maybeClearRoomTimer(matchId: string) {
|
||||
const room = this.server.adapter.rooms.get(matchId);
|
||||
if (room && room.size > 0) return;
|
||||
this.clearRoomTimer(matchId);
|
||||
}
|
||||
|
||||
private clearRoomTimer(matchId: string) {
|
||||
const timer = this.roomTimers.get(matchId);
|
||||
if (!timer) return;
|
||||
clearInterval(timer);
|
||||
this.roomTimers.delete(matchId);
|
||||
}
|
||||
|
||||
private emitKnownError(socket: Socket, error: unknown) {
|
||||
const message =
|
||||
error instanceof Error ? error.message : 'Unexpected auction gateway error.';
|
||||
this.emitError(socket, message);
|
||||
}
|
||||
|
||||
private emitKnownErrorToRoom(matchId: string, error: unknown) {
|
||||
const message =
|
||||
error instanceof Error ? error.message : 'Unexpected auction gateway error.';
|
||||
this.server.to(matchId).emit('error', { message });
|
||||
}
|
||||
|
||||
private emitError(socket: Socket, message: string) {
|
||||
socket.emit('error', { message });
|
||||
}
|
||||
|
||||
private serializeAuction(auction: AuctionDocument) {
|
||||
private serializeAuction(auction: AuctionStateResponse) {
|
||||
return JSON.parse(JSON.stringify(auction));
|
||||
}
|
||||
|
||||
private buildBidDeltaFromAuctionState(
|
||||
auction: AuctionStateResponse,
|
||||
bidRequestId?: string,
|
||||
): Record<string, unknown> | null {
|
||||
const serialized = this.serializeAuction(auction) as Record<string, unknown>;
|
||||
const revision = Number(serialized.revision);
|
||||
const currentHighestBidPointAmount = Number(
|
||||
serialized.currentHighestBidPointAmount ?? serialized.currentBid,
|
||||
);
|
||||
const currentHighestBidderTeamIndex = Number(
|
||||
serialized.currentHighestBidderTeamIndex ??
|
||||
serialized.currentBidderTeamIndex,
|
||||
);
|
||||
const currentBidRoundDeadlineTimestampMS = Number(
|
||||
serialized.currentBidRoundDeadlineTimestampMS ??
|
||||
(typeof serialized.currentDeadline === 'string'
|
||||
? Date.parse(serialized.currentDeadline)
|
||||
: 0),
|
||||
);
|
||||
const redisBidHistory = Array.isArray(serialized.auctionBidHistory)
|
||||
? serialized.auctionBidHistory
|
||||
: [];
|
||||
const legacyBidHistory = Array.isArray(serialized.bids)
|
||||
? serialized.bids
|
||||
: [];
|
||||
const auctionBidHistoryEntry =
|
||||
redisBidHistory[redisBidHistory.length - 1] ??
|
||||
this.convertLegacyBidToRedisBidHistoryEntry(
|
||||
legacyBidHistory[legacyBidHistory.length - 1],
|
||||
);
|
||||
|
||||
if (
|
||||
!Number.isFinite(currentHighestBidPointAmount) ||
|
||||
!Number.isFinite(currentHighestBidderTeamIndex) ||
|
||||
!auctionBidHistoryEntry
|
||||
) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return {
|
||||
auctionBidHistoryEntry,
|
||||
auctionLifecycleId: serialized.auctionLifecycleId,
|
||||
bidRequestId,
|
||||
currentBidRoundDeadlineTimestampMS: Number.isFinite(
|
||||
currentBidRoundDeadlineTimestampMS,
|
||||
)
|
||||
? currentBidRoundDeadlineTimestampMS
|
||||
: undefined,
|
||||
currentHighestBidPointAmount,
|
||||
currentHighestBidderTeamIndex,
|
||||
currentServerTimestampMS: serialized.currentServerTimestampMS,
|
||||
revision: Number.isFinite(revision) ? revision : undefined,
|
||||
};
|
||||
}
|
||||
|
||||
private convertLegacyBidToRedisBidHistoryEntry(
|
||||
bid: unknown,
|
||||
): Record<string, unknown> | null {
|
||||
if (!bid || typeof bid !== 'object') return null;
|
||||
const record = bid as Record<string, unknown>;
|
||||
return {
|
||||
bidderTeamIndex: record.teamIndex,
|
||||
bidPointAmount: record.amount,
|
||||
bidderUserId: record.bidderUserId,
|
||||
bidPlacedAtTimestampMS:
|
||||
typeof record.timestamp === 'string'
|
||||
? Date.parse(record.timestamp)
|
||||
: undefined,
|
||||
};
|
||||
}
|
||||
|
||||
private serializeChatMessage(message: AuctionChatMessage) {
|
||||
return JSON.parse(JSON.stringify(message));
|
||||
}
|
||||
|
||||
@@ -4,12 +4,29 @@ import { TournamentCodeModule } from '../tournament-code/tournament-code.module'
|
||||
import { TournamentResultModule } from '../tournament-result/tournament-result.module';
|
||||
import { AuctionGateway } from './auction.gateway';
|
||||
import { AuctionController } from './auction.controller';
|
||||
import { AuctionDeadlineScheduler } from './auction-deadline.scheduler';
|
||||
import { AuctionDurabilityScheduler } from './auction-durability.scheduler';
|
||||
import { AuctionEventBusService } from './auction-event-bus.service';
|
||||
import { AuctionRedisModule } from './redis/auction-redis.module';
|
||||
import { AuctionSideEffectService } from './auction-side-effect.service';
|
||||
import { AuctionService } from './auction.service';
|
||||
|
||||
@Module({
|
||||
imports: [RiotModule, TournamentCodeModule, TournamentResultModule],
|
||||
imports: [
|
||||
RiotModule,
|
||||
TournamentCodeModule,
|
||||
TournamentResultModule,
|
||||
AuctionRedisModule,
|
||||
],
|
||||
controllers: [AuctionController],
|
||||
providers: [AuctionService, AuctionGateway],
|
||||
providers: [
|
||||
AuctionService,
|
||||
AuctionGateway,
|
||||
AuctionEventBusService,
|
||||
AuctionDeadlineScheduler,
|
||||
AuctionDurabilityScheduler,
|
||||
AuctionSideEffectService,
|
||||
],
|
||||
exports: [AuctionService],
|
||||
})
|
||||
export class AuctionModule {}
|
||||
File diff suppressed because it is too large.
Load diff
File diff suppressed because it is too large.
Load diff
@@ -7,6 +7,8 @@ import {
|
||||
IsInt,
|
||||
IsMongoId,
|
||||
IsOptional,
|
||||
IsString,
|
||||
IsUUID,
|
||||
Max,
|
||||
Min,
|
||||
ValidateNested,
|
||||
@@ -28,10 +30,13 @@ class CaptainAssignmentDto {
|
||||
@IsInt()
|
||||
@Min(100)
|
||||
@Max(100000)
|
||||
initialPoints?: number;
|
||||
initialTeamBidPointAmount?: number;
|
||||
}
|
||||
|
||||
export class StartAuctionDto {
|
||||
@IsUUID()
|
||||
startAuctionRequestId!: string;
|
||||
|
||||
@IsArray()
|
||||
@ArrayMinSize(2)
|
||||
@ArrayMaxSize(16)
|
||||
@@ -43,50 +48,92 @@ export class StartAuctionDto {
|
||||
@IsInt()
|
||||
@Min(100)
|
||||
@Max(100000)
|
||||
initialPoints?: number;
|
||||
initialTeamBidPointAmount?: number;
|
||||
|
||||
@IsOptional()
|
||||
@IsEnum(AUCTION_TOP_TIER_THRESHOLDS)
|
||||
topTierThreshold?: AuctionTopTierThreshold;
|
||||
topTierAuctionPriorityThreshold?: AuctionTopTierThreshold;
|
||||
|
||||
@IsOptional()
|
||||
@IsArray()
|
||||
@ArrayMaxSize(100)
|
||||
@IsMongoId({ each: true })
|
||||
manualTopTierUserIds?: string[];
|
||||
manualTopTierAuctionPriorityUserIds?: string[];
|
||||
|
||||
@IsOptional()
|
||||
@IsInt()
|
||||
@Min(5)
|
||||
maxTimerSeconds?: number;
|
||||
maximumBidRoundDurationSeconds?: number;
|
||||
|
||||
@IsOptional()
|
||||
@IsInt()
|
||||
@Min(0)
|
||||
bidExtensionSeconds?: number;
|
||||
bidRoundExtensionSeconds?: number;
|
||||
}
|
||||
|
||||
export class PlaceBidDto {
|
||||
@IsInt()
|
||||
@Min(1)
|
||||
teamIndex!: number;
|
||||
@IsOptional()
|
||||
@IsUUID()
|
||||
bidRequestId?: string;
|
||||
|
||||
@IsInt()
|
||||
@Min(1)
|
||||
amount!: number;
|
||||
bidderTeamIndex!: number;
|
||||
|
||||
@IsInt()
|
||||
@Min(1)
|
||||
bidPointAmount!: number;
|
||||
|
||||
@IsOptional()
|
||||
@IsMongoId()
|
||||
bidderUserId?: string;
|
||||
clientObservedAuctionLifecycleId?: string;
|
||||
|
||||
@IsOptional()
|
||||
clientObservedCurrentBidRoundPlayerUserId?: string;
|
||||
}
|
||||
|
||||
export class SoldDto {
|
||||
export class AuctionActionRequestDto {
|
||||
@IsOptional()
|
||||
@IsUUID()
|
||||
auctionActionRequestId?: string;
|
||||
|
||||
@IsOptional()
|
||||
@IsString()
|
||||
clientObservedAuctionLifecycleId?: string;
|
||||
|
||||
@IsOptional()
|
||||
@IsInt()
|
||||
@Min(0)
|
||||
clientObservedRevision?: number;
|
||||
|
||||
@IsOptional()
|
||||
@IsString()
|
||||
clientObservedPhase?: string;
|
||||
|
||||
@IsOptional()
|
||||
@IsString()
|
||||
clientObservedCurrentBidRoundPlayerUserId?: string;
|
||||
|
||||
@IsOptional()
|
||||
@IsInt()
|
||||
@Min(0)
|
||||
clientObservedCurrentAuctionPlayerOrderIndex?: number;
|
||||
}
|
||||
|
||||
export class SoldDto extends AuctionActionRequestDto {
|
||||
@IsOptional()
|
||||
@IsEnum(['TOP', 'JGL', 'MID', 'ADC', 'SUP'])
|
||||
assignedPosition?: 'TOP' | 'JGL' | 'MID' | 'ADC' | 'SUP';
|
||||
}
|
||||
|
||||
export class UndoAuctionDto {
|
||||
export class OpenBiddingDto extends AuctionActionRequestDto {}
|
||||
|
||||
export class NextAuctionDto extends AuctionActionRequestDto {}
|
||||
|
||||
export class PassedAuctionDto extends AuctionActionRequestDto {}
|
||||
|
||||
export class ResetAuctionDto extends AuctionActionRequestDto {}
|
||||
|
||||
export class UndoAuctionDto extends AuctionActionRequestDto {
|
||||
@IsInt()
|
||||
@Min(1)
|
||||
sequence!: number;
|
||||
|
||||
@@ -0,0 +1,377 @@
|
||||
import { AuctionRedisService } from './auction-redis.service';
|
||||
import { AuctionRedisCommandService } from './auction-redis-command.service';
|
||||
import { AUCTION_APPLY_TRANSITION_SCRIPT } from './auction-redis.apply-transition';
|
||||
import { AUCTION_BID_SCRIPT } from './auction-redis.bid';
|
||||
import { AUCTION_EXPIRE_PREPARE_SCRIPT } from './auction-redis.expire-prepare';
|
||||
import { AUCTION_RESERVE_ACTION_REQUEST_SCRIPT } from './auction-redis.reserve-action';
|
||||
import { AUCTION_HYDRATE_STATE_SCRIPT } from './auction-redis.state';
|
||||
|
||||
function makeService(reply: unknown) {
|
||||
const auctionRedisService = {
|
||||
evalScript: jest.fn().mockResolvedValue(reply),
|
||||
} as unknown as jest.Mocked<AuctionRedisService>;
|
||||
return {
|
||||
auctionRedisService,
|
||||
service: new AuctionRedisCommandService(auctionRedisService),
|
||||
};
|
||||
}
|
||||
|
||||
describe('AuctionRedisCommandService', () => {
|
||||
it('executes BID script and parses successful reply', async () => {
|
||||
const { service, auctionRedisService } = makeService([
|
||||
'OK',
|
||||
'bid-1',
|
||||
'9',
|
||||
'1000',
|
||||
'120',
|
||||
'2',
|
||||
'31000',
|
||||
'{"bidPointAmount":120}',
|
||||
]);
|
||||
|
||||
await expect(
|
||||
service.placeBid('match-1', {
|
||||
bidderTeamIndex: 2,
|
||||
bidPointAmount: 120,
|
||||
bidRequestId: 'bid-1',
|
||||
bidderUserId: 'captain-2',
|
||||
clientObservedAuctionLifecycleId: 'life-1',
|
||||
clientObservedCurrentBidRoundPlayerUserId: 'player-1',
|
||||
maximumAuctionTeamMemberCount: 5,
|
||||
maximumStoredAuctionBidHistoryCount: 200,
|
||||
maximumStoredBidRequestResultCount: 100,
|
||||
matchId: 'match-1',
|
||||
minimumBidPointReservePerRemainingAuctionTeamMemberSlot: 10,
|
||||
minimumBidRequestResultReplayWindowMS: 60_000,
|
||||
}),
|
||||
).resolves.toEqual({
|
||||
auctionBidHistoryEntry: { bidPointAmount: 120 },
|
||||
bidRequestId: 'bid-1',
|
||||
currentHighestBidderTeamIndex: 2,
|
||||
currentHighestBidPointAmount: 120,
|
||||
currentBidRoundDeadlineTimestampMS: 31_000,
|
||||
currentServerTimestampMS: 1_000,
|
||||
ok: true,
|
||||
revision: 9,
|
||||
});
|
||||
expect(auctionRedisService.evalScript).toHaveBeenCalledWith(
|
||||
AUCTION_BID_SCRIPT,
|
||||
expect.arrayContaining(['auction:match-1:liveAuctionState']),
|
||||
expect.arrayContaining(['match-1', '2', '120']),
|
||||
);
|
||||
});
|
||||
|
||||
it('parses BID rejected reply', async () => {
|
||||
const { service } = makeService([
|
||||
'REJECTED',
|
||||
'TOO_LOW',
|
||||
'bid-1',
|
||||
'1000',
|
||||
]);
|
||||
|
||||
await expect(
|
||||
service.placeBid('match-1', {
|
||||
bidderTeamIndex: 2,
|
||||
bidPointAmount: 120,
|
||||
bidRequestId: 'bid-1',
|
||||
bidderUserId: 'captain-2',
|
||||
clientObservedAuctionLifecycleId: 'life-1',
|
||||
clientObservedCurrentBidRoundPlayerUserId: 'player-1',
|
||||
maximumAuctionTeamMemberCount: 5,
|
||||
maximumStoredAuctionBidHistoryCount: 200,
|
||||
maximumStoredBidRequestResultCount: 100,
|
||||
matchId: 'match-1',
|
||||
minimumBidPointReservePerRemainingAuctionTeamMemberSlot: 10,
|
||||
minimumBidRequestResultReplayWindowMS: 60_000,
|
||||
}),
|
||||
).resolves.toEqual({
|
||||
bidRequestId: 'bid-1',
|
||||
code: 'TOO_LOW',
|
||||
currentServerTimestampMS: 1000,
|
||||
rejected: true,
|
||||
});
|
||||
});
|
||||
|
||||
it('executes reserve action request and parses lease metadata', async () => {
|
||||
const { service, auctionRedisService } = makeService([
|
||||
'RESERVED',
|
||||
'life-1:request-1',
|
||||
'transition-1',
|
||||
'',
|
||||
'2',
|
||||
'1',
|
||||
'1000',
|
||||
]);
|
||||
|
||||
await expect(
|
||||
service.reserveActionRequest('match-1', {
|
||||
auctionActionRequestId: 'request-1',
|
||||
auctionActionType: 'sold',
|
||||
auctionStateTransitionId: 'transition-1',
|
||||
clientObservedAuctionLifecycleId: 'life-1',
|
||||
clientObservedPhase: 'bidding',
|
||||
clientObservedRevision: 8,
|
||||
leaseDurationMS: 10_000,
|
||||
maximumStoredAuctionActionRequestResultCount: 100,
|
||||
minimumAuctionActionRequestResultReplayWindowMS: 60_000,
|
||||
processingOwnerToken: 'owner-1',
|
||||
}),
|
||||
).resolves.toEqual({
|
||||
actionRequestScopeKey: 'life-1:request-1',
|
||||
auctionStateTransitionId: 'transition-1',
|
||||
currentServerTimestampMS: 1000,
|
||||
newAuctionLifecycleId: '',
|
||||
observedProcessingLeaseVersion: 2,
|
||||
reserved: true,
|
||||
wasLeaseExpired: true,
|
||||
});
|
||||
expect(auctionRedisService.evalScript).toHaveBeenCalledWith(
|
||||
AUCTION_RESERVE_ACTION_REQUEST_SCRIPT,
|
||||
expect.arrayContaining(['auction:match-1:auctionActionRequestResults']),
|
||||
expect.arrayContaining(['life-1', 'request-1', 'sold']),
|
||||
);
|
||||
});
|
||||
|
||||
it('parses reserve action request replay refetch metadata', async () => {
|
||||
const { service } = makeService([
|
||||
'REPLAY',
|
||||
'applied',
|
||||
'life-1:request-1',
|
||||
'11',
|
||||
'',
|
||||
'transition-1',
|
||||
'',
|
||||
'2',
|
||||
'3000',
|
||||
'',
|
||||
'1',
|
||||
]);
|
||||
|
||||
await expect(
|
||||
service.reserveActionRequest('match-1', {
|
||||
auctionActionRequestId: 'request-1',
|
||||
auctionActionType: 'sold',
|
||||
auctionStateTransitionId: 'transition-1',
|
||||
clientObservedAuctionLifecycleId: 'life-1',
|
||||
clientObservedPhase: 'bidding',
|
||||
clientObservedRevision: 8,
|
||||
leaseDurationMS: 10_000,
|
||||
maximumStoredAuctionActionRequestResultCount: 100,
|
||||
minimumAuctionActionRequestResultReplayWindowMS: 60_000,
|
||||
processingOwnerToken: 'owner-1',
|
||||
}),
|
||||
).resolves.toEqual({
|
||||
actionRequestScopeKey: 'life-1:request-1',
|
||||
currentServerTimestampMS: 3000,
|
||||
isReplay: true,
|
||||
requiresRefetch: true,
|
||||
replayStatus: 'applied',
|
||||
revision: 11,
|
||||
});
|
||||
});
|
||||
|
||||
it('executes apply transition and parses successful reply', async () => {
|
||||
const { service, auctionRedisService } = makeService([
|
||||
'OK',
|
||||
'transition-1',
|
||||
'11',
|
||||
'2000',
|
||||
]);
|
||||
|
||||
await expect(
|
||||
service.applyTransition('match-1', {
|
||||
afterAuctionStructureStateJson: '{"auctionTeams":[]}',
|
||||
auctionHistorySequence: 5,
|
||||
auctionLifecycleId: 'life-1',
|
||||
auctionStateTransitionId: 'transition-1',
|
||||
broadcastStateRevision: 11,
|
||||
deadline: { mode: 'remove' },
|
||||
durabilityPayloadJson: '{"auctionStateTransitionId":"transition-1"}',
|
||||
expectedPhase: 'bidding',
|
||||
expectedRevision: 10,
|
||||
liveStatePatch: { phase: 'sold' },
|
||||
matchId: 'match-1',
|
||||
shouldBroadcastState: true,
|
||||
}),
|
||||
).resolves.toEqual({
|
||||
auctionStateTransitionId: 'transition-1',
|
||||
currentServerTimestampMS: 2000,
|
||||
ok: true,
|
||||
revision: 11,
|
||||
});
|
||||
expect(auctionRedisService.evalScript).toHaveBeenCalledWith(
|
||||
AUCTION_APPLY_TRANSITION_SCRIPT,
|
||||
expect.arrayContaining(['auction:match-1:liveAuctionState']),
|
||||
expect.arrayContaining(['match-1', 'life-1', 'transition-1']),
|
||||
);
|
||||
});
|
||||
|
||||
it('parses apply transition replay and rejected replies', async () => {
|
||||
await expect(
|
||||
makeService(['REPLAY', 'APPLIED', 'transition-1', '2100'])
|
||||
.service.applyTransition('match-1', {
|
||||
afterAuctionStructureStateJson: '{}',
|
||||
auctionHistorySequence: 5,
|
||||
auctionLifecycleId: 'life-1',
|
||||
auctionStateTransitionId: 'transition-1',
|
||||
broadcastStateRevision: 11,
|
||||
deadline: { mode: 'none' },
|
||||
durabilityPayloadJson: '{}',
|
||||
expectedPhase: 'sold',
|
||||
expectedRevision: 10,
|
||||
liveStatePatch: {},
|
||||
matchId: 'match-1',
|
||||
shouldBroadcastState: false,
|
||||
}),
|
||||
).resolves.toEqual({
|
||||
auctionStateTransitionId: 'transition-1',
|
||||
currentServerTimestampMS: 2100,
|
||||
isReplay: true,
|
||||
replayStatus: 'APPLIED',
|
||||
});
|
||||
|
||||
await expect(
|
||||
makeService(['REJECTED', 'CONFLICT', 'transition-1', '2200'])
|
||||
.service.applyTransition('match-1', {
|
||||
afterAuctionStructureStateJson: '{}',
|
||||
auctionHistorySequence: 5,
|
||||
auctionLifecycleId: 'life-1',
|
||||
auctionStateTransitionId: 'transition-1',
|
||||
broadcastStateRevision: 11,
|
||||
deadline: { mode: 'none' },
|
||||
durabilityPayloadJson: '{}',
|
||||
expectedPhase: 'sold',
|
||||
expectedRevision: 10,
|
||||
liveStatePatch: {},
|
||||
matchId: 'match-1',
|
||||
shouldBroadcastState: false,
|
||||
}),
|
||||
).resolves.toEqual({
|
||||
auctionStateTransitionId: 'transition-1',
|
||||
code: 'CONFLICT',
|
||||
currentServerTimestampMS: 2200,
|
||||
rejected: true,
|
||||
});
|
||||
});
|
||||
|
||||
it('executes expire prepare and parses expiry decisions', async () => {
|
||||
const { service, auctionRedisService } = makeService([
|
||||
'OK',
|
||||
'sold',
|
||||
'expire-1',
|
||||
'12',
|
||||
'3000',
|
||||
]);
|
||||
|
||||
await expect(
|
||||
service.expirePrepare('match-1', {
|
||||
auctionStateTransitionId: 'expire-1',
|
||||
bidRoundExpiryRetryDelayMS: 3000,
|
||||
matchId: 'match-1',
|
||||
}),
|
||||
).resolves.toEqual({
|
||||
auctionStateTransitionId: 'expire-1',
|
||||
bidRoundExpiryDecision: 'sold',
|
||||
currentServerTimestampMS: 3000,
|
||||
isReplay: undefined,
|
||||
ok: true,
|
||||
revision: 12,
|
||||
});
|
||||
expect(auctionRedisService.evalScript).toHaveBeenCalledWith(
|
||||
AUCTION_EXPIRE_PREPARE_SCRIPT,
|
||||
expect.arrayContaining(['auction:match-1:liveAuctionState']),
|
||||
expect.arrayContaining(['match-1', 'expire-1']),
|
||||
);
|
||||
});
|
||||
|
||||
it('parses expire prepare replay and noop replies', async () => {
|
||||
await expect(
|
||||
makeService(['REPLAY', 'passed', 'expire-1', '12', '3100'])
|
||||
.service.expirePrepare('match-1', {
|
||||
auctionStateTransitionId: 'expire-1',
|
||||
bidRoundExpiryRetryDelayMS: 3000,
|
||||
matchId: 'match-1',
|
||||
}),
|
||||
).resolves.toMatchObject({
|
||||
auctionStateTransitionId: 'expire-1',
|
||||
bidRoundExpiryDecision: 'passed',
|
||||
currentServerTimestampMS: 3100,
|
||||
isReplay: true,
|
||||
ok: true,
|
||||
revision: 12,
|
||||
});
|
||||
|
||||
await expect(
|
||||
makeService(['NOOP', 'NOT_DUE', '3200']).service.expirePrepare(
|
||||
'match-1',
|
||||
{
|
||||
auctionStateTransitionId: 'expire-1',
|
||||
bidRoundExpiryRetryDelayMS: 3000,
|
||||
matchId: 'match-1',
|
||||
},
|
||||
),
|
||||
).resolves.toEqual({
|
||||
code: 'NOT_DUE',
|
||||
currentServerTimestampMS: 3200,
|
||||
noop: true,
|
||||
});
|
||||
});
|
||||
|
||||
it('executes hydrate state and parses hydrate/noop replies', async () => {
|
||||
const { service, auctionRedisService } = makeService(['OK', '7', '4000']);
|
||||
|
||||
await expect(
|
||||
service.hydrateState('match-1', {
|
||||
auctionHistorySequence: 3,
|
||||
auctionLifecycleId: 'life-1',
|
||||
maximumBidRoundDurationSeconds: 30,
|
||||
matchId: 'match-1',
|
||||
phase: 'presenting',
|
||||
revision: 6,
|
||||
structureStateJson: '{"auctionTeams":[]}',
|
||||
}),
|
||||
).resolves.toEqual({
|
||||
currentServerTimestampMS: 4000,
|
||||
hydrated: true,
|
||||
revision: 7,
|
||||
});
|
||||
expect(auctionRedisService.evalScript).toHaveBeenCalledWith(
|
||||
AUCTION_HYDRATE_STATE_SCRIPT,
|
||||
expect.arrayContaining(['auction:match-1:liveAuctionState']),
|
||||
expect.arrayContaining(['match-1', 'life-1', '6']),
|
||||
);
|
||||
|
||||
await expect(
|
||||
makeService(['NOOP', '8', '4100']).service.hydrateState('match-1', {
|
||||
auctionHistorySequence: 3,
|
||||
auctionLifecycleId: 'life-1',
|
||||
maximumBidRoundDurationSeconds: 30,
|
||||
matchId: 'match-1',
|
||||
phase: 'presenting',
|
||||
revision: 6,
|
||||
structureStateJson: '{}',
|
||||
}),
|
||||
).resolves.toEqual({
|
||||
currentServerTimestampMS: 4100,
|
||||
noop: true,
|
||||
revision: 8,
|
||||
});
|
||||
|
||||
await expect(
|
||||
makeService(['REJECTED', 'INVALID_PATCH_ARITY', '4200'])
|
||||
.service.hydrateState('match-1', {
|
||||
auctionHistorySequence: 3,
|
||||
auctionLifecycleId: 'life-1',
|
||||
maximumBidRoundDurationSeconds: 30,
|
||||
matchId: 'match-1',
|
||||
phase: 'presenting',
|
||||
revision: 6,
|
||||
structureStateJson: '{}',
|
||||
}),
|
||||
).resolves.toEqual({
|
||||
code: 'INVALID_PATCH_ARITY',
|
||||
currentServerTimestampMS: 4200,
|
||||
rejected: true,
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,375 @@
|
||||
import { Injectable } from '@nestjs/common';
|
||||
import {
|
||||
type AuctionApplyTransitionScriptInput,
|
||||
buildAuctionApplyTransitionScriptInvocation,
|
||||
} from './auction-redis.apply-transition';
|
||||
import {
|
||||
type AuctionBidScriptInput,
|
||||
buildAuctionBidScriptInvocation,
|
||||
} from './auction-redis.bid';
|
||||
import {
|
||||
type AuctionExpirePrepareScriptInput,
|
||||
buildAuctionExpirePrepareScriptInvocation,
|
||||
} from './auction-redis.expire-prepare';
|
||||
import { buildAuctionRedisKeys } from './auction-redis.keys';
|
||||
import { AuctionRedisService } from './auction-redis.service';
|
||||
import {
|
||||
type AuctionReserveActionRequestScriptInput,
|
||||
buildAuctionReserveActionRequestScriptInvocation,
|
||||
} from './auction-redis.reserve-action';
|
||||
import {
|
||||
type HydrateAuctionStateScriptInput,
|
||||
buildHydrateAuctionStateScriptInvocation,
|
||||
} from './auction-redis.state';
|
||||
|
||||
export type AuctionBidCommandResult =
|
||||
| {
|
||||
auctionBidHistoryEntry: Record<string, unknown>;
|
||||
bidRequestId: string;
|
||||
currentBidRoundDeadlineTimestampMS: number;
|
||||
currentHighestBidderTeamIndex: number;
|
||||
currentHighestBidPointAmount: number;
|
||||
currentServerTimestampMS: number;
|
||||
isReplay?: boolean;
|
||||
ok: true;
|
||||
revision: number;
|
||||
}
|
||||
| {
|
||||
bidRequestId: string;
|
||||
code: string;
|
||||
currentServerTimestampMS: number;
|
||||
isReplay?: boolean;
|
||||
rejected: true;
|
||||
};
|
||||
|
||||
export type AuctionReserveActionRequestCommandResult =
|
||||
| {
|
||||
actionRequestScopeKey: string;
|
||||
auctionStateTransitionId: string;
|
||||
currentServerTimestampMS: number;
|
||||
newAuctionLifecycleId: string;
|
||||
observedProcessingLeaseVersion: number;
|
||||
reserved: true;
|
||||
wasLeaseExpired: boolean;
|
||||
}
|
||||
| {
|
||||
actionRequestScopeKey: string;
|
||||
code: string;
|
||||
currentServerTimestampMS: number;
|
||||
rejected: true;
|
||||
}
|
||||
| {
|
||||
actionRequestScopeKey: string;
|
||||
currentServerTimestampMS: number;
|
||||
isReplay: true;
|
||||
requiresRefetch?: boolean;
|
||||
replayStatus: string;
|
||||
responseJson?: string;
|
||||
revision?: number;
|
||||
};
|
||||
|
||||
export type AuctionApplyTransitionCommandResult =
|
||||
| {
|
||||
auctionStateTransitionId: string;
|
||||
currentServerTimestampMS: number;
|
||||
ok: true;
|
||||
revision: number;
|
||||
}
|
||||
| {
|
||||
auctionStateTransitionId: string;
|
||||
currentServerTimestampMS: number;
|
||||
isReplay: true;
|
||||
replayStatus: string;
|
||||
}
|
||||
| {
|
||||
auctionStateTransitionId: string;
|
||||
code: string;
|
||||
currentServerTimestampMS: number;
|
||||
rejected: true;
|
||||
};
|
||||
|
||||
export type AuctionExpirePrepareCommandResult =
|
||||
| {
|
||||
auctionStateTransitionId: string;
|
||||
bidRoundExpiryDecision: 'passed' | 'sold';
|
||||
currentServerTimestampMS: number;
|
||||
isReplay?: boolean;
|
||||
ok: true;
|
||||
revision: number;
|
||||
}
|
||||
| {
|
||||
code: string;
|
||||
currentServerTimestampMS: number;
|
||||
noop: true;
|
||||
};
|
||||
|
||||
export type AuctionHydrateStateCommandResult =
|
||||
| {
|
||||
currentServerTimestampMS: number;
|
||||
hydrated: true;
|
||||
revision: number;
|
||||
}
|
||||
| {
|
||||
currentServerTimestampMS: number;
|
||||
noop: true;
|
||||
revision: number;
|
||||
}
|
||||
| {
|
||||
code: string;
|
||||
currentServerTimestampMS: number;
|
||||
rejected: true;
|
||||
};
|
||||
|
||||
@Injectable()
|
||||
export class AuctionRedisCommandService {
|
||||
constructor(private readonly auctionRedisService: AuctionRedisService) {}
|
||||
|
||||
public async placeBid(
|
||||
matchId: string,
|
||||
input: AuctionBidScriptInput,
|
||||
): Promise<AuctionBidCommandResult> {
|
||||
const invocation = buildAuctionBidScriptInvocation(
|
||||
buildAuctionRedisKeys(matchId),
|
||||
input,
|
||||
);
|
||||
const reply = await this.auctionRedisService.evalScript<unknown[]>(
|
||||
invocation.script,
|
||||
invocation.keys,
|
||||
invocation.values,
|
||||
);
|
||||
return parseBidCommandReply(reply);
|
||||
}
|
||||
|
||||
public async reserveActionRequest(
|
||||
matchId: string,
|
||||
input: AuctionReserveActionRequestScriptInput,
|
||||
): Promise<AuctionReserveActionRequestCommandResult> {
|
||||
const invocation = buildAuctionReserveActionRequestScriptInvocation(
|
||||
buildAuctionRedisKeys(matchId),
|
||||
input,
|
||||
);
|
||||
const reply = await this.auctionRedisService.evalScript<unknown[]>(
|
||||
invocation.script,
|
||||
invocation.keys,
|
||||
invocation.values,
|
||||
);
|
||||
return parseReserveActionRequestReply(reply);
|
||||
}
|
||||
|
||||
public async applyTransition(
|
||||
matchId: string,
|
||||
input: AuctionApplyTransitionScriptInput,
|
||||
): Promise<AuctionApplyTransitionCommandResult> {
|
||||
const invocation = buildAuctionApplyTransitionScriptInvocation(
|
||||
buildAuctionRedisKeys(matchId),
|
||||
input,
|
||||
);
|
||||
const reply = await this.auctionRedisService.evalScript<unknown[]>(
|
||||
invocation.script,
|
||||
invocation.keys,
|
||||
invocation.values,
|
||||
);
|
||||
return parseApplyTransitionReply(reply);
|
||||
}
|
||||
|
||||
public async expirePrepare(
|
||||
matchId: string,
|
||||
input: AuctionExpirePrepareScriptInput,
|
||||
): Promise<AuctionExpirePrepareCommandResult> {
|
||||
const invocation = buildAuctionExpirePrepareScriptInvocation(
|
||||
buildAuctionRedisKeys(matchId),
|
||||
input,
|
||||
);
|
||||
const reply = await this.auctionRedisService.evalScript<unknown[]>(
|
||||
invocation.script,
|
||||
invocation.keys,
|
||||
invocation.values,
|
||||
);
|
||||
return parseExpirePrepareReply(reply);
|
||||
}
|
||||
|
||||
public async hydrateState(
|
||||
matchId: string,
|
||||
input: HydrateAuctionStateScriptInput,
|
||||
): Promise<AuctionHydrateStateCommandResult> {
|
||||
const invocation = buildHydrateAuctionStateScriptInvocation(
|
||||
buildAuctionRedisKeys(matchId),
|
||||
input,
|
||||
);
|
||||
const reply = await this.auctionRedisService.evalScript<unknown[]>(
|
||||
invocation.script,
|
||||
invocation.keys,
|
||||
invocation.values,
|
||||
);
|
||||
return parseHydrateStateReply(reply);
|
||||
}
|
||||
}
|
||||
|
||||
function parseBidCommandReply(reply: unknown[]): AuctionBidCommandResult {
|
||||
const values = reply.map(String);
|
||||
const kind = values[0];
|
||||
if (kind === 'OK') {
|
||||
return {
|
||||
auctionBidHistoryEntry: JSON.parse(values[7] || '{}') as Record<
|
||||
string,
|
||||
unknown
|
||||
>,
|
||||
bidRequestId: values[1],
|
||||
currentBidRoundDeadlineTimestampMS: numberValue(values[6]),
|
||||
currentHighestBidderTeamIndex: numberValue(values[5]),
|
||||
currentHighestBidPointAmount: numberValue(values[4]),
|
||||
currentServerTimestampMS: numberValue(values[3]),
|
||||
ok: true,
|
||||
revision: numberValue(values[2]),
|
||||
};
|
||||
}
|
||||
if (kind === 'REPLAY') {
|
||||
const status = values[1];
|
||||
if (status === 'ok') {
|
||||
return {
|
||||
auctionBidHistoryEntry: JSON.parse(values[8] || '{}') as Record<
|
||||
string,
|
||||
unknown
|
||||
>,
|
||||
bidRequestId: values[2],
|
||||
currentBidRoundDeadlineTimestampMS: numberValue(values[7]),
|
||||
currentHighestBidderTeamIndex: numberValue(values[6]),
|
||||
currentHighestBidPointAmount: numberValue(values[5]),
|
||||
currentServerTimestampMS: numberValue(values[9]),
|
||||
isReplay: true,
|
||||
ok: true,
|
||||
revision: numberValue(values[3]),
|
||||
};
|
||||
}
|
||||
return {
|
||||
bidRequestId: values[2],
|
||||
code: values[4] || status,
|
||||
currentServerTimestampMS: numberValue(values[9]),
|
||||
isReplay: true,
|
||||
rejected: true,
|
||||
};
|
||||
}
|
||||
return {
|
||||
bidRequestId: values[2] ?? '',
|
||||
code: values[1] ?? 'UNKNOWN',
|
||||
currentServerTimestampMS: numberValue(values[3]),
|
||||
rejected: true,
|
||||
};
|
||||
}
|
||||
|
||||
function parseReserveActionRequestReply(
|
||||
reply: unknown[],
|
||||
): AuctionReserveActionRequestCommandResult {
|
||||
const values = reply.map(String);
|
||||
const kind = values[0];
|
||||
if (kind === 'RESERVED') {
|
||||
return {
|
||||
actionRequestScopeKey: values[1],
|
||||
auctionStateTransitionId: values[2],
|
||||
currentServerTimestampMS: numberValue(values[6]),
|
||||
newAuctionLifecycleId: values[3],
|
||||
observedProcessingLeaseVersion: numberValue(values[4]),
|
||||
reserved: true,
|
||||
wasLeaseExpired: values[5] === '1',
|
||||
};
|
||||
}
|
||||
if (kind === 'REPLAY') {
|
||||
return {
|
||||
actionRequestScopeKey: values[2],
|
||||
currentServerTimestampMS: numberValue(values[8]),
|
||||
isReplay: true,
|
||||
requiresRefetch: values[10] === '1' || undefined,
|
||||
replayStatus: values[1],
|
||||
responseJson: values[9] || undefined,
|
||||
revision: values[3] ? numberValue(values[3]) : undefined,
|
||||
};
|
||||
}
|
||||
return {
|
||||
actionRequestScopeKey: values[2] ?? '',
|
||||
code: values[1] ?? 'UNKNOWN',
|
||||
currentServerTimestampMS: numberValue(values[3]),
|
||||
rejected: true,
|
||||
};
|
||||
}
|
||||
|
||||
function parseApplyTransitionReply(
|
||||
reply: unknown[],
|
||||
): AuctionApplyTransitionCommandResult {
|
||||
const values = reply.map(String);
|
||||
const kind = values[0];
|
||||
if (kind === 'OK') {
|
||||
return {
|
||||
auctionStateTransitionId: values[1],
|
||||
currentServerTimestampMS: numberValue(values[3]),
|
||||
ok: true,
|
||||
revision: numberValue(values[2]),
|
||||
};
|
||||
}
|
||||
if (kind === 'REPLAY') {
|
||||
return {
|
||||
auctionStateTransitionId: values[2],
|
||||
currentServerTimestampMS: numberValue(values[3]),
|
||||
isReplay: true,
|
||||
replayStatus: values[1],
|
||||
};
|
||||
}
|
||||
return {
|
||||
auctionStateTransitionId: values[2] ?? '',
|
||||
code: values[1] ?? 'UNKNOWN',
|
||||
currentServerTimestampMS: numberValue(values[3]),
|
||||
rejected: true,
|
||||
};
|
||||
}
|
||||
|
||||
function parseExpirePrepareReply(
|
||||
reply: unknown[],
|
||||
): AuctionExpirePrepareCommandResult {
|
||||
const values = reply.map(String);
|
||||
const kind = values[0];
|
||||
if (kind === 'OK' || kind === 'REPLAY') {
|
||||
return {
|
||||
auctionStateTransitionId: values[2],
|
||||
bidRoundExpiryDecision:
|
||||
values[1] === 'sold' || values[1] === 'passed' ? values[1] : 'passed',
|
||||
currentServerTimestampMS: numberValue(values[4]),
|
||||
isReplay: kind === 'REPLAY' || undefined,
|
||||
ok: true,
|
||||
revision: numberValue(values[3]),
|
||||
};
|
||||
}
|
||||
return {
|
||||
code: values[1] ?? 'UNKNOWN',
|
||||
currentServerTimestampMS: numberValue(values[2]),
|
||||
noop: true,
|
||||
};
|
||||
}
|
||||
|
||||
function parseHydrateStateReply(
|
||||
reply: unknown[],
|
||||
): AuctionHydrateStateCommandResult {
|
||||
const values = reply.map(String);
|
||||
if (values[0] === 'OK') {
|
||||
return {
|
||||
currentServerTimestampMS: numberValue(values[2]),
|
||||
hydrated: true,
|
||||
revision: numberValue(values[1]),
|
||||
};
|
||||
}
|
||||
if (values[0] === 'REJECTED') {
|
||||
return {
|
||||
code: values[1] ?? 'UNKNOWN',
|
||||
currentServerTimestampMS: numberValue(values[2]),
|
||||
rejected: true,
|
||||
};
|
||||
}
|
||||
return {
|
||||
currentServerTimestampMS: numberValue(values[2]),
|
||||
noop: true,
|
||||
revision: numberValue(values[1]),
|
||||
};
|
||||
}
|
||||
|
||||
function numberValue(value: string | undefined): number {
|
||||
const parsed = Number(value);
|
||||
return Number.isFinite(parsed) ? parsed : 0;
|
||||
}
|
||||
@@ -0,0 +1,152 @@
|
||||
import mongoose from 'mongoose';
|
||||
import {
|
||||
buildAuctionRedisLiveStatePatchFromStructure,
|
||||
buildAuctionRedisStructureState,
|
||||
convertLegacyAuctionTeamsToRedisTeams,
|
||||
} from './auction-redis-projection';
|
||||
|
||||
describe('auction redis projection helpers', () => {
|
||||
it('converts legacy auction team fields to redis-v1 names', () => {
|
||||
const captainUserId = new mongoose.Types.ObjectId();
|
||||
const memberUserId = new mongoose.Types.ObjectId();
|
||||
|
||||
expect(
|
||||
convertLegacyAuctionTeamsToRedisTeams([
|
||||
{
|
||||
teamIndex: 1,
|
||||
captainUserId,
|
||||
points: 970,
|
||||
members: [
|
||||
{
|
||||
userId: memberUserId,
|
||||
assignedPosition: 'ADC',
|
||||
cost: 30,
|
||||
},
|
||||
],
|
||||
},
|
||||
]),
|
||||
).toEqual([
|
||||
{
|
||||
teamIndex: 1,
|
||||
captainUserId,
|
||||
remainingBidPointAmount: 970,
|
||||
members: [
|
||||
{
|
||||
userId: memberUserId,
|
||||
assignedPosition: 'ADC',
|
||||
memberAcquisitionBidPointAmount: 30,
|
||||
},
|
||||
],
|
||||
},
|
||||
]);
|
||||
});
|
||||
|
||||
it('builds the redis structure state with only structure/config fields', () => {
|
||||
const captainUserId = new mongoose.Types.ObjectId();
|
||||
const playerUserId = new mongoose.Types.ObjectId();
|
||||
|
||||
expect(
|
||||
buildAuctionRedisStructureState({
|
||||
auctionPlayerOrder: [
|
||||
{
|
||||
userId: playerUserId,
|
||||
puuid: 'puuid',
|
||||
gameName: 'Player',
|
||||
tagLine: 'KR1',
|
||||
profileIconId: 1,
|
||||
preferredPositions: [{ position: 'MID', priority: 1 }],
|
||||
tiers: [],
|
||||
tierHistory: [],
|
||||
masteries: [],
|
||||
passCount: 0,
|
||||
},
|
||||
],
|
||||
auctionTeams: [
|
||||
{
|
||||
teamIndex: 1,
|
||||
captainUserId,
|
||||
remainingBidPointAmount: 1000,
|
||||
members: [],
|
||||
},
|
||||
],
|
||||
bidRoundExtensionSeconds: 5,
|
||||
currentAuctionPlayerOrderIndex: 0,
|
||||
currentAuctionRound: 1,
|
||||
initialTeamBidPointAmount: 1000,
|
||||
manualTopTierAuctionPriorityUserIds: [],
|
||||
maximumBidRoundDurationSeconds: 30,
|
||||
passedAuctionPlayerQueue: [],
|
||||
topTierAuctionPriorityThreshold: 'NONE',
|
||||
}),
|
||||
).toMatchObject({
|
||||
auctionPlayerOrder: [expect.objectContaining({ userId: playerUserId })],
|
||||
auctionTeams: [
|
||||
expect.objectContaining({
|
||||
captainUserId,
|
||||
remainingBidPointAmount: 1000,
|
||||
teamIndex: 1,
|
||||
}),
|
||||
],
|
||||
bidRoundExtensionSeconds: 5,
|
||||
currentAuctionPlayerOrderIndex: 0,
|
||||
currentAuctionRound: 1,
|
||||
initialTeamBidPointAmount: 1000,
|
||||
maximumBidRoundDurationSeconds: 30,
|
||||
passedAuctionPlayerQueue: [],
|
||||
topTierAuctionPriorityThreshold: 'NONE',
|
||||
});
|
||||
});
|
||||
|
||||
it('builds live state patch required by BID Lua', () => {
|
||||
const captainUserId = new mongoose.Types.ObjectId();
|
||||
const playerUserId = new mongoose.Types.ObjectId();
|
||||
|
||||
expect(
|
||||
buildAuctionRedisLiveStatePatchFromStructure({
|
||||
auctionPlayerOrder: [
|
||||
{
|
||||
userId: playerUserId,
|
||||
puuid: 'puuid',
|
||||
gameName: 'Player',
|
||||
tagLine: 'KR1',
|
||||
profileIconId: 1,
|
||||
preferredPositions: [{ position: 'MID', priority: 1 }],
|
||||
tiers: [],
|
||||
tierHistory: [],
|
||||
masteries: [],
|
||||
passCount: 0,
|
||||
},
|
||||
],
|
||||
auctionTeams: [
|
||||
{
|
||||
teamIndex: 2,
|
||||
captainUserId,
|
||||
remainingBidPointAmount: 970,
|
||||
members: [
|
||||
{
|
||||
userId: new mongoose.Types.ObjectId(),
|
||||
assignedPosition: 'ADC',
|
||||
memberAcquisitionBidPointAmount: 30,
|
||||
},
|
||||
],
|
||||
},
|
||||
],
|
||||
bidRoundExtensionSeconds: 5,
|
||||
currentAuctionPlayerOrderIndex: 0,
|
||||
currentAuctionRound: 1,
|
||||
initialTeamBidPointAmount: 1000,
|
||||
manualTopTierAuctionPriorityUserIds: [],
|
||||
maximumBidRoundDurationSeconds: 30,
|
||||
passedAuctionPlayerQueue: [],
|
||||
topTierAuctionPriorityThreshold: 'NONE',
|
||||
}),
|
||||
).toEqual({
|
||||
bidRoundExtensionSeconds: 5,
|
||||
currentAuctionPlayerOrderIndex: 0,
|
||||
currentBidRoundPlayerUserId: playerUserId.toString(),
|
||||
maximumBidRoundDurationSeconds: 30,
|
||||
'team:2:assignedAuctionTeamMemberCount': 2,
|
||||
'team:2:remainingBidPointAmount': 970,
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,92 @@
|
||||
import type {
|
||||
AuctionPlayerSnapshot,
|
||||
AuctionTeam,
|
||||
AuctionTopTierThreshold,
|
||||
RedisAuctionTeam,
|
||||
} from '../../global/database/schema';
|
||||
import type mongoose from 'mongoose';
|
||||
|
||||
export interface AuctionRedisStructureStateInput {
|
||||
auctionPlayerOrder: AuctionPlayerSnapshot[];
|
||||
auctionTeams: RedisAuctionTeam[];
|
||||
bidRoundExtensionSeconds: number;
|
||||
currentAuctionPlayerOrderIndex: number;
|
||||
currentAuctionRound: number;
|
||||
initialTeamBidPointAmount: number;
|
||||
manualTopTierAuctionPriorityUserIds: mongoose.Types.ObjectId[];
|
||||
maximumBidRoundDurationSeconds: number;
|
||||
passedAuctionPlayerQueue: AuctionPlayerSnapshot[];
|
||||
topTierAuctionPriorityThreshold: AuctionTopTierThreshold;
|
||||
}
|
||||
|
||||
export function convertLegacyAuctionTeamsToRedisTeams(
|
||||
teams: AuctionTeam[],
|
||||
): RedisAuctionTeam[] {
|
||||
return teams.map((team) => ({
|
||||
teamIndex: team.teamIndex,
|
||||
captainUserId: team.captainUserId,
|
||||
remainingBidPointAmount: team.points,
|
||||
members: team.members.map((member) => ({
|
||||
userId: member.userId,
|
||||
assignedPosition: member.assignedPosition,
|
||||
memberAcquisitionBidPointAmount: member.cost,
|
||||
})),
|
||||
}));
|
||||
}
|
||||
|
||||
export function buildAuctionRedisStructureState(
|
||||
input: AuctionRedisStructureStateInput,
|
||||
): Record<string, unknown> {
|
||||
return {
|
||||
auctionPlayerOrder: input.auctionPlayerOrder,
|
||||
auctionTeams: input.auctionTeams,
|
||||
bidRoundExtensionSeconds: input.bidRoundExtensionSeconds,
|
||||
currentAuctionPlayerOrderIndex: input.currentAuctionPlayerOrderIndex,
|
||||
currentAuctionRound: input.currentAuctionRound,
|
||||
initialTeamBidPointAmount: input.initialTeamBidPointAmount,
|
||||
manualTopTierAuctionPriorityUserIds:
|
||||
input.manualTopTierAuctionPriorityUserIds,
|
||||
maximumBidRoundDurationSeconds: input.maximumBidRoundDurationSeconds,
|
||||
passedAuctionPlayerQueue: input.passedAuctionPlayerQueue,
|
||||
topTierAuctionPriorityThreshold: input.topTierAuctionPriorityThreshold,
|
||||
};
|
||||
}
|
||||
|
||||
export function buildAuctionRedisLiveStatePatchFromStructure(
|
||||
input: AuctionRedisStructureStateInput,
|
||||
): Record<string, string | number> {
|
||||
const patch: Record<string, string | number> = {
|
||||
bidRoundExtensionSeconds: input.bidRoundExtensionSeconds,
|
||||
currentAuctionPlayerOrderIndex: input.currentAuctionPlayerOrderIndex,
|
||||
maximumBidRoundDurationSeconds: input.maximumBidRoundDurationSeconds,
|
||||
};
|
||||
|
||||
const currentPlayer =
|
||||
input.auctionPlayerOrder[input.currentAuctionPlayerOrderIndex];
|
||||
if (currentPlayer) {
|
||||
patch.currentBidRoundPlayerUserId = currentPlayer.userId.toString();
|
||||
}
|
||||
|
||||
for (const team of input.auctionTeams) {
|
||||
patch[`team:${team.teamIndex}:remainingBidPointAmount`] =
|
||||
team.remainingBidPointAmount;
|
||||
patch[`team:${team.teamIndex}:assignedAuctionTeamMemberCount`] =
|
||||
countAuctionTeamMembersIncludingCaptain(team);
|
||||
}
|
||||
|
||||
return patch;
|
||||
}
|
||||
|
||||
export function stringifyAuctionRedisStructureState(
|
||||
input: AuctionRedisStructureStateInput,
|
||||
): string {
|
||||
return JSON.stringify(buildAuctionRedisStructureState(input));
|
||||
}
|
||||
|
||||
function countAuctionTeamMembersIncludingCaptain(team: RedisAuctionTeam): number {
|
||||
const userIds = new Set<string>([team.captainUserId.toString()]);
|
||||
for (const member of team.members) {
|
||||
userIds.add(member.userId.toString());
|
||||
}
|
||||
return userIds.size;
|
||||
}
|
||||
@@ -0,0 +1,160 @@
|
||||
import { AuctionRedisService } from './auction-redis.service';
|
||||
import { AuctionRedisStateReaderService } from './auction-redis-state-reader.service';
|
||||
|
||||
function makeService(commandReplies: unknown[], currentServerTimestampMS = 1000) {
|
||||
const sendCommand = jest
|
||||
.fn()
|
||||
.mockImplementation(() => Promise.resolve(commandReplies.shift()));
|
||||
const auctionRedisService = {
|
||||
getCurrentRedisTimestampMS: jest
|
||||
.fn()
|
||||
.mockResolvedValue(currentServerTimestampMS),
|
||||
raw: jest.fn().mockReturnValue({ sendCommand }),
|
||||
} as unknown as jest.Mocked<AuctionRedisService>;
|
||||
|
||||
return {
|
||||
auctionRedisService,
|
||||
sendCommand,
|
||||
service: new AuctionRedisStateReaderService(auctionRedisService),
|
||||
};
|
||||
}
|
||||
|
||||
describe('AuctionRedisStateReaderService', () => {
|
||||
it('reads live state identity', async () => {
|
||||
const { service, sendCommand } = makeService([['life-1', '7']]);
|
||||
|
||||
await expect(service.readLiveStateIdentity('match-1')).resolves.toEqual({
|
||||
auctionLifecycleId: 'life-1',
|
||||
revision: 7,
|
||||
});
|
||||
expect(sendCommand).toHaveBeenCalledWith([
|
||||
'HMGET',
|
||||
'auction:match-1:liveAuctionState',
|
||||
'auctionLifecycleId',
|
||||
'revision',
|
||||
]);
|
||||
});
|
||||
|
||||
it('returns null when live state identity is missing', async () => {
|
||||
const { service } = makeService([[null, null]]);
|
||||
|
||||
await expect(service.readLiveStateIdentity('match-1')).resolves.toBeNull();
|
||||
});
|
||||
|
||||
it('assembles a public auction view from Redis state', async () => {
|
||||
const { service, sendCommand } = makeService([
|
||||
[
|
||||
'auctionLifecycleId',
|
||||
'life-1',
|
||||
'phase',
|
||||
'expiring',
|
||||
'revision',
|
||||
'8',
|
||||
'currentHighestBidPointAmount',
|
||||
'100',
|
||||
'currentHighestBidderTeamIndex',
|
||||
'2',
|
||||
'team:2:remainingBidPointAmount',
|
||||
'900',
|
||||
'bidRoundExpiryDecision',
|
||||
'sold',
|
||||
],
|
||||
'{"auctionTeams":[{"teamIndex":1}]}',
|
||||
['{"bidPointAmount":100,"bidderTeamIndex":2}'],
|
||||
]);
|
||||
|
||||
const view = await service.readAuctionStateView('match-1', {
|
||||
shouldForceAuctionStateResync: true,
|
||||
});
|
||||
|
||||
expect(view).toMatchObject({
|
||||
auctionBidHistory: [{ bidPointAmount: 100, bidderTeamIndex: 2 }],
|
||||
auctionLifecycleId: 'life-1',
|
||||
auctionTeams: [{ teamIndex: 1 }],
|
||||
canPlaceBidInCurrentBidRound: false,
|
||||
currentHighestBidderTeamIndex: 2,
|
||||
currentHighestBidPointAmount: 100,
|
||||
currentServerTimestampMS: 1000,
|
||||
isAuctionStateTransitionInProgress: true,
|
||||
phase: 'bidding',
|
||||
revision: 8,
|
||||
shouldForceAuctionStateResync: true,
|
||||
});
|
||||
expect(view).not.toHaveProperty('team:2:remainingBidPointAmount');
|
||||
expect(view).not.toHaveProperty('bidRoundExpiryDecision');
|
||||
expect(sendCommand).toHaveBeenNthCalledWith(1, [
|
||||
'HGETALL',
|
||||
'auction:match-1:liveAuctionState',
|
||||
]);
|
||||
expect(sendCommand).toHaveBeenNthCalledWith(2, [
|
||||
'GET',
|
||||
'auction:match-1:auctionStructureState',
|
||||
]);
|
||||
expect(sendCommand).toHaveBeenNthCalledWith(3, [
|
||||
'LRANGE',
|
||||
'auction:match-1:auctionBidHistory',
|
||||
'0',
|
||||
'-1',
|
||||
]);
|
||||
});
|
||||
|
||||
it('assembles state when HGETALL returns an object', async () => {
|
||||
const { service } = makeService([
|
||||
{
|
||||
auctionLifecycleId: 'life-1',
|
||||
phase: 'presenting',
|
||||
revision: '3',
|
||||
},
|
||||
'{"auctionTeams":[]}',
|
||||
[],
|
||||
]);
|
||||
|
||||
await expect(service.readAuctionStateView('match-1')).resolves.toMatchObject({
|
||||
auctionLifecycleId: 'life-1',
|
||||
auctionTeams: [],
|
||||
phase: 'presenting',
|
||||
revision: 3,
|
||||
});
|
||||
});
|
||||
|
||||
it('can expose internal live fields for server-side expiry completion', async () => {
|
||||
const { service } = makeService([
|
||||
{
|
||||
auctionLifecycleId: 'life-1',
|
||||
bidRoundExpiryDecision: 'sold',
|
||||
phase: 'expiring',
|
||||
revision: '4',
|
||||
'team:1:remainingBidPointAmount': '900',
|
||||
},
|
||||
'{"auctionTeams":[]}',
|
||||
[],
|
||||
]);
|
||||
|
||||
await expect(
|
||||
service.readAuctionStateView('match-1', {
|
||||
includeInternalLiveStateFields: true,
|
||||
}),
|
||||
).resolves.toMatchObject({
|
||||
bidRoundExpiryDecision: 'sold',
|
||||
redisInternalPhase: 'expiring',
|
||||
'team:1:remainingBidPointAmount': '900',
|
||||
});
|
||||
});
|
||||
|
||||
|
||||
it('returns null when live or structure state is absent', async () => {
|
||||
await expect(
|
||||
makeService([[], '{"auctionTeams":[]}', []]).service.readAuctionStateView(
|
||||
'match-1',
|
||||
),
|
||||
).resolves.toBeNull();
|
||||
|
||||
await expect(
|
||||
makeService([
|
||||
{ auctionLifecycleId: 'life-1', phase: 'presenting', revision: '1' },
|
||||
null,
|
||||
[],
|
||||
]).service.readAuctionStateView('match-1'),
|
||||
).resolves.toBeNull();
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,155 @@
|
||||
import { Injectable } from '@nestjs/common';
|
||||
import { buildAuctionRedisKeys } from './auction-redis.keys';
|
||||
import { AuctionRedisService } from './auction-redis.service';
|
||||
import { assembleAuctionViewFromRedisState } from './auction-redis.state';
|
||||
|
||||
const NUMERIC_LIVE_STATE_FIELDS = new Set([
|
||||
'bidRoundExpiryPlayerOrderIndex',
|
||||
'bidRoundExpiryRevision',
|
||||
'bidRoundExpiryWinningBidPointAmount',
|
||||
'bidRoundExpiryWinningBidderTeamIndex',
|
||||
'currentAuctionHistorySequence',
|
||||
'currentAuctionPlayerOrderIndex',
|
||||
'currentBidRoundDeadlineTimestampMS',
|
||||
'currentHighestBidPointAmount',
|
||||
'currentHighestBidderTeamIndex',
|
||||
'matchSideEffectRevision',
|
||||
'revision',
|
||||
]);
|
||||
|
||||
export interface AuctionRedisLiveStateIdentity {
|
||||
auctionLifecycleId?: string;
|
||||
revision?: number;
|
||||
}
|
||||
|
||||
export interface AuctionRedisStateViewReadOptions {
|
||||
includeInternalLiveStateFields?: boolean;
|
||||
shouldForceAuctionStateResync?: boolean;
|
||||
}
|
||||
|
||||
@Injectable()
|
||||
export class AuctionRedisStateReaderService {
|
||||
constructor(private readonly auctionRedisService: AuctionRedisService) {}
|
||||
|
||||
public async readLiveStateIdentity(
|
||||
matchId: string,
|
||||
): Promise<AuctionRedisLiveStateIdentity | null> {
|
||||
const keys = buildAuctionRedisKeys(matchId);
|
||||
const reply = await this.auctionRedisService.raw().sendCommand([
|
||||
'HMGET',
|
||||
keys.liveStateKey,
|
||||
'auctionLifecycleId',
|
||||
'revision',
|
||||
]);
|
||||
if (!Array.isArray(reply)) return null;
|
||||
const auctionLifecycleId =
|
||||
typeof reply[0] === 'string' && reply[0] ? reply[0] : undefined;
|
||||
const revision =
|
||||
typeof reply[1] === 'string' || typeof reply[1] === 'number'
|
||||
? Number(reply[1])
|
||||
: Number.NaN;
|
||||
if (!auctionLifecycleId && !Number.isFinite(revision)) return null;
|
||||
return {
|
||||
auctionLifecycleId,
|
||||
revision: Number.isFinite(revision) ? revision : undefined,
|
||||
};
|
||||
}
|
||||
|
||||
public async readAuctionStateView(
|
||||
matchId: string,
|
||||
options: AuctionRedisStateViewReadOptions = {},
|
||||
): Promise<Record<string, unknown> | null> {
|
||||
const keys = buildAuctionRedisKeys(matchId);
|
||||
const [currentServerTimestampMS, liveReply, structureStateJson, bidEntries] =
|
||||
await Promise.all([
|
||||
this.auctionRedisService.getCurrentRedisTimestampMS(),
|
||||
this.auctionRedisService.raw().sendCommand(['HGETALL', keys.liveStateKey]),
|
||||
this.auctionRedisService.raw().sendCommand(['GET', keys.structureStateKey]),
|
||||
this.auctionRedisService.raw().sendCommand([
|
||||
'LRANGE',
|
||||
keys.bidHistoryKey,
|
||||
'0',
|
||||
'-1',
|
||||
]),
|
||||
]);
|
||||
|
||||
const liveState = parseHashReply(liveReply, {
|
||||
includeInternalLiveStateFields:
|
||||
options.includeInternalLiveStateFields ?? false,
|
||||
});
|
||||
if (!liveState) return null;
|
||||
if (
|
||||
typeof liveState.auctionLifecycleId !== 'string' ||
|
||||
typeof liveState.phase !== 'string' ||
|
||||
typeof liveState.revision !== 'number'
|
||||
) {
|
||||
return null;
|
||||
}
|
||||
if (typeof structureStateJson !== 'string' || !structureStateJson) {
|
||||
return null;
|
||||
}
|
||||
|
||||
const view = assembleAuctionViewFromRedisState({
|
||||
auctionBidHistoryEntries: Array.isArray(bidEntries)
|
||||
? bidEntries.map(String)
|
||||
: [],
|
||||
currentServerTimestampMS,
|
||||
liveState: liveState as Record<string, unknown> & {
|
||||
auctionLifecycleId: string;
|
||||
phase: string;
|
||||
revision: number;
|
||||
},
|
||||
shouldForceAuctionStateResync: options.shouldForceAuctionStateResync,
|
||||
structureState: JSON.parse(structureStateJson) as Record<string, unknown>,
|
||||
});
|
||||
if (options.includeInternalLiveStateFields) {
|
||||
view.redisInternalPhase = liveState.phase;
|
||||
}
|
||||
return view;
|
||||
}
|
||||
}
|
||||
|
||||
function parseHashReply(
|
||||
reply: unknown,
|
||||
options: { includeInternalLiveStateFields?: boolean } = {},
|
||||
): Record<string, unknown> | null {
|
||||
if (!reply) return null;
|
||||
if (Array.isArray(reply)) {
|
||||
if (reply.length === 0) return null;
|
||||
const entries: [string, unknown][] = [];
|
||||
for (let index = 0; index < reply.length; index += 2) {
|
||||
entries.push([String(reply[index]), reply[index + 1]]);
|
||||
}
|
||||
return parseHashEntries(entries, options);
|
||||
}
|
||||
if (typeof reply === 'object') {
|
||||
const entries = Object.entries(reply as Record<string, unknown>);
|
||||
if (entries.length === 0) return null;
|
||||
return parseHashEntries(entries, options);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
function parseHashEntries(
|
||||
entries: [string, unknown][],
|
||||
options: { includeInternalLiveStateFields?: boolean } = {},
|
||||
): Record<string, unknown> {
|
||||
const result: Record<string, unknown> = {};
|
||||
for (const [field, rawValue] of entries) {
|
||||
if (!options.includeInternalLiveStateFields && isInternalLiveStateField(field)) {
|
||||
continue;
|
||||
}
|
||||
const value = String(rawValue);
|
||||
if (NUMERIC_LIVE_STATE_FIELDS.has(field)) {
|
||||
const parsed = Number(value);
|
||||
result[field] = Number.isFinite(parsed) ? parsed : 0;
|
||||
continue;
|
||||
}
|
||||
result[field] = value;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
function isInternalLiveStateField(field: string): boolean {
|
||||
return field.startsWith('team:') || field.startsWith('bidRoundExpiry');
|
||||
}
|
||||
@@ -0,0 +1,113 @@
|
||||
import { buildAuctionRedisKeys } from './auction-redis.keys';
|
||||
import {
|
||||
AUCTION_APPLY_TRANSITION_SCRIPT,
|
||||
buildAuctionApplyTransitionScriptInvocation,
|
||||
} from './auction-redis.apply-transition';
|
||||
|
||||
describe('auction apply transition redis script contract', () => {
|
||||
it('builds APPLY_TRANSITION keys and values in a stable order', () => {
|
||||
const keys = buildAuctionRedisKeys('match-1');
|
||||
const invocation = buildAuctionApplyTransitionScriptInvocation(keys, {
|
||||
actionRequest: {
|
||||
observedProcessingLeaseVersion: 3,
|
||||
processingOwnerToken: 'owner-1',
|
||||
scopeKey: 'life-1:request-1',
|
||||
},
|
||||
afterAuctionStructureStateJson: '{"auctionTeams":[]}',
|
||||
auctionHistorySequence: 4,
|
||||
auctionLifecycleId: 'life-1',
|
||||
auctionStateTransitionId: 'transition-1',
|
||||
broadcastStateRevision: 9,
|
||||
deadline: { durationSeconds: 30, mode: 'set-relative' },
|
||||
durabilityPayloadJson: '{"revision":9}',
|
||||
expectedCurrentAuctionPlayerOrderIndex: 2,
|
||||
expectedCurrentBidRoundPlayerUserId: 'player-1',
|
||||
expectedAuctionHistorySequence: 3,
|
||||
expectedPhase: 'bidding',
|
||||
expectedRevision: 8,
|
||||
liveStatePatch: {
|
||||
currentAuctionHistorySequence: 4,
|
||||
phase: 'sold',
|
||||
},
|
||||
matchId: 'match-1',
|
||||
shouldBroadcastState: true,
|
||||
});
|
||||
|
||||
expect(invocation.script).toBe(AUCTION_APPLY_TRANSITION_SCRIPT);
|
||||
expect(invocation.keys).toEqual([
|
||||
'auction:match-1:liveAuctionState',
|
||||
'auction:match-1:auctionStructureState',
|
||||
'auction:match-1:appliedAuctionStateTransitionIds',
|
||||
'auction:match-1:durability:transition-1',
|
||||
'auction:auctionDurabilityRetryQueue',
|
||||
'auction:match-1:auctionActionRequestResults',
|
||||
'auction:match-1:auctionActionRequestResultOrder',
|
||||
'auction:match-1:auctionBidHistory',
|
||||
'auction:match-1:bidRequestResults',
|
||||
'auction:match-1:bidRequestResultOrder',
|
||||
'auction:bidRoundDeadlineQueue',
|
||||
]);
|
||||
expect(invocation.values.slice(0, 19)).toEqual([
|
||||
'match-1',
|
||||
'life-1',
|
||||
'transition-1',
|
||||
'8',
|
||||
'3',
|
||||
'bidding',
|
||||
'player-1',
|
||||
'2',
|
||||
'{"auctionTeams":[]}',
|
||||
'4',
|
||||
'{"revision":9}',
|
||||
'1',
|
||||
'9',
|
||||
'set-relative',
|
||||
'30',
|
||||
'0',
|
||||
'life-1:request-1',
|
||||
'owner-1',
|
||||
'3',
|
||||
]);
|
||||
expect(invocation.values.slice(19)).toEqual([
|
||||
'2',
|
||||
'currentAuctionHistorySequence',
|
||||
'4',
|
||||
'phase',
|
||||
'sold',
|
||||
]);
|
||||
});
|
||||
|
||||
it('keeps critical atomicity guards in Lua', () => {
|
||||
expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain("redis.call('TIME')");
|
||||
expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain(
|
||||
'ACTION_REQUEST_LEASE_VERSION_MISMATCH',
|
||||
);
|
||||
expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain(
|
||||
'ACTION_REQUEST_TRANSITION_MISMATCH',
|
||||
);
|
||||
expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain(
|
||||
'INVALID_PATCH_ARITY',
|
||||
);
|
||||
expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain(
|
||||
'shouldBroadcastState',
|
||||
);
|
||||
expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain(
|
||||
"redis.call('SADD'",
|
||||
);
|
||||
expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain(
|
||||
"redis.call('HINCRBY'",
|
||||
);
|
||||
expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain(
|
||||
'currentAuctionHistorySequence',
|
||||
);
|
||||
expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain(
|
||||
'storeValidatedActionRequestRejection',
|
||||
);
|
||||
expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain(
|
||||
"actionRequestPrefix .. 'status'",
|
||||
);
|
||||
expect(AUCTION_APPLY_TRANSITION_SCRIPT.lua).toContain(
|
||||
"actionRequestPrefix .. 'requiresRefetch'",
|
||||
);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,325 @@
|
||||
import type { AuctionRedisKeys } from './auction-redis.keys';
|
||||
import { defineAuctionRedisScript } from './auction-redis.scripts';
|
||||
|
||||
export type ApplyTransitionDeadlineInput =
|
||||
| { mode: 'none' }
|
||||
| { mode: 'remove' }
|
||||
| { durationSeconds: number; mode: 'set-relative' };
|
||||
|
||||
export interface ApplyTransitionActionRequestInput {
|
||||
observedProcessingLeaseVersion: number;
|
||||
processingOwnerToken: string;
|
||||
scopeKey: string;
|
||||
}
|
||||
|
||||
export interface AuctionApplyTransitionScriptInput {
|
||||
actionRequest?: ApplyTransitionActionRequestInput;
|
||||
afterAuctionStructureStateJson: string;
|
||||
auctionHistorySequence: number;
|
||||
auctionLifecycleId: string;
|
||||
auctionStateTransitionId: string;
|
||||
broadcastStateRevision: number;
|
||||
deadline: ApplyTransitionDeadlineInput;
|
||||
durabilityPayloadJson: string;
|
||||
expectedCurrentAuctionPlayerOrderIndex?: number;
|
||||
expectedCurrentBidRoundPlayerUserId?: string;
|
||||
expectedAuctionHistorySequence?: number;
|
||||
expectedPhase: string;
|
||||
expectedRevision: number;
|
||||
liveStatePatch: Record<string, string | number | boolean | null | undefined>;
|
||||
matchId: string;
|
||||
shouldBroadcastState: boolean;
|
||||
shouldResetBidRuntime?: boolean;
|
||||
}
|
||||
|
||||
export interface AuctionApplyTransitionScriptInvocation {
|
||||
keys: string[];
|
||||
script: typeof AUCTION_APPLY_TRANSITION_SCRIPT;
|
||||
values: string[];
|
||||
}
|
||||
|
||||
function stringifyRedisValue(value: string | number | boolean | null): string {
|
||||
if (typeof value === 'boolean') return value ? '1' : '0';
|
||||
if (value === null) return '';
|
||||
return String(value);
|
||||
}
|
||||
|
||||
function flattenLiveStatePatch(
|
||||
liveStatePatch: AuctionApplyTransitionScriptInput['liveStatePatch'],
|
||||
): string[] {
|
||||
return Object.entries(liveStatePatch)
|
||||
.filter(([, value]) => value !== undefined)
|
||||
.sort(([a], [b]) => a.localeCompare(b))
|
||||
.flatMap(([key, value]) => [
|
||||
key,
|
||||
stringifyRedisValue(value as string | number | boolean | null),
|
||||
]);
|
||||
}
|
||||
|
||||
export function buildAuctionApplyTransitionScriptInvocation(
|
||||
keys: AuctionRedisKeys,
|
||||
input: AuctionApplyTransitionScriptInput,
|
||||
): AuctionApplyTransitionScriptInvocation {
|
||||
const liveStatePatchPairs = flattenLiveStatePatch(input.liveStatePatch);
|
||||
const deadlineDurationSeconds =
|
||||
input.deadline.mode === 'set-relative'
|
||||
? String(input.deadline.durationSeconds)
|
||||
: '0';
|
||||
|
||||
return {
|
||||
keys: [
|
||||
keys.liveStateKey,
|
||||
keys.structureStateKey,
|
||||
keys.appliedTransitionIdsKey,
|
||||
keys.durabilityPayloadKey(input.auctionStateTransitionId),
|
||||
keys.durabilityRetryQueueKey,
|
||||
keys.actionRequestResultsKey,
|
||||
keys.actionRequestResultOrderKey,
|
||||
keys.bidHistoryKey,
|
||||
keys.bidRequestResultsKey,
|
||||
keys.bidRequestResultOrderKey,
|
||||
keys.deadlineQueueKey,
|
||||
],
|
||||
script: AUCTION_APPLY_TRANSITION_SCRIPT,
|
||||
values: [
|
||||
input.matchId,
|
||||
input.auctionLifecycleId,
|
||||
input.auctionStateTransitionId,
|
||||
String(input.expectedRevision),
|
||||
String(
|
||||
input.expectedAuctionHistorySequence ??
|
||||
input.auctionHistorySequence - 1,
|
||||
),
|
||||
input.expectedPhase,
|
||||
input.expectedCurrentBidRoundPlayerUserId ?? '',
|
||||
input.expectedCurrentAuctionPlayerOrderIndex === undefined
|
||||
? ''
|
||||
: String(input.expectedCurrentAuctionPlayerOrderIndex),
|
||||
input.afterAuctionStructureStateJson,
|
||||
String(input.auctionHistorySequence),
|
||||
input.durabilityPayloadJson,
|
||||
input.shouldBroadcastState ? '1' : '0',
|
||||
String(input.broadcastStateRevision),
|
||||
input.deadline.mode,
|
||||
deadlineDurationSeconds,
|
||||
input.shouldResetBidRuntime ? '1' : '0',
|
||||
input.actionRequest?.scopeKey ?? '',
|
||||
input.actionRequest?.processingOwnerToken ?? '',
|
||||
input.actionRequest?.observedProcessingLeaseVersion === undefined
|
||||
? ''
|
||||
: String(input.actionRequest.observedProcessingLeaseVersion),
|
||||
String(liveStatePatchPairs.length / 2),
|
||||
...liveStatePatchPairs,
|
||||
],
|
||||
};
|
||||
}
|
||||
|
||||
export const AUCTION_APPLY_TRANSITION_SCRIPT = defineAuctionRedisScript(
|
||||
'auction.applyTransition',
|
||||
`
|
||||
local liveAuctionStateKey = KEYS[1]
|
||||
local auctionStructureStateKey = KEYS[2]
|
||||
local appliedAuctionStateTransitionIdsKey = KEYS[3]
|
||||
local durabilityPayloadKey = KEYS[4]
|
||||
local durabilityRetryQueueKey = KEYS[5]
|
||||
local auctionActionRequestResultsKey = KEYS[6]
|
||||
local auctionActionRequestResultOrderKey = KEYS[7]
|
||||
local auctionBidHistoryKey = KEYS[8]
|
||||
local bidRequestResultsKey = KEYS[9]
|
||||
local bidRequestResultOrderKey = KEYS[10]
|
||||
local bidRoundDeadlineQueueKey = KEYS[11]
|
||||
|
||||
local matchId = ARGV[1]
|
||||
local auctionLifecycleId = ARGV[2]
|
||||
local auctionStateTransitionId = ARGV[3]
|
||||
local expectedRevision = tonumber(ARGV[4])
|
||||
local expectedAuctionHistorySequence = tonumber(ARGV[5])
|
||||
local expectedPhase = ARGV[6]
|
||||
local expectedCurrentBidRoundPlayerUserId = ARGV[7]
|
||||
local expectedCurrentAuctionPlayerOrderIndex = ARGV[8]
|
||||
local afterAuctionStructureStateJson = ARGV[9]
|
||||
local auctionHistorySequence = tonumber(ARGV[10])
|
||||
local durabilityPayloadJson = ARGV[11]
|
||||
local shouldBroadcastState = ARGV[12]
|
||||
local broadcastStateRevision = tonumber(ARGV[13])
|
||||
local deadlineMode = ARGV[14]
|
||||
local deadlineDurationSeconds = tonumber(ARGV[15])
|
||||
local shouldResetBidRuntime = ARGV[16]
|
||||
local actionRequestScopeKey = ARGV[17]
|
||||
local processingOwnerToken = ARGV[18]
|
||||
local observedProcessingLeaseVersion = ARGV[19]
|
||||
local liveStatePatchPairCount = tonumber(ARGV[20])
|
||||
|
||||
local redisTime = redis.call('TIME')
|
||||
local currentRedisTimestampMS = (tonumber(redisTime[1]) * 1000) + math.floor(tonumber(redisTime[2]) / 1000)
|
||||
local validatedActionRequestScopeKey = ''
|
||||
|
||||
local function storeValidatedActionRequestRejection(code)
|
||||
if validatedActionRequestScopeKey == '' then
|
||||
return
|
||||
end
|
||||
local actionRequestPrefix = validatedActionRequestScopeKey .. ':'
|
||||
redis.call(
|
||||
'HSET',
|
||||
auctionActionRequestResultsKey,
|
||||
actionRequestPrefix .. 'status',
|
||||
'rejected',
|
||||
actionRequestPrefix .. 'rejectCode',
|
||||
code,
|
||||
actionRequestPrefix .. 'requiresRefetch',
|
||||
'1',
|
||||
actionRequestPrefix .. 'responseServerTimestampMS',
|
||||
tostring(currentRedisTimestampMS)
|
||||
)
|
||||
end
|
||||
|
||||
local function reject(code)
|
||||
storeValidatedActionRequestRejection(code)
|
||||
return {'REJECTED', code, auctionStateTransitionId, tostring(currentRedisTimestampMS)}
|
||||
end
|
||||
|
||||
if not liveStatePatchPairCount then
|
||||
return reject('INVALID_PATCH_ARITY')
|
||||
end
|
||||
if #ARGV ~= 20 + (liveStatePatchPairCount * 2) then
|
||||
return reject('INVALID_PATCH_ARITY')
|
||||
end
|
||||
if not durabilityPayloadJson or durabilityPayloadJson == '' then
|
||||
return reject('MISSING_DURABILITY_PAYLOAD')
|
||||
end
|
||||
if shouldBroadcastState ~= '0' and shouldBroadcastState ~= '1' then
|
||||
return reject('INVALID_SHOULD_BROADCAST_STATE')
|
||||
end
|
||||
if shouldBroadcastState == '1' and not broadcastStateRevision then
|
||||
return reject('INVALID_BROADCAST_STATE_REVISION')
|
||||
end
|
||||
if deadlineMode ~= 'none' and deadlineMode ~= 'remove' and deadlineMode ~= 'set-relative' then
|
||||
return reject('INVALID_DEADLINE_MODE')
|
||||
end
|
||||
if deadlineMode == 'set-relative' and (not deadlineDurationSeconds or deadlineDurationSeconds <= 0) then
|
||||
return reject('INVALID_DEADLINE_DURATION')
|
||||
end
|
||||
|
||||
if actionRequestScopeKey ~= '' then
|
||||
local actionRequestPrefix = actionRequestScopeKey .. ':'
|
||||
local storedTransitionId = redis.call('HGET', auctionActionRequestResultsKey, actionRequestPrefix .. 'auctionStateTransitionId')
|
||||
if not storedTransitionId then
|
||||
return reject('ACTION_REQUEST_NOT_RESERVED')
|
||||
end
|
||||
if storedTransitionId ~= auctionStateTransitionId then
|
||||
return reject('ACTION_REQUEST_TRANSITION_MISMATCH')
|
||||
end
|
||||
local storedOwnerToken = redis.call('HGET', auctionActionRequestResultsKey, actionRequestPrefix .. 'processingOwnerToken')
|
||||
local leaseExpiresAtTimestampMS = tonumber(redis.call('HGET', auctionActionRequestResultsKey, actionRequestPrefix .. 'processingLeaseExpiresAtTimestampMS') or '0')
|
||||
if leaseExpiresAtTimestampMS <= currentRedisTimestampMS then
|
||||
return reject('ACTION_REQUEST_LEASE_EXPIRED')
|
||||
end
|
||||
if storedOwnerToken ~= processingOwnerToken then
|
||||
return reject('ACTION_REQUEST_IN_PROGRESS')
|
||||
end
|
||||
local storedLeaseVersion = redis.call('HGET', auctionActionRequestResultsKey, actionRequestPrefix .. 'processingLeaseVersion') or ''
|
||||
if storedLeaseVersion ~= observedProcessingLeaseVersion then
|
||||
return reject('ACTION_REQUEST_LEASE_VERSION_MISMATCH')
|
||||
end
|
||||
validatedActionRequestScopeKey = actionRequestScopeKey
|
||||
end
|
||||
|
||||
local currentRevision = tonumber(redis.call('HGET', liveAuctionStateKey, 'revision') or '-1')
|
||||
if currentRevision ~= expectedRevision then
|
||||
return reject('CONFLICT')
|
||||
end
|
||||
local currentAuctionHistorySequence = tonumber(redis.call('HGET', liveAuctionStateKey, 'currentAuctionHistorySequence') or '-1')
|
||||
if currentAuctionHistorySequence ~= expectedAuctionHistorySequence then
|
||||
return reject('CONFLICT')
|
||||
end
|
||||
if redis.call('HGET', liveAuctionStateKey, 'auctionLifecycleId') ~= auctionLifecycleId then
|
||||
return reject('CONFLICT')
|
||||
end
|
||||
if redis.call('HGET', liveAuctionStateKey, 'phase') ~= expectedPhase then
|
||||
return reject('CONFLICT')
|
||||
end
|
||||
if expectedCurrentBidRoundPlayerUserId ~= '' and redis.call('HGET', liveAuctionStateKey, 'currentBidRoundPlayerUserId') ~= expectedCurrentBidRoundPlayerUserId then
|
||||
return reject('CONFLICT')
|
||||
end
|
||||
if expectedCurrentAuctionPlayerOrderIndex ~= '' and redis.call('HGET', liveAuctionStateKey, 'currentAuctionPlayerOrderIndex') ~= expectedCurrentAuctionPlayerOrderIndex then
|
||||
return reject('CONFLICT')
|
||||
end
|
||||
|
||||
local transitionDedupeMember = auctionLifecycleId .. ':' .. auctionStateTransitionId
|
||||
if redis.call('SISMEMBER', appliedAuctionStateTransitionIdsKey, transitionDedupeMember) == 1 then
|
||||
return {'REPLAY', 'APPLIED', auctionStateTransitionId, tostring(currentRedisTimestampMS)}
|
||||
end
|
||||
|
||||
local newRevision = redis.call('HINCRBY', liveAuctionStateKey, 'revision', 1)
|
||||
redis.call('SET', auctionStructureStateKey, afterAuctionStructureStateJson)
|
||||
|
||||
local hsetArgs = {
|
||||
liveAuctionStateKey,
|
||||
'auctionLifecycleId',
|
||||
auctionLifecycleId,
|
||||
'currentAuctionHistorySequence',
|
||||
tostring(auctionHistorySequence),
|
||||
'lastAppliedAuctionStateTransitionId',
|
||||
auctionStateTransitionId
|
||||
}
|
||||
local patchIndex = 21
|
||||
for i = 1, liveStatePatchPairCount do
|
||||
table.insert(hsetArgs, ARGV[patchIndex])
|
||||
table.insert(hsetArgs, ARGV[patchIndex + 1])
|
||||
patchIndex = patchIndex + 2
|
||||
end
|
||||
redis.call('HSET', unpack(hsetArgs))
|
||||
|
||||
if deadlineMode == 'set-relative' then
|
||||
local currentBidRoundDeadlineTimestampMS = currentRedisTimestampMS + (deadlineDurationSeconds * 1000)
|
||||
redis.call('HSET', liveAuctionStateKey, 'currentBidRoundDeadlineTimestampMS', tostring(currentBidRoundDeadlineTimestampMS))
|
||||
redis.call('ZADD', bidRoundDeadlineQueueKey, currentBidRoundDeadlineTimestampMS, matchId)
|
||||
elseif deadlineMode == 'remove' then
|
||||
redis.call('ZREM', bidRoundDeadlineQueueKey, matchId)
|
||||
end
|
||||
|
||||
if shouldResetBidRuntime == '1' then
|
||||
redis.call('DEL', auctionBidHistoryKey, bidRequestResultsKey, bidRequestResultOrderKey)
|
||||
end
|
||||
|
||||
redis.call('SADD', appliedAuctionStateTransitionIdsKey, transitionDedupeMember)
|
||||
redis.call(
|
||||
'HSET',
|
||||
durabilityPayloadKey,
|
||||
'payloadJson',
|
||||
durabilityPayloadJson,
|
||||
'preparedAtRedisTimestampMS',
|
||||
tostring(currentRedisTimestampMS),
|
||||
'committedAtRedisTimestampMS',
|
||||
tostring(currentRedisTimestampMS),
|
||||
'auctionLifecycleId',
|
||||
auctionLifecycleId,
|
||||
'revision',
|
||||
tostring(newRevision),
|
||||
'shouldBroadcastState',
|
||||
shouldBroadcastState,
|
||||
'broadcastStateRevision',
|
||||
tostring(broadcastStateRevision)
|
||||
)
|
||||
redis.call('ZADD', durabilityRetryQueueKey, currentRedisTimestampMS, durabilityPayloadKey)
|
||||
|
||||
if actionRequestScopeKey ~= '' then
|
||||
local actionRequestPrefix = actionRequestScopeKey .. ':'
|
||||
redis.call(
|
||||
'HSET',
|
||||
auctionActionRequestResultsKey,
|
||||
actionRequestPrefix .. 'status',
|
||||
'applied',
|
||||
actionRequestPrefix .. 'revision',
|
||||
tostring(newRevision),
|
||||
actionRequestPrefix .. 'requiresRefetch',
|
||||
'1',
|
||||
actionRequestPrefix .. 'responseServerTimestampMS',
|
||||
tostring(currentRedisTimestampMS)
|
||||
)
|
||||
redis.call('RPUSH', auctionActionRequestResultOrderKey, actionRequestScopeKey)
|
||||
end
|
||||
|
||||
return {'OK', auctionStateTransitionId, tostring(newRevision), tostring(currentRedisTimestampMS)}
|
||||
`,
|
||||
);
|
||||
@@ -0,0 +1,72 @@
|
||||
import { buildAuctionRedisKeys } from './auction-redis.keys';
|
||||
import {
|
||||
AUCTION_BID_SCRIPT,
|
||||
buildAuctionBidScriptInvocation,
|
||||
buildBidRequestPayloadFingerprint,
|
||||
} from './auction-redis.bid';
|
||||
|
||||
describe('auction bid redis script contract', () => {
|
||||
it('builds the BID script KEYS and ARGV in the documented order', () => {
|
||||
const keys = buildAuctionRedisKeys('match-1');
|
||||
const invocation = buildAuctionBidScriptInvocation(keys, {
|
||||
bidderTeamIndex: 2,
|
||||
bidPointAmount: 120,
|
||||
bidRequestId: 'bid-1',
|
||||
bidderUserId: 'captain-2',
|
||||
clientObservedAuctionLifecycleId: 'life-1',
|
||||
clientObservedCurrentBidRoundPlayerUserId: 'player-1',
|
||||
maximumAuctionTeamMemberCount: 5,
|
||||
maximumStoredAuctionBidHistoryCount: 200,
|
||||
maximumStoredBidRequestResultCount: 100,
|
||||
matchId: 'match-1',
|
||||
minimumBidPointReservePerRemainingAuctionTeamMemberSlot: 10,
|
||||
minimumBidRequestResultReplayWindowMS: 60_000,
|
||||
});
|
||||
|
||||
expect(invocation.script).toBe(AUCTION_BID_SCRIPT);
|
||||
expect(invocation.keys).toEqual([
|
||||
'auction:match-1:liveAuctionState',
|
||||
'auction:match-1:auctionBidHistory',
|
||||
'auction:match-1:bidRequestResults',
|
||||
'auction:match-1:bidRequestResultOrder',
|
||||
'auction:bidRoundDeadlineQueue',
|
||||
]);
|
||||
expect(invocation.values).toEqual([
|
||||
'match-1',
|
||||
'2',
|
||||
'120',
|
||||
'5',
|
||||
'10',
|
||||
'bid-1',
|
||||
'captain-2',
|
||||
'life-1',
|
||||
'player-1',
|
||||
'match-1|life-1|player-1|2|120',
|
||||
'100',
|
||||
'60000',
|
||||
'200',
|
||||
]);
|
||||
});
|
||||
|
||||
it('keeps bid fingerprints stable and timestamp-free', () => {
|
||||
expect(
|
||||
buildBidRequestPayloadFingerprint({
|
||||
bidderTeamIndex: 2,
|
||||
bidPointAmount: 120,
|
||||
clientObservedAuctionLifecycleId: 'life-1',
|
||||
clientObservedCurrentBidRoundPlayerUserId: 'player-1',
|
||||
matchId: 'match-1',
|
||||
}),
|
||||
).toBe('match-1|life-1|player-1|2|120');
|
||||
});
|
||||
|
||||
it('uses Redis TIME and scalar hash fields rather than JSON parsing', () => {
|
||||
expect(AUCTION_BID_SCRIPT.lua).toContain("redis.call('TIME')");
|
||||
expect(AUCTION_BID_SCRIPT.lua).toContain("redis.call('HINCRBY'");
|
||||
expect(AUCTION_BID_SCRIPT.lua).toContain('BID_REQUEST_RESULT_LIMIT');
|
||||
expect(AUCTION_BID_SCRIPT.lua).toContain(
|
||||
'currentHighestBidPointAmount',
|
||||
);
|
||||
expect(AUCTION_BID_SCRIPT.lua).not.toContain('cjson.decode');
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,310 @@
|
||||
import type { AuctionRedisKeys } from './auction-redis.keys';
|
||||
import { defineAuctionRedisScript } from './auction-redis.scripts';
|
||||
|
||||
export interface AuctionBidScriptInput {
|
||||
bidderTeamIndex: number;
|
||||
bidPointAmount: number;
|
||||
bidRequestId: string;
|
||||
bidderUserId: string;
|
||||
clientObservedAuctionLifecycleId: string;
|
||||
clientObservedCurrentBidRoundPlayerUserId: string;
|
||||
maximumAuctionTeamMemberCount: number;
|
||||
maximumStoredAuctionBidHistoryCount: number;
|
||||
maximumStoredBidRequestResultCount: number;
|
||||
matchId: string;
|
||||
minimumBidPointReservePerRemainingAuctionTeamMemberSlot: number;
|
||||
minimumBidRequestResultReplayWindowMS: number;
|
||||
}
|
||||
|
||||
export interface AuctionBidScriptInvocation {
|
||||
keys: string[];
|
||||
script: typeof AUCTION_BID_SCRIPT;
|
||||
values: string[];
|
||||
}
|
||||
|
||||
const BID_RESULT_HASH_SUFFIXES = [
|
||||
'fingerprint',
|
||||
'status',
|
||||
'revision',
|
||||
'rejectCode',
|
||||
'currentHighestBidPointAmount',
|
||||
'currentHighestBidderTeamIndex',
|
||||
'currentBidRoundDeadlineTimestampMS',
|
||||
'auctionBidHistoryEntryJson',
|
||||
'responseServerTimestampMS',
|
||||
'createdAtTimestampMS',
|
||||
] as const;
|
||||
|
||||
export function buildBidRequestPayloadFingerprint(params: {
|
||||
bidderTeamIndex: number;
|
||||
bidPointAmount: number;
|
||||
clientObservedAuctionLifecycleId: string;
|
||||
clientObservedCurrentBidRoundPlayerUserId: string;
|
||||
matchId: string;
|
||||
}): string {
|
||||
return [
|
||||
params.matchId,
|
||||
params.clientObservedAuctionLifecycleId,
|
||||
params.clientObservedCurrentBidRoundPlayerUserId,
|
||||
params.bidderTeamIndex,
|
||||
params.bidPointAmount,
|
||||
].join('|');
|
||||
}
|
||||
|
||||
export function buildAuctionBidScriptInvocation(
|
||||
keys: AuctionRedisKeys,
|
||||
input: AuctionBidScriptInput,
|
||||
): AuctionBidScriptInvocation {
|
||||
return {
|
||||
keys: [
|
||||
keys.liveStateKey,
|
||||
keys.bidHistoryKey,
|
||||
keys.bidRequestResultsKey,
|
||||
keys.bidRequestResultOrderKey,
|
||||
keys.deadlineQueueKey,
|
||||
],
|
||||
script: AUCTION_BID_SCRIPT,
|
||||
values: [
|
||||
input.matchId,
|
||||
String(input.bidderTeamIndex),
|
||||
String(input.bidPointAmount),
|
||||
String(input.maximumAuctionTeamMemberCount),
|
||||
String(input.minimumBidPointReservePerRemainingAuctionTeamMemberSlot),
|
||||
input.bidRequestId,
|
||||
input.bidderUserId,
|
||||
input.clientObservedAuctionLifecycleId,
|
||||
input.clientObservedCurrentBidRoundPlayerUserId,
|
||||
buildBidRequestPayloadFingerprint(input),
|
||||
String(input.maximumStoredBidRequestResultCount),
|
||||
String(input.minimumBidRequestResultReplayWindowMS),
|
||||
String(input.maximumStoredAuctionBidHistoryCount),
|
||||
],
|
||||
};
|
||||
}
|
||||
|
||||
export const AUCTION_BID_SCRIPT = defineAuctionRedisScript(
|
||||
'auction.bid',
|
||||
`
|
||||
local liveAuctionStateKey = KEYS[1]
|
||||
local auctionBidHistoryKey = KEYS[2]
|
||||
local bidRequestResultsKey = KEYS[3]
|
||||
local bidRequestResultOrderKey = KEYS[4]
|
||||
local bidRoundDeadlineQueueKey = KEYS[5]
|
||||
|
||||
local matchId = ARGV[1]
|
||||
local bidderTeamIndex = ARGV[2]
|
||||
local bidPointAmount = tonumber(ARGV[3])
|
||||
local maximumAuctionTeamMemberCount = tonumber(ARGV[4])
|
||||
local minimumBidPointReservePerRemainingAuctionTeamMemberSlot = tonumber(ARGV[5])
|
||||
local bidRequestId = ARGV[6]
|
||||
local bidderUserId = ARGV[7]
|
||||
local clientObservedAuctionLifecycleId = ARGV[8]
|
||||
local clientObservedCurrentBidRoundPlayerUserId = ARGV[9]
|
||||
local bidRequestPayloadFingerprint = ARGV[10]
|
||||
local maximumStoredBidRequestResultCount = tonumber(ARGV[11])
|
||||
local minimumBidRequestResultReplayWindowMS = tonumber(ARGV[12])
|
||||
local maximumStoredAuctionBidHistoryCount = tonumber(ARGV[13])
|
||||
|
||||
local redisTime = redis.call('TIME')
|
||||
local currentRedisTimestampMS = (tonumber(redisTime[1]) * 1000) + math.floor(tonumber(redisTime[2]) / 1000)
|
||||
|
||||
local function requestField(suffix)
|
||||
return bidRequestId .. ':' .. suffix
|
||||
end
|
||||
|
||||
local function hdelBidRequest(requestId)
|
||||
redis.call(
|
||||
'HDEL',
|
||||
bidRequestResultsKey,
|
||||
requestId .. ':fingerprint',
|
||||
requestId .. ':status',
|
||||
requestId .. ':revision',
|
||||
requestId .. ':rejectCode',
|
||||
requestId .. ':currentHighestBidPointAmount',
|
||||
requestId .. ':currentHighestBidderTeamIndex',
|
||||
requestId .. ':currentBidRoundDeadlineTimestampMS',
|
||||
requestId .. ':auctionBidHistoryEntryJson',
|
||||
requestId .. ':responseServerTimestampMS',
|
||||
requestId .. ':createdAtTimestampMS'
|
||||
)
|
||||
end
|
||||
|
||||
local function trimOldBidRequestResults()
|
||||
while redis.call('LLEN', bidRequestResultOrderKey) >= maximumStoredBidRequestResultCount do
|
||||
local oldestBidRequestId = redis.call('LINDEX', bidRequestResultOrderKey, 0)
|
||||
if not oldestBidRequestId then
|
||||
return
|
||||
end
|
||||
local createdAtTimestampMS = tonumber(redis.call('HGET', bidRequestResultsKey, oldestBidRequestId .. ':createdAtTimestampMS') or '0')
|
||||
if createdAtTimestampMS > currentRedisTimestampMS - minimumBidRequestResultReplayWindowMS then
|
||||
return
|
||||
end
|
||||
redis.call('LPOP', bidRequestResultOrderKey)
|
||||
hdelBidRequest(oldestBidRequestId)
|
||||
end
|
||||
end
|
||||
|
||||
local function replayExistingRequest()
|
||||
local status = redis.call('HGET', bidRequestResultsKey, requestField('status')) or ''
|
||||
return {
|
||||
'REPLAY',
|
||||
status,
|
||||
bidRequestId,
|
||||
redis.call('HGET', bidRequestResultsKey, requestField('revision')) or '',
|
||||
redis.call('HGET', bidRequestResultsKey, requestField('rejectCode')) or '',
|
||||
redis.call('HGET', bidRequestResultsKey, requestField('currentHighestBidPointAmount')) or '',
|
||||
redis.call('HGET', bidRequestResultsKey, requestField('currentHighestBidderTeamIndex')) or '',
|
||||
redis.call('HGET', bidRequestResultsKey, requestField('currentBidRoundDeadlineTimestampMS')) or '',
|
||||
redis.call('HGET', bidRequestResultsKey, requestField('auctionBidHistoryEntryJson')) or '',
|
||||
redis.call('HGET', bidRequestResultsKey, requestField('responseServerTimestampMS')) or tostring(currentRedisTimestampMS)
|
||||
}
|
||||
end
|
||||
|
||||
local existingFingerprint = redis.call('HGET', bidRequestResultsKey, requestField('fingerprint'))
|
||||
if existingFingerprint then
|
||||
if existingFingerprint ~= bidRequestPayloadFingerprint then
|
||||
return {'REJECTED', 'DUPLICATE_REQUEST_CONFLICT', bidRequestId, tostring(currentRedisTimestampMS)}
|
||||
end
|
||||
return replayExistingRequest()
|
||||
end
|
||||
|
||||
trimOldBidRequestResults()
|
||||
if redis.call('LLEN', bidRequestResultOrderKey) >= maximumStoredBidRequestResultCount then
|
||||
return {'REJECTED', 'BID_REQUEST_RESULT_LIMIT', bidRequestId, tostring(currentRedisTimestampMS)}
|
||||
end
|
||||
|
||||
local function storeRejectedRequest(rejectCode)
|
||||
redis.call(
|
||||
'HSET',
|
||||
bidRequestResultsKey,
|
||||
requestField('fingerprint'),
|
||||
bidRequestPayloadFingerprint,
|
||||
requestField('status'),
|
||||
'rejected',
|
||||
requestField('rejectCode'),
|
||||
rejectCode,
|
||||
requestField('responseServerTimestampMS'),
|
||||
tostring(currentRedisTimestampMS),
|
||||
requestField('createdAtTimestampMS'),
|
||||
tostring(currentRedisTimestampMS)
|
||||
)
|
||||
redis.call('RPUSH', bidRequestResultOrderKey, bidRequestId)
|
||||
return {'REJECTED', rejectCode, bidRequestId, tostring(currentRedisTimestampMS)}
|
||||
end
|
||||
|
||||
local phase = redis.call('HGET', liveAuctionStateKey, 'phase')
|
||||
if phase ~= 'bidding' then
|
||||
return storeRejectedRequest('PHASE')
|
||||
end
|
||||
|
||||
local auctionLifecycleId = redis.call('HGET', liveAuctionStateKey, 'auctionLifecycleId')
|
||||
local currentBidRoundPlayerUserId = redis.call('HGET', liveAuctionStateKey, 'currentBidRoundPlayerUserId')
|
||||
if auctionLifecycleId ~= clientObservedAuctionLifecycleId or currentBidRoundPlayerUserId ~= clientObservedCurrentBidRoundPlayerUserId then
|
||||
return storeRejectedRequest('STALE_BID_ROUND')
|
||||
end
|
||||
|
||||
local currentBidRoundDeadlineTimestampMS = tonumber(redis.call('HGET', liveAuctionStateKey, 'currentBidRoundDeadlineTimestampMS') or '0')
|
||||
if currentBidRoundDeadlineTimestampMS <= currentRedisTimestampMS then
|
||||
return storeRejectedRequest('EXPIRED')
|
||||
end
|
||||
|
||||
local currentHighestBidPointAmount = tonumber(redis.call('HGET', liveAuctionStateKey, 'currentHighestBidPointAmount') or '0')
|
||||
if bidPointAmount <= currentHighestBidPointAmount then
|
||||
return storeRejectedRequest('TOO_LOW')
|
||||
end
|
||||
|
||||
local remainingBidPointAmountField = 'team:' .. bidderTeamIndex .. ':remainingBidPointAmount'
|
||||
local assignedAuctionTeamMemberCountField = 'team:' .. bidderTeamIndex .. ':assignedAuctionTeamMemberCount'
|
||||
local remainingBidPointAmountRaw = redis.call('HGET', liveAuctionStateKey, remainingBidPointAmountField)
|
||||
if not remainingBidPointAmountRaw then
|
||||
return storeRejectedRequest('UNKNOWN_TEAM')
|
||||
end
|
||||
|
||||
local assignedAuctionTeamMemberCount = tonumber(redis.call('HGET', liveAuctionStateKey, assignedAuctionTeamMemberCountField) or '0')
|
||||
if assignedAuctionTeamMemberCount >= maximumAuctionTeamMemberCount then
|
||||
return storeRejectedRequest('FULL')
|
||||
end
|
||||
|
||||
local remainingBidPointAmount = tonumber(remainingBidPointAmountRaw)
|
||||
local remainingSlotsAfterBid = maximumAuctionTeamMemberCount - assignedAuctionTeamMemberCount - 1
|
||||
local requiredReserveAfterBid = remainingSlotsAfterBid * minimumBidPointReservePerRemainingAuctionTeamMemberSlot
|
||||
if bidPointAmount + requiredReserveAfterBid > remainingBidPointAmount then
|
||||
return storeRejectedRequest('INSUFFICIENT')
|
||||
end
|
||||
|
||||
if redis.call('LLEN', auctionBidHistoryKey) >= maximumStoredAuctionBidHistoryCount then
|
||||
return storeRejectedRequest('BID_HISTORY_LIMIT')
|
||||
end
|
||||
|
||||
local maximumBidRoundDurationSeconds = tonumber(redis.call('HGET', liveAuctionStateKey, 'maximumBidRoundDurationSeconds') or '0')
|
||||
local bidRoundExtensionSeconds = tonumber(redis.call('HGET', liveAuctionStateKey, 'bidRoundExtensionSeconds') or '0')
|
||||
local remainingBidRoundTimeMS = currentBidRoundDeadlineTimestampMS - currentRedisTimestampMS
|
||||
local nextRemainingBidRoundTimeMS = remainingBidRoundTimeMS
|
||||
local bidRoundExtensionMS = bidRoundExtensionSeconds * 1000
|
||||
local maximumBidRoundDurationMS = maximumBidRoundDurationSeconds * 1000
|
||||
if nextRemainingBidRoundTimeMS < bidRoundExtensionMS then
|
||||
nextRemainingBidRoundTimeMS = bidRoundExtensionMS
|
||||
end
|
||||
if nextRemainingBidRoundTimeMS > maximumBidRoundDurationMS then
|
||||
nextRemainingBidRoundTimeMS = maximumBidRoundDurationMS
|
||||
end
|
||||
local nextBidRoundDeadlineTimestampMS = currentRedisTimestampMS + nextRemainingBidRoundTimeMS
|
||||
|
||||
local revision = redis.call('HINCRBY', liveAuctionStateKey, 'revision', 1)
|
||||
local auctionBidHistoryEntryJson =
|
||||
'{"bidderTeamIndex":' .. bidderTeamIndex ..
|
||||
',"bidPointAmount":' .. tostring(bidPointAmount) ..
|
||||
',"bidderUserId":"' .. bidderUserId ..
|
||||
'","bidPlacedAtTimestampMS":' .. tostring(currentRedisTimestampMS) ..
|
||||
'}'
|
||||
|
||||
redis.call('RPUSH', auctionBidHistoryKey, auctionBidHistoryEntryJson)
|
||||
redis.call(
|
||||
'HSET',
|
||||
liveAuctionStateKey,
|
||||
'currentHighestBidPointAmount',
|
||||
tostring(bidPointAmount),
|
||||
'currentHighestBidderTeamIndex',
|
||||
bidderTeamIndex,
|
||||
'currentBidRoundDeadlineTimestampMS',
|
||||
tostring(nextBidRoundDeadlineTimestampMS)
|
||||
)
|
||||
redis.call('ZADD', bidRoundDeadlineQueueKey, nextBidRoundDeadlineTimestampMS, matchId)
|
||||
redis.call(
|
||||
'HSET',
|
||||
bidRequestResultsKey,
|
||||
requestField('fingerprint'),
|
||||
bidRequestPayloadFingerprint,
|
||||
requestField('status'),
|
||||
'ok',
|
||||
requestField('revision'),
|
||||
tostring(revision),
|
||||
requestField('currentHighestBidPointAmount'),
|
||||
tostring(bidPointAmount),
|
||||
requestField('currentHighestBidderTeamIndex'),
|
||||
bidderTeamIndex,
|
||||
requestField('currentBidRoundDeadlineTimestampMS'),
|
||||
tostring(nextBidRoundDeadlineTimestampMS),
|
||||
requestField('auctionBidHistoryEntryJson'),
|
||||
auctionBidHistoryEntryJson,
|
||||
requestField('responseServerTimestampMS'),
|
||||
tostring(currentRedisTimestampMS),
|
||||
requestField('createdAtTimestampMS'),
|
||||
tostring(currentRedisTimestampMS)
|
||||
)
|
||||
redis.call('RPUSH', bidRequestResultOrderKey, bidRequestId)
|
||||
|
||||
return {
|
||||
'OK',
|
||||
bidRequestId,
|
||||
tostring(revision),
|
||||
tostring(currentRedisTimestampMS),
|
||||
tostring(bidPointAmount),
|
||||
bidderTeamIndex,
|
||||
tostring(nextBidRoundDeadlineTimestampMS),
|
||||
auctionBidHistoryEntryJson
|
||||
}
|
||||
`,
|
||||
);
|
||||
|
||||
export const BID_RESULT_HASH_FIELD_SUFFIXES = BID_RESULT_HASH_SUFFIXES;
|
||||
@@ -0,0 +1 @@
|
||||
export const AUCTION_REDIS_CLIENT = Symbol('AUCTION_REDIS_CLIENT');
|
||||
@@ -0,0 +1,38 @@
|
||||
import { buildAuctionRedisKeys } from './auction-redis.keys';
|
||||
import {
|
||||
AUCTION_EXPIRE_PREPARE_SCRIPT,
|
||||
buildAuctionExpirePrepareScriptInvocation,
|
||||
} from './auction-redis.expire-prepare';
|
||||
|
||||
describe('auction expire prepare redis script contract', () => {
|
||||
it('builds EXPIRE_PREPARE keys and values', () => {
|
||||
const invocation = buildAuctionExpirePrepareScriptInvocation(
|
||||
buildAuctionRedisKeys('match-1'),
|
||||
{
|
||||
auctionStateTransitionId: 'expire-1',
|
||||
bidRoundExpiryRetryDelayMS: 3_000,
|
||||
matchId: 'match-1',
|
||||
},
|
||||
);
|
||||
|
||||
expect(invocation.script).toBe(AUCTION_EXPIRE_PREPARE_SCRIPT);
|
||||
expect(invocation.keys).toEqual([
|
||||
'auction:match-1:liveAuctionState',
|
||||
'auction:bidRoundDeadlineQueue',
|
||||
]);
|
||||
expect(invocation.values).toEqual(['match-1', 'expire-1', '3000']);
|
||||
});
|
||||
|
||||
it('freezes expiry context with Redis TIME and expiring phase', () => {
|
||||
expect(AUCTION_EXPIRE_PREPARE_SCRIPT.lua).toContain("redis.call('TIME')");
|
||||
expect(AUCTION_EXPIRE_PREPARE_SCRIPT.lua).toContain("'phase'");
|
||||
expect(AUCTION_EXPIRE_PREPARE_SCRIPT.lua).toContain("'expiring'");
|
||||
expect(AUCTION_EXPIRE_PREPARE_SCRIPT.lua).toContain(
|
||||
'bidRoundExpiryRevision',
|
||||
);
|
||||
expect(AUCTION_EXPIRE_PREPARE_SCRIPT.lua).toContain(
|
||||
'bidRoundExpiryWinningBidderTeamIndex',
|
||||
);
|
||||
expect(AUCTION_EXPIRE_PREPARE_SCRIPT.lua).toContain("'ZADD'");
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,107 @@
|
||||
import type { AuctionRedisKeys } from './auction-redis.keys';
|
||||
import { defineAuctionRedisScript } from './auction-redis.scripts';
|
||||
|
||||
export interface AuctionExpirePrepareScriptInput {
|
||||
auctionStateTransitionId: string;
|
||||
bidRoundExpiryRetryDelayMS: number;
|
||||
matchId: string;
|
||||
}
|
||||
|
||||
export interface AuctionExpirePrepareScriptInvocation {
|
||||
keys: string[];
|
||||
script: typeof AUCTION_EXPIRE_PREPARE_SCRIPT;
|
||||
values: string[];
|
||||
}
|
||||
|
||||
export function buildAuctionExpirePrepareScriptInvocation(
|
||||
keys: AuctionRedisKeys,
|
||||
input: AuctionExpirePrepareScriptInput,
|
||||
): AuctionExpirePrepareScriptInvocation {
|
||||
return {
|
||||
keys: [keys.liveStateKey, keys.deadlineQueueKey],
|
||||
script: AUCTION_EXPIRE_PREPARE_SCRIPT,
|
||||
values: [
|
||||
input.matchId,
|
||||
input.auctionStateTransitionId,
|
||||
String(input.bidRoundExpiryRetryDelayMS),
|
||||
],
|
||||
};
|
||||
}
|
||||
|
||||
export const AUCTION_EXPIRE_PREPARE_SCRIPT = defineAuctionRedisScript(
|
||||
'auction.expirePrepare',
|
||||
`
|
||||
local liveAuctionStateKey = KEYS[1]
|
||||
local bidRoundDeadlineQueueKey = KEYS[2]
|
||||
|
||||
local matchId = ARGV[1]
|
||||
local auctionStateTransitionId = ARGV[2]
|
||||
local bidRoundExpiryRetryDelayMS = tonumber(ARGV[3])
|
||||
|
||||
local redisTime = redis.call('TIME')
|
||||
local currentRedisTimestampMS = (tonumber(redisTime[1]) * 1000) + math.floor(tonumber(redisTime[2]) / 1000)
|
||||
|
||||
local phase = redis.call('HGET', liveAuctionStateKey, 'phase')
|
||||
if phase == 'expiring' then
|
||||
return {
|
||||
'REPLAY',
|
||||
redis.call('HGET', liveAuctionStateKey, 'bidRoundExpiryDecision') or '',
|
||||
redis.call('HGET', liveAuctionStateKey, 'bidRoundExpiryAuctionStateTransitionId') or '',
|
||||
redis.call('HGET', liveAuctionStateKey, 'bidRoundExpiryRevision') or '',
|
||||
tostring(currentRedisTimestampMS)
|
||||
}
|
||||
end
|
||||
if phase ~= 'bidding' then
|
||||
redis.call('ZREM', bidRoundDeadlineQueueKey, matchId)
|
||||
return {'NOOP', 'PHASE', tostring(currentRedisTimestampMS)}
|
||||
end
|
||||
|
||||
local currentBidRoundDeadlineTimestampMS = tonumber(redis.call('HGET', liveAuctionStateKey, 'currentBidRoundDeadlineTimestampMS') or '0')
|
||||
if currentBidRoundDeadlineTimestampMS > currentRedisTimestampMS then
|
||||
return {'NOOP', 'NOT_DUE', tostring(currentRedisTimestampMS)}
|
||||
end
|
||||
|
||||
local currentHighestBidPointAmount = tonumber(redis.call('HGET', liveAuctionStateKey, 'currentHighestBidPointAmount') or '0')
|
||||
local currentHighestBidderTeamIndex = redis.call('HGET', liveAuctionStateKey, 'currentHighestBidderTeamIndex') or '-1'
|
||||
local bidRoundExpiryDecision = 'passed'
|
||||
if currentHighestBidPointAmount > 0 then
|
||||
bidRoundExpiryDecision = 'sold'
|
||||
end
|
||||
|
||||
local revision = redis.call('HINCRBY', liveAuctionStateKey, 'revision', 1)
|
||||
redis.call(
|
||||
'HSET',
|
||||
liveAuctionStateKey,
|
||||
'phase',
|
||||
'expiring',
|
||||
'bidRoundExpiryDecision',
|
||||
bidRoundExpiryDecision,
|
||||
'bidRoundExpiryAuctionStateTransitionId',
|
||||
auctionStateTransitionId,
|
||||
'bidRoundExpiryPlayerUserId',
|
||||
redis.call('HGET', liveAuctionStateKey, 'currentBidRoundPlayerUserId') or '',
|
||||
'bidRoundExpiryPlayerOrderIndex',
|
||||
redis.call('HGET', liveAuctionStateKey, 'currentAuctionPlayerOrderIndex') or '',
|
||||
'bidRoundExpiryWinningBidPointAmount',
|
||||
tostring(currentHighestBidPointAmount),
|
||||
'bidRoundExpiryWinningBidderTeamIndex',
|
||||
currentHighestBidderTeamIndex,
|
||||
'bidRoundExpiryRevision',
|
||||
tostring(revision)
|
||||
)
|
||||
redis.call(
|
||||
'ZADD',
|
||||
bidRoundDeadlineQueueKey,
|
||||
currentRedisTimestampMS + bidRoundExpiryRetryDelayMS,
|
||||
matchId
|
||||
)
|
||||
|
||||
return {
|
||||
'OK',
|
||||
bidRoundExpiryDecision,
|
||||
auctionStateTransitionId,
|
||||
tostring(revision),
|
||||
tostring(currentRedisTimestampMS)
|
||||
}
|
||||
`,
|
||||
);
|
||||
@@ -0,0 +1,29 @@
|
||||
import { buildAuctionRedisKeys } from './auction-redis.keys';
|
||||
|
||||
describe('auction redis keys', () => {
|
||||
it('builds lifecycle-safe key names from match id', () => {
|
||||
expect(buildAuctionRedisKeys('match-1')).toMatchObject({
|
||||
actionRequestResultOrderKey: 'auction:match-1:auctionActionRequestResultOrder',
|
||||
actionRequestResultsKey: 'auction:match-1:auctionActionRequestResults',
|
||||
appliedTransitionIdsKey: 'auction:match-1:appliedAuctionStateTransitionIds',
|
||||
bidHistoryKey: 'auction:match-1:auctionBidHistory',
|
||||
bidRequestResultOrderKey: 'auction:match-1:bidRequestResultOrder',
|
||||
bidRequestResultsKey: 'auction:match-1:bidRequestResults',
|
||||
deadlineQueueKey: 'auction:bidRoundDeadlineQueue',
|
||||
durabilityDeadLetterQueueKey: 'auction:auctionDurabilityDeadLetterQueue',
|
||||
durabilityPayloadKeyPrefix: 'auction:match-1:durability:',
|
||||
durabilityRetryQueueKey: 'auction:auctionDurabilityRetryQueue',
|
||||
liveStateKey: 'auction:match-1:liveAuctionState',
|
||||
rehydrateLockKey: 'auction:match-1:rehydrateLock',
|
||||
stateTransitionLockKey: 'auction:match-1:auctionStateTransitionLock',
|
||||
structureStateKey: 'auction:match-1:auctionStructureState',
|
||||
});
|
||||
});
|
||||
|
||||
it('builds transition durability payload keys', () => {
|
||||
const keys = buildAuctionRedisKeys('match-1');
|
||||
expect(keys.durabilityPayloadKey('transition-1')).toBe(
|
||||
'auction:match-1:durability:transition-1',
|
||||
);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,47 @@
|
||||
export const AUCTION_BID_ROUND_DEADLINE_QUEUE_KEY =
|
||||
'auction:bidRoundDeadlineQueue';
|
||||
export const AUCTION_DURABILITY_RETRY_QUEUE_KEY =
|
||||
'auction:auctionDurabilityRetryQueue';
|
||||
export const AUCTION_DURABILITY_DEAD_LETTER_QUEUE_KEY =
|
||||
'auction:auctionDurabilityDeadLetterQueue';
|
||||
|
||||
export interface AuctionRedisKeys {
|
||||
actionRequestResultOrderKey: string;
|
||||
actionRequestResultsKey: string;
|
||||
appliedTransitionIdsKey: string;
|
||||
bidHistoryKey: string;
|
||||
bidRequestResultOrderKey: string;
|
||||
bidRequestResultsKey: string;
|
||||
deadlineQueueKey: string;
|
||||
durabilityDeadLetterQueueKey: string;
|
||||
durabilityPayloadKey: (auctionStateTransitionId: string) => string;
|
||||
durabilityPayloadKeyPrefix: string;
|
||||
durabilityRetryQueueKey: string;
|
||||
liveStateKey: string;
|
||||
rehydrateLockKey: string;
|
||||
stateTransitionLockKey: string;
|
||||
structureStateKey: string;
|
||||
}
|
||||
|
||||
export function buildAuctionRedisKeys(matchId: string): AuctionRedisKeys {
|
||||
const prefix = `auction:${matchId}`;
|
||||
const durabilityPayloadKeyPrefix = `${prefix}:durability:`;
|
||||
return {
|
||||
actionRequestResultOrderKey: `${prefix}:auctionActionRequestResultOrder`,
|
||||
actionRequestResultsKey: `${prefix}:auctionActionRequestResults`,
|
||||
appliedTransitionIdsKey: `${prefix}:appliedAuctionStateTransitionIds`,
|
||||
bidHistoryKey: `${prefix}:auctionBidHistory`,
|
||||
bidRequestResultOrderKey: `${prefix}:bidRequestResultOrder`,
|
||||
bidRequestResultsKey: `${prefix}:bidRequestResults`,
|
||||
deadlineQueueKey: AUCTION_BID_ROUND_DEADLINE_QUEUE_KEY,
|
||||
durabilityDeadLetterQueueKey: AUCTION_DURABILITY_DEAD_LETTER_QUEUE_KEY,
|
||||
durabilityPayloadKey: (auctionStateTransitionId: string) =>
|
||||
`${durabilityPayloadKeyPrefix}${auctionStateTransitionId}`,
|
||||
durabilityPayloadKeyPrefix,
|
||||
durabilityRetryQueueKey: AUCTION_DURABILITY_RETRY_QUEUE_KEY,
|
||||
liveStateKey: `${prefix}:liveAuctionState`,
|
||||
rehydrateLockKey: `${prefix}:rehydrateLock`,
|
||||
stateTransitionLockKey: `${prefix}:auctionStateTransitionLock`,
|
||||
structureStateKey: `${prefix}:auctionStructureState`,
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,100 @@
|
||||
import { Logger, Module } from '@nestjs/common';
|
||||
import { createClient } from 'redis';
|
||||
import { SecretModule } from '../../global/secret/secret.module';
|
||||
import { SecretService } from '../../global/secret/secret.service';
|
||||
import {
|
||||
assertDistinctRedisInstances,
|
||||
resolveRedisClientOptions,
|
||||
} from '../../global/redis/redis.config';
|
||||
import { AUCTION_REDIS_CLIENT } from './auction-redis.constants';
|
||||
import {
|
||||
AuctionRedisService,
|
||||
type AuctionRedisClient,
|
||||
} from './auction-redis.service';
|
||||
import { AuctionRedisCommandService } from './auction-redis-command.service';
|
||||
import { AuctionRedisStateReaderService } from './auction-redis-state-reader.service';
|
||||
|
||||
async function readFirstSecret(
|
||||
secretService: SecretService,
|
||||
keys: string[],
|
||||
): Promise<string | undefined> {
|
||||
for (const key of keys) {
|
||||
const value = await secretService.get<string>(key, '');
|
||||
const trimmed = value.trim();
|
||||
if (trimmed) return trimmed;
|
||||
}
|
||||
return undefined;
|
||||
}
|
||||
|
||||
@Module({
|
||||
imports: [SecretModule],
|
||||
providers: [
|
||||
{
|
||||
provide: AUCTION_REDIS_CLIENT,
|
||||
inject: [SecretService],
|
||||
useFactory: async (
|
||||
secretService: SecretService,
|
||||
): Promise<AuctionRedisClient> => {
|
||||
await secretService.ready();
|
||||
|
||||
const [
|
||||
redisUrl,
|
||||
redisEndpoint,
|
||||
auctionRedisUrl,
|
||||
auctionRedisEndpoint,
|
||||
auctionRedisUsername,
|
||||
auctionRedisPassword,
|
||||
] = await Promise.all([
|
||||
readFirstSecret(secretService, ['REDIS_URL', 'GARNET_URL']),
|
||||
readFirstSecret(secretService, ['REDIS_ENDPOINT', 'GARNET_ENDPOINT']),
|
||||
readFirstSecret(secretService, ['AUCTION_REDIS_URL']),
|
||||
readFirstSecret(secretService, ['AUCTION_REDIS_ENDPOINT']),
|
||||
readFirstSecret(secretService, [
|
||||
'AUCTION_REDIS_USERNAME',
|
||||
'AUCTION_REDIS_USERID',
|
||||
]),
|
||||
readFirstSecret(secretService, ['AUCTION_REDIS_PASSWORD']),
|
||||
]);
|
||||
|
||||
const redisOptions = resolveRedisClientOptions({
|
||||
endpoint: redisEndpoint,
|
||||
endpointEnvName: 'REDIS_ENDPOINT',
|
||||
url: redisUrl,
|
||||
urlEnvName: 'REDIS_URL',
|
||||
});
|
||||
const auctionRedisOptions = resolveRedisClientOptions({
|
||||
endpoint: auctionRedisEndpoint,
|
||||
endpointEnvName: 'AUCTION_REDIS_ENDPOINT',
|
||||
password: auctionRedisPassword,
|
||||
url: auctionRedisUrl,
|
||||
urlEnvName: 'AUCTION_REDIS_URL',
|
||||
username: auctionRedisUsername,
|
||||
});
|
||||
assertDistinctRedisInstances(redisOptions.url, auctionRedisOptions.url);
|
||||
|
||||
const logger = new Logger('AuctionRedisClient');
|
||||
const client = createClient(auctionRedisOptions);
|
||||
client.on('error', (error) => {
|
||||
logger.error(
|
||||
`Auction Redis client error: ${error?.message ?? error}`,
|
||||
);
|
||||
});
|
||||
|
||||
await client.connect();
|
||||
logger.log('Auction Redis connected');
|
||||
|
||||
return client;
|
||||
},
|
||||
},
|
||||
AuctionRedisService,
|
||||
AuctionRedisCommandService,
|
||||
AuctionRedisStateReaderService,
|
||||
],
|
||||
exports: [
|
||||
AuctionRedisService,
|
||||
AuctionRedisCommandService,
|
||||
AuctionRedisStateReaderService,
|
||||
AUCTION_REDIS_CLIENT,
|
||||
],
|
||||
})
|
||||
export class AuctionRedisModule {}
|
||||
@@ -0,0 +1,77 @@
|
||||
import { buildAuctionRedisKeys } from './auction-redis.keys';
|
||||
import {
|
||||
AUCTION_RESERVE_ACTION_REQUEST_SCRIPT,
|
||||
buildActionRequestPayloadFingerprint,
|
||||
buildAuctionReserveActionRequestScriptInvocation,
|
||||
} from './auction-redis.reserve-action';
|
||||
|
||||
describe('auction reserve action request redis script contract', () => {
|
||||
it('builds RESERVE_AUCTION_ACTION_REQUEST keys and values', () => {
|
||||
const invocation = buildAuctionReserveActionRequestScriptInvocation(
|
||||
buildAuctionRedisKeys('match-1'),
|
||||
{
|
||||
auctionActionRequestId: 'request-1',
|
||||
auctionActionType: 'sold',
|
||||
auctionStateTransitionId: 'transition-1',
|
||||
clientObservedAuctionLifecycleId: 'life-1',
|
||||
clientObservedPhase: 'bidding',
|
||||
clientObservedRevision: 8,
|
||||
leaseDurationMS: 10_000,
|
||||
maximumStoredAuctionActionRequestResultCount: 100,
|
||||
minimumAuctionActionRequestResultReplayWindowMS: 60_000,
|
||||
newAuctionLifecycleId: undefined,
|
||||
processingOwnerToken: 'owner-1',
|
||||
},
|
||||
);
|
||||
|
||||
expect(invocation.script).toBe(AUCTION_RESERVE_ACTION_REQUEST_SCRIPT);
|
||||
expect(invocation.keys).toEqual([
|
||||
'auction:match-1:auctionActionRequestResults',
|
||||
'auction:match-1:auctionActionRequestResultOrder',
|
||||
]);
|
||||
expect(invocation.values).toEqual([
|
||||
'life-1',
|
||||
'request-1',
|
||||
'sold',
|
||||
'transition-1',
|
||||
'',
|
||||
'owner-1',
|
||||
'10000',
|
||||
'100',
|
||||
'60000',
|
||||
'life-1|request-1|sold|8|bidding||',
|
||||
]);
|
||||
});
|
||||
|
||||
it('builds stable action request fingerprints', () => {
|
||||
expect(
|
||||
buildActionRequestPayloadFingerprint({
|
||||
auctionActionRequestId: 'request-1',
|
||||
auctionActionType: 'next',
|
||||
clientObservedAuctionLifecycleId: 'life-1',
|
||||
clientObservedCurrentAuctionPlayerOrderIndex: 3,
|
||||
clientObservedCurrentBidRoundPlayerUserId: 'player-1',
|
||||
clientObservedPhase: 'sold',
|
||||
clientObservedRevision: 9,
|
||||
}),
|
||||
).toBe('life-1|request-1|next|9|sold|player-1|3');
|
||||
});
|
||||
|
||||
it('keeps lease version and replay guards in Lua', () => {
|
||||
expect(AUCTION_RESERVE_ACTION_REQUEST_SCRIPT.lua).toContain(
|
||||
"redis.call('TIME')",
|
||||
);
|
||||
expect(AUCTION_RESERVE_ACTION_REQUEST_SCRIPT.lua).toContain(
|
||||
'processingLeaseVersion',
|
||||
);
|
||||
expect(AUCTION_RESERVE_ACTION_REQUEST_SCRIPT.lua).toContain(
|
||||
'ACTION_REQUEST_IN_PROGRESS',
|
||||
);
|
||||
expect(AUCTION_RESERVE_ACTION_REQUEST_SCRIPT.lua).toContain(
|
||||
'ACTION_REQUEST_RESULT_LIMIT',
|
||||
);
|
||||
expect(AUCTION_RESERVE_ACTION_REQUEST_SCRIPT.lua).toContain(
|
||||
'DUPLICATE_ACTION_REQUEST_CONFLICT',
|
||||
);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,233 @@
|
||||
import type { AuctionRedisKeys } from './auction-redis.keys';
|
||||
import { defineAuctionRedisScript } from './auction-redis.scripts';
|
||||
|
||||
export interface AuctionReserveActionRequestScriptInput {
|
||||
auctionActionRequestId: string;
|
||||
auctionActionType: string;
|
||||
auctionStateTransitionId: string;
|
||||
clientObservedAuctionLifecycleId: string;
|
||||
clientObservedCurrentAuctionPlayerOrderIndex?: number;
|
||||
clientObservedCurrentBidRoundPlayerUserId?: string;
|
||||
clientObservedPhase: string;
|
||||
clientObservedRevision: number;
|
||||
leaseDurationMS: number;
|
||||
maximumStoredAuctionActionRequestResultCount: number;
|
||||
minimumAuctionActionRequestResultReplayWindowMS: number;
|
||||
newAuctionLifecycleId?: string;
|
||||
processingOwnerToken: string;
|
||||
}
|
||||
|
||||
export interface AuctionReserveActionRequestScriptInvocation {
|
||||
keys: string[];
|
||||
script: typeof AUCTION_RESERVE_ACTION_REQUEST_SCRIPT;
|
||||
values: string[];
|
||||
}
|
||||
|
||||
export function buildActionRequestPayloadFingerprint(params: {
|
||||
auctionActionRequestId: string;
|
||||
auctionActionType: string;
|
||||
clientObservedAuctionLifecycleId: string;
|
||||
clientObservedCurrentAuctionPlayerOrderIndex?: number;
|
||||
clientObservedCurrentBidRoundPlayerUserId?: string;
|
||||
clientObservedPhase: string;
|
||||
clientObservedRevision: number;
|
||||
}): string {
|
||||
return [
|
||||
params.clientObservedAuctionLifecycleId,
|
||||
params.auctionActionRequestId,
|
||||
params.auctionActionType,
|
||||
params.clientObservedRevision,
|
||||
params.clientObservedPhase,
|
||||
params.clientObservedCurrentBidRoundPlayerUserId ?? '',
|
||||
params.clientObservedCurrentAuctionPlayerOrderIndex ?? '',
|
||||
].join('|');
|
||||
}
|
||||
|
||||
export function buildAuctionReserveActionRequestScriptInvocation(
|
||||
keys: AuctionRedisKeys,
|
||||
input: AuctionReserveActionRequestScriptInput,
|
||||
): AuctionReserveActionRequestScriptInvocation {
|
||||
return {
|
||||
keys: [keys.actionRequestResultsKey, keys.actionRequestResultOrderKey],
|
||||
script: AUCTION_RESERVE_ACTION_REQUEST_SCRIPT,
|
||||
values: [
|
||||
input.clientObservedAuctionLifecycleId,
|
||||
input.auctionActionRequestId,
|
||||
input.auctionActionType,
|
||||
input.auctionStateTransitionId,
|
||||
input.newAuctionLifecycleId ?? '',
|
||||
input.processingOwnerToken,
|
||||
String(input.leaseDurationMS),
|
||||
String(input.maximumStoredAuctionActionRequestResultCount),
|
||||
String(input.minimumAuctionActionRequestResultReplayWindowMS),
|
||||
buildActionRequestPayloadFingerprint(input),
|
||||
],
|
||||
};
|
||||
}
|
||||
|
||||
export const AUCTION_RESERVE_ACTION_REQUEST_SCRIPT = defineAuctionRedisScript(
|
||||
'auction.reserveActionRequest',
|
||||
`
|
||||
local auctionActionRequestResultsKey = KEYS[1]
|
||||
local auctionActionRequestResultOrderKey = KEYS[2]
|
||||
|
||||
local clientObservedAuctionLifecycleId = ARGV[1]
|
||||
local auctionActionRequestId = ARGV[2]
|
||||
local auctionActionType = ARGV[3]
|
||||
local auctionStateTransitionId = ARGV[4]
|
||||
local newAuctionLifecycleId = ARGV[5]
|
||||
local processingOwnerToken = ARGV[6]
|
||||
local leaseDurationMS = tonumber(ARGV[7])
|
||||
local maximumStoredAuctionActionRequestResultCount = tonumber(ARGV[8])
|
||||
local minimumAuctionActionRequestResultReplayWindowMS = tonumber(ARGV[9])
|
||||
local actionRequestPayloadFingerprint = ARGV[10]
|
||||
|
||||
local redisTime = redis.call('TIME')
|
||||
local currentRedisTimestampMS = (tonumber(redisTime[1]) * 1000) + math.floor(tonumber(redisTime[2]) / 1000)
|
||||
local actionRequestScopeKey = clientObservedAuctionLifecycleId .. ':' .. auctionActionRequestId
|
||||
|
||||
local function requestField(suffix)
|
||||
return actionRequestScopeKey .. ':' .. suffix
|
||||
end
|
||||
|
||||
local function hdelActionRequest(scopeKey)
|
||||
redis.call(
|
||||
'HDEL',
|
||||
auctionActionRequestResultsKey,
|
||||
scopeKey .. ':fingerprint',
|
||||
scopeKey .. ':status',
|
||||
scopeKey .. ':revision',
|
||||
scopeKey .. ':rejectCode',
|
||||
scopeKey .. ':auctionActionType',
|
||||
scopeKey .. ':auctionStateTransitionId',
|
||||
scopeKey .. ':newAuctionLifecycleId',
|
||||
scopeKey .. ':processingOwnerToken',
|
||||
scopeKey .. ':processingLeaseExpiresAtTimestampMS',
|
||||
scopeKey .. ':processingLeaseVersion',
|
||||
scopeKey .. ':responseServerTimestampMS',
|
||||
scopeKey .. ':responseJson',
|
||||
scopeKey .. ':requiresRefetch',
|
||||
scopeKey .. ':createdAtTimestampMS'
|
||||
)
|
||||
end
|
||||
|
||||
local function trimOldActionRequestResults()
|
||||
while redis.call('LLEN', auctionActionRequestResultOrderKey) >= maximumStoredAuctionActionRequestResultCount do
|
||||
local oldestActionRequestScopeKey = redis.call('LINDEX', auctionActionRequestResultOrderKey, 0)
|
||||
if not oldestActionRequestScopeKey then
|
||||
return
|
||||
end
|
||||
local createdAtTimestampMS = tonumber(redis.call('HGET', auctionActionRequestResultsKey, oldestActionRequestScopeKey .. ':createdAtTimestampMS') or '0')
|
||||
if createdAtTimestampMS > currentRedisTimestampMS - minimumAuctionActionRequestResultReplayWindowMS then
|
||||
return
|
||||
end
|
||||
redis.call('LPOP', auctionActionRequestResultOrderKey)
|
||||
hdelActionRequest(oldestActionRequestScopeKey)
|
||||
end
|
||||
end
|
||||
|
||||
local existingFingerprint = redis.call('HGET', auctionActionRequestResultsKey, requestField('fingerprint'))
|
||||
if existingFingerprint then
|
||||
if existingFingerprint ~= actionRequestPayloadFingerprint then
|
||||
return {'REJECTED', 'DUPLICATE_ACTION_REQUEST_CONFLICT', actionRequestScopeKey, tostring(currentRedisTimestampMS)}
|
||||
end
|
||||
|
||||
local status = redis.call('HGET', auctionActionRequestResultsKey, requestField('status')) or ''
|
||||
if status == 'applied' or status == 'rejected' then
|
||||
return {
|
||||
'REPLAY',
|
||||
status,
|
||||
actionRequestScopeKey,
|
||||
redis.call('HGET', auctionActionRequestResultsKey, requestField('revision')) or '',
|
||||
redis.call('HGET', auctionActionRequestResultsKey, requestField('rejectCode')) or '',
|
||||
redis.call('HGET', auctionActionRequestResultsKey, requestField('auctionStateTransitionId')) or '',
|
||||
redis.call('HGET', auctionActionRequestResultsKey, requestField('newAuctionLifecycleId')) or '',
|
||||
redis.call('HGET', auctionActionRequestResultsKey, requestField('processingLeaseVersion')) or '',
|
||||
redis.call('HGET', auctionActionRequestResultsKey, requestField('responseServerTimestampMS')) or tostring(currentRedisTimestampMS),
|
||||
redis.call('HGET', auctionActionRequestResultsKey, requestField('responseJson')) or '',
|
||||
redis.call('HGET', auctionActionRequestResultsKey, requestField('requiresRefetch')) or ''
|
||||
}
|
||||
end
|
||||
|
||||
local leaseExpiresAtTimestampMS = tonumber(redis.call('HGET', auctionActionRequestResultsKey, requestField('processingLeaseExpiresAtTimestampMS')) or '0')
|
||||
local storedOwnerToken = redis.call('HGET', auctionActionRequestResultsKey, requestField('processingOwnerToken')) or ''
|
||||
local storedLeaseVersion = tonumber(redis.call('HGET', auctionActionRequestResultsKey, requestField('processingLeaseVersion')) or '1')
|
||||
if leaseExpiresAtTimestampMS > currentRedisTimestampMS and storedOwnerToken ~= processingOwnerToken then
|
||||
return {'REJECTED', 'ACTION_REQUEST_IN_PROGRESS', actionRequestScopeKey, tostring(currentRedisTimestampMS)}
|
||||
end
|
||||
|
||||
local nextLeaseVersion = storedLeaseVersion
|
||||
local wasLeaseExpired = '0'
|
||||
if leaseExpiresAtTimestampMS <= currentRedisTimestampMS then
|
||||
nextLeaseVersion = storedLeaseVersion + 1
|
||||
wasLeaseExpired = '1'
|
||||
end
|
||||
|
||||
redis.call(
|
||||
'HSET',
|
||||
auctionActionRequestResultsKey,
|
||||
requestField('status'),
|
||||
'processing',
|
||||
requestField('processingOwnerToken'),
|
||||
processingOwnerToken,
|
||||
requestField('processingLeaseExpiresAtTimestampMS'),
|
||||
tostring(currentRedisTimestampMS + leaseDurationMS),
|
||||
requestField('processingLeaseVersion'),
|
||||
tostring(nextLeaseVersion),
|
||||
requestField('responseServerTimestampMS'),
|
||||
tostring(currentRedisTimestampMS)
|
||||
)
|
||||
|
||||
return {
|
||||
'RESERVED',
|
||||
actionRequestScopeKey,
|
||||
redis.call('HGET', auctionActionRequestResultsKey, requestField('auctionStateTransitionId')) or auctionStateTransitionId,
|
||||
redis.call('HGET', auctionActionRequestResultsKey, requestField('newAuctionLifecycleId')) or '',
|
||||
tostring(nextLeaseVersion),
|
||||
wasLeaseExpired,
|
||||
tostring(currentRedisTimestampMS)
|
||||
}
|
||||
end
|
||||
|
||||
trimOldActionRequestResults()
|
||||
if redis.call('LLEN', auctionActionRequestResultOrderKey) >= maximumStoredAuctionActionRequestResultCount then
|
||||
return {'REJECTED', 'ACTION_REQUEST_RESULT_LIMIT', actionRequestScopeKey, tostring(currentRedisTimestampMS)}
|
||||
end
|
||||
|
||||
redis.call(
|
||||
'HSET',
|
||||
auctionActionRequestResultsKey,
|
||||
requestField('fingerprint'),
|
||||
actionRequestPayloadFingerprint,
|
||||
requestField('status'),
|
||||
'processing',
|
||||
requestField('auctionActionType'),
|
||||
auctionActionType,
|
||||
requestField('auctionStateTransitionId'),
|
||||
auctionStateTransitionId,
|
||||
requestField('newAuctionLifecycleId'),
|
||||
newAuctionLifecycleId,
|
||||
requestField('processingOwnerToken'),
|
||||
processingOwnerToken,
|
||||
requestField('processingLeaseExpiresAtTimestampMS'),
|
||||
tostring(currentRedisTimestampMS + leaseDurationMS),
|
||||
requestField('processingLeaseVersion'),
|
||||
'1',
|
||||
requestField('responseServerTimestampMS'),
|
||||
tostring(currentRedisTimestampMS),
|
||||
requestField('createdAtTimestampMS'),
|
||||
tostring(currentRedisTimestampMS)
|
||||
)
|
||||
redis.call('RPUSH', auctionActionRequestResultOrderKey, actionRequestScopeKey)
|
||||
|
||||
return {
|
||||
'RESERVED',
|
||||
actionRequestScopeKey,
|
||||
auctionStateTransitionId,
|
||||
newAuctionLifecycleId,
|
||||
'1',
|
||||
'0',
|
||||
tostring(currentRedisTimestampMS)
|
||||
}
|
||||
`,
|
||||
);
|
||||
@@ -0,0 +1,14 @@
|
||||
import { createHash } from 'crypto';
|
||||
import { defineAuctionRedisScript } from './auction-redis.scripts';
|
||||
|
||||
describe('auction redis scripts', () => {
|
||||
it('stores normalized Lua and its SHA1', () => {
|
||||
const script = defineAuctionRedisScript('test', 'return 1\n');
|
||||
|
||||
expect(script).toEqual({
|
||||
lua: 'return 1\n',
|
||||
name: 'test',
|
||||
sha: createHash('sha1').update('return 1\n').digest('hex'),
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,18 @@
|
||||
import { createHash } from 'crypto';
|
||||
|
||||
export interface AuctionRedisScriptDefinition {
|
||||
lua: string;
|
||||
name: string;
|
||||
sha: string;
|
||||
}
|
||||
|
||||
export function defineAuctionRedisScript(
|
||||
name: string,
|
||||
lua: string,
|
||||
): AuctionRedisScriptDefinition {
|
||||
return {
|
||||
lua,
|
||||
name,
|
||||
sha: createHash('sha1').update(lua).digest('hex'),
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,64 @@
|
||||
import {
|
||||
AuctionRedisNoscriptError,
|
||||
AuctionRedisService,
|
||||
} from './auction-redis.service';
|
||||
|
||||
function makeService(sendCommand: jest.Mock) {
|
||||
const client = {
|
||||
destroy: jest.fn(),
|
||||
quit: jest.fn().mockResolvedValue(undefined),
|
||||
sendCommand,
|
||||
};
|
||||
|
||||
return new AuctionRedisService(client as never);
|
||||
}
|
||||
|
||||
describe('AuctionRedisService', () => {
|
||||
it('uses Redis TIME as the timestamp source', async () => {
|
||||
const service = makeService(jest.fn().mockResolvedValue(['1781700000', '123000']));
|
||||
|
||||
await expect(service.getCurrentRedisTimestampMS()).resolves.toBe(
|
||||
1_781_700_000_123,
|
||||
);
|
||||
});
|
||||
|
||||
it('loads and retries a script once when EVALSHA returns NOSCRIPT', async () => {
|
||||
const sendCommand = jest
|
||||
.fn()
|
||||
.mockRejectedValueOnce(new AuctionRedisNoscriptError())
|
||||
.mockResolvedValueOnce('sha-from-redis')
|
||||
.mockResolvedValueOnce(['ok']);
|
||||
const service = makeService(sendCommand);
|
||||
|
||||
await expect(
|
||||
service.evalShaWithReload({
|
||||
keys: ['auction:state:1'],
|
||||
script: 'return 1',
|
||||
scriptSha: 'old-sha',
|
||||
values: ['v1'],
|
||||
}),
|
||||
).resolves.toEqual(['ok']);
|
||||
|
||||
expect(sendCommand.mock.calls).toEqual([
|
||||
[['EVALSHA', 'old-sha', '1', 'auction:state:1', 'v1']],
|
||||
[['SCRIPT', 'LOAD', 'return 1']],
|
||||
[['EVALSHA', 'sha-from-redis', '1', 'auction:state:1', 'v1']],
|
||||
]);
|
||||
});
|
||||
|
||||
it('does not reload scripts for non-NOSCRIPT errors', async () => {
|
||||
const error = new Error('OOM command not allowed');
|
||||
const sendCommand = jest.fn().mockRejectedValue(error);
|
||||
const service = makeService(sendCommand);
|
||||
|
||||
await expect(
|
||||
service.evalShaWithReload({
|
||||
keys: [],
|
||||
script: 'return 1',
|
||||
scriptSha: 'sha',
|
||||
values: [],
|
||||
}),
|
||||
).rejects.toBe(error);
|
||||
expect(sendCommand).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,131 @@
|
||||
import { Inject, Injectable, OnModuleDestroy } from '@nestjs/common';
|
||||
import type { createClient } from 'redis';
|
||||
import { AUCTION_REDIS_CLIENT } from './auction-redis.constants';
|
||||
import type { AuctionRedisScriptDefinition } from './auction-redis.scripts';
|
||||
|
||||
export type AuctionRedisClient = ReturnType<typeof createClient>;
|
||||
|
||||
export interface EvalShaWithReloadParams {
|
||||
keys: string[];
|
||||
script: string;
|
||||
scriptSha: string;
|
||||
values: string[];
|
||||
}
|
||||
|
||||
export class AuctionRedisNoscriptError extends Error {
|
||||
constructor(message = 'NOSCRIPT No matching script. Please use EVAL.') {
|
||||
super(message);
|
||||
this.name = 'AuctionRedisNoscriptError';
|
||||
}
|
||||
}
|
||||
|
||||
function isNoscriptError(error: unknown): boolean {
|
||||
if (error instanceof AuctionRedisNoscriptError) return true;
|
||||
const message =
|
||||
error instanceof Error ? error.message : typeof error === 'string' ? error : '';
|
||||
return /\bNOSCRIPT\b/iu.test(message);
|
||||
}
|
||||
|
||||
function buildEvalShaCommand(
|
||||
scriptSha: string,
|
||||
keys: string[],
|
||||
values: string[],
|
||||
): string[] {
|
||||
return ['EVALSHA', scriptSha, String(keys.length), ...keys, ...values];
|
||||
}
|
||||
|
||||
function parseRedisTimeReply(reply: unknown): number {
|
||||
if (Array.isArray(reply) && reply.length >= 2) {
|
||||
const seconds = Number(reply[0]);
|
||||
const microseconds = Number(reply[1]);
|
||||
if (Number.isFinite(seconds) && Number.isFinite(microseconds)) {
|
||||
return seconds * 1000 + Math.floor(microseconds / 1000);
|
||||
}
|
||||
}
|
||||
|
||||
throw new Error(`Unexpected Redis TIME reply: ${JSON.stringify(reply)}`);
|
||||
}
|
||||
|
||||
@Injectable()
|
||||
export class AuctionRedisService implements OnModuleDestroy {
|
||||
constructor(
|
||||
@Inject(AUCTION_REDIS_CLIENT)
|
||||
private readonly client: AuctionRedisClient,
|
||||
) {}
|
||||
|
||||
async onModuleDestroy() {
|
||||
try {
|
||||
await this.client.quit();
|
||||
} catch {
|
||||
this.client.destroy();
|
||||
}
|
||||
}
|
||||
|
||||
public raw(): AuctionRedisClient {
|
||||
return this.client;
|
||||
}
|
||||
|
||||
public async getCurrentRedisTimestampMS(): Promise<number> {
|
||||
const reply = await this.client.sendCommand(['TIME']);
|
||||
return parseRedisTimeReply(reply);
|
||||
}
|
||||
|
||||
public async evalShaWithReload<T = unknown>(
|
||||
params: EvalShaWithReloadParams,
|
||||
): Promise<T> {
|
||||
try {
|
||||
return (await this.client.sendCommand(
|
||||
buildEvalShaCommand(params.scriptSha, params.keys, params.values),
|
||||
)) as T;
|
||||
} catch (error) {
|
||||
if (!isNoscriptError(error)) throw error;
|
||||
}
|
||||
|
||||
const loadedSha = String(
|
||||
await this.client.sendCommand(['SCRIPT', 'LOAD', params.script]),
|
||||
);
|
||||
return (await this.client.sendCommand(
|
||||
buildEvalShaCommand(loadedSha, params.keys, params.values),
|
||||
)) as T;
|
||||
}
|
||||
|
||||
public async evalScript<T = unknown>(
|
||||
script: AuctionRedisScriptDefinition,
|
||||
keys: string[],
|
||||
values: string[],
|
||||
): Promise<T> {
|
||||
return this.evalShaWithReload<T>({
|
||||
keys,
|
||||
script: script.lua,
|
||||
scriptSha: script.sha,
|
||||
values,
|
||||
});
|
||||
}
|
||||
|
||||
public async acquireTokenLock(
|
||||
key: string,
|
||||
token: string,
|
||||
ttlMS: number,
|
||||
): Promise<boolean> {
|
||||
const result = await this.client.sendCommand([
|
||||
'SET',
|
||||
key,
|
||||
token,
|
||||
'PX',
|
||||
String(ttlMS),
|
||||
'NX',
|
||||
]);
|
||||
return String(result) === 'OK';
|
||||
}
|
||||
|
||||
public async releaseTokenLock(key: string, token: string): Promise<boolean> {
|
||||
const result = await this.client.sendCommand([
|
||||
'EVAL',
|
||||
'if redis.call("GET", KEYS[1]) == ARGV[1] then return redis.call("DEL", KEYS[1]) else return 0 end',
|
||||
'1',
|
||||
key,
|
||||
token,
|
||||
]);
|
||||
return Number(result) === 1;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,111 @@
|
||||
import { buildAuctionRedisKeys } from './auction-redis.keys';
|
||||
import {
|
||||
AUCTION_HYDRATE_STATE_SCRIPT,
|
||||
assembleAuctionViewFromRedisState,
|
||||
buildHydrateAuctionStateScriptInvocation,
|
||||
shouldHydrateRedisAuctionState,
|
||||
} from './auction-redis.state';
|
||||
|
||||
describe('auction redis state assembly', () => {
|
||||
it.each([
|
||||
{
|
||||
expected: true,
|
||||
live: null,
|
||||
mongo: { auctionLifecycleId: 'life-1', revision: 1 },
|
||||
},
|
||||
{
|
||||
expected: true,
|
||||
live: { auctionLifecycleId: 'life-1', revision: 1 },
|
||||
mongo: { auctionLifecycleId: 'life-1', revision: 2 },
|
||||
},
|
||||
{
|
||||
expected: true,
|
||||
live: { auctionLifecycleId: 'old-life', revision: 2 },
|
||||
mongo: { auctionLifecycleId: 'new-life', revision: 2 },
|
||||
},
|
||||
{
|
||||
expected: false,
|
||||
live: { auctionLifecycleId: 'redis-life', revision: 3 },
|
||||
mongo: { auctionLifecycleId: 'mongo-life', revision: 2 },
|
||||
},
|
||||
])('decides rehydrate need: %#', ({ live, mongo, expected }) => {
|
||||
expect(shouldHydrateRedisAuctionState({ live, mongo })).toBe(expected);
|
||||
});
|
||||
|
||||
it('assembles public view and maps internal expiring phase to bidding', () => {
|
||||
expect(
|
||||
assembleAuctionViewFromRedisState({
|
||||
auctionBidHistoryEntries: ['{"bidPointAmount":100}'],
|
||||
currentServerTimestampMS: 1_000,
|
||||
liveState: {
|
||||
auctionLifecycleId: 'life-1',
|
||||
currentBidRoundPlayerUserId: 'player-1',
|
||||
phase: 'expiring',
|
||||
revision: 3,
|
||||
},
|
||||
shouldForceAuctionStateResync: true,
|
||||
structureState: {
|
||||
auctionTeams: [],
|
||||
},
|
||||
}),
|
||||
).toMatchObject({
|
||||
auctionBidHistory: [{ bidPointAmount: 100 }],
|
||||
auctionLifecycleId: 'life-1',
|
||||
canPlaceBidInCurrentBidRound: false,
|
||||
currentBidRoundPlayerUserId: 'player-1',
|
||||
currentServerTimestampMS: 1000,
|
||||
isAuctionStateTransitionInProgress: true,
|
||||
phase: 'bidding',
|
||||
revision: 3,
|
||||
shouldForceAuctionStateResync: true,
|
||||
});
|
||||
});
|
||||
|
||||
it('builds HYDRATE invocation and keeps CAS conditions in Lua', () => {
|
||||
const invocation = buildHydrateAuctionStateScriptInvocation(
|
||||
buildAuctionRedisKeys('match-1'),
|
||||
{
|
||||
auctionHistorySequence: 4,
|
||||
auctionLifecycleId: 'life-1',
|
||||
liveStatePatch: {
|
||||
'team:1:assignedAuctionTeamMemberCount': 1,
|
||||
'team:1:remainingBidPointAmount': 1000,
|
||||
},
|
||||
maximumBidRoundDurationSeconds: 30,
|
||||
matchId: 'match-1',
|
||||
phase: 'bidding',
|
||||
revision: 7,
|
||||
structureStateJson: '{"auctionTeams":[]}',
|
||||
},
|
||||
);
|
||||
|
||||
expect(invocation.script).toBe(AUCTION_HYDRATE_STATE_SCRIPT);
|
||||
expect(invocation.keys).toEqual([
|
||||
'auction:match-1:liveAuctionState',
|
||||
'auction:match-1:auctionStructureState',
|
||||
'auction:bidRoundDeadlineQueue',
|
||||
]);
|
||||
expect(invocation.values).toEqual([
|
||||
'match-1',
|
||||
'life-1',
|
||||
'7',
|
||||
'bidding',
|
||||
'4',
|
||||
'30',
|
||||
'{"auctionTeams":[]}',
|
||||
'2',
|
||||
'team:1:assignedAuctionTeamMemberCount',
|
||||
'1',
|
||||
'team:1:remainingBidPointAmount',
|
||||
'1000',
|
||||
]);
|
||||
expect(AUCTION_HYDRATE_STATE_SCRIPT.lua).toContain("redis.call('TIME')");
|
||||
expect(AUCTION_HYDRATE_STATE_SCRIPT.lua).toContain(
|
||||
'INVALID_PATCH_ARITY',
|
||||
);
|
||||
expect(AUCTION_HYDRATE_STATE_SCRIPT.lua).toContain(
|
||||
'mongoRevision > redisRevision',
|
||||
);
|
||||
expect(AUCTION_HYDRATE_STATE_SCRIPT.lua).toContain("redis.call('ZADD'");
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,188 @@
|
||||
import type { AuctionRedisKeys } from './auction-redis.keys';
|
||||
import { defineAuctionRedisScript } from './auction-redis.scripts';
|
||||
|
||||
export interface AuctionRedisRevisionIdentity {
|
||||
auctionLifecycleId?: string;
|
||||
revision?: number;
|
||||
}
|
||||
|
||||
export interface ShouldHydrateRedisAuctionStateParams {
|
||||
live: AuctionRedisRevisionIdentity | null;
|
||||
mongo: Required<AuctionRedisRevisionIdentity>;
|
||||
}
|
||||
|
||||
export interface AssembleAuctionViewParams {
|
||||
auctionBidHistoryEntries: string[];
|
||||
currentServerTimestampMS: number;
|
||||
liveState: Record<string, unknown> & {
|
||||
auctionLifecycleId: string;
|
||||
phase: string;
|
||||
revision: number;
|
||||
};
|
||||
shouldForceAuctionStateResync?: boolean;
|
||||
structureState: Record<string, unknown>;
|
||||
}
|
||||
|
||||
export interface HydrateAuctionStateScriptInput {
|
||||
auctionHistorySequence: number;
|
||||
auctionLifecycleId: string;
|
||||
liveStatePatch?: Record<string, string | number | boolean | null | undefined>;
|
||||
maximumBidRoundDurationSeconds: number;
|
||||
matchId: string;
|
||||
phase: string;
|
||||
revision: number;
|
||||
structureStateJson: string;
|
||||
}
|
||||
|
||||
export interface HydrateAuctionStateScriptInvocation {
|
||||
keys: string[];
|
||||
script: typeof AUCTION_HYDRATE_STATE_SCRIPT;
|
||||
values: string[];
|
||||
}
|
||||
|
||||
function stringifyRedisValue(value: string | number | boolean | null): string {
|
||||
if (typeof value === 'boolean') return value ? '1' : '0';
|
||||
if (value === null) return '';
|
||||
return String(value);
|
||||
}
|
||||
|
||||
function flattenLiveStatePatch(
|
||||
liveStatePatch: HydrateAuctionStateScriptInput['liveStatePatch'],
|
||||
): string[] {
|
||||
return Object.entries(liveStatePatch ?? {})
|
||||
.filter(([, value]) => value !== undefined)
|
||||
.sort(([a], [b]) => a.localeCompare(b))
|
||||
.flatMap(([key, value]) => [
|
||||
key,
|
||||
stringifyRedisValue(value as string | number | boolean | null),
|
||||
]);
|
||||
}
|
||||
|
||||
export function shouldHydrateRedisAuctionState(
|
||||
params: ShouldHydrateRedisAuctionStateParams,
|
||||
): boolean {
|
||||
if (!params.live) return true;
|
||||
const redisRevision = params.live.revision ?? -1;
|
||||
const mongoRevision = params.mongo.revision;
|
||||
if (mongoRevision > redisRevision) return true;
|
||||
return (
|
||||
mongoRevision === redisRevision &&
|
||||
params.mongo.auctionLifecycleId !== params.live.auctionLifecycleId
|
||||
);
|
||||
}
|
||||
|
||||
export function assembleAuctionViewFromRedisState(
|
||||
params: AssembleAuctionViewParams,
|
||||
): Record<string, unknown> {
|
||||
const isExpiring = params.liveState.phase === 'expiring';
|
||||
return {
|
||||
...params.structureState,
|
||||
...params.liveState,
|
||||
auctionBidHistory: params.auctionBidHistoryEntries.map((entry) =>
|
||||
JSON.parse(entry),
|
||||
),
|
||||
canPlaceBidInCurrentBidRound: !isExpiring,
|
||||
currentServerTimestampMS: params.currentServerTimestampMS,
|
||||
isAuctionStateTransitionInProgress: isExpiring,
|
||||
phase: isExpiring ? 'bidding' : params.liveState.phase,
|
||||
shouldForceAuctionStateResync:
|
||||
params.shouldForceAuctionStateResync || undefined,
|
||||
};
|
||||
}
|
||||
|
||||
export function buildHydrateAuctionStateScriptInvocation(
|
||||
keys: AuctionRedisKeys,
|
||||
input: HydrateAuctionStateScriptInput,
|
||||
): HydrateAuctionStateScriptInvocation {
|
||||
const liveStatePatchPairs = flattenLiveStatePatch(input.liveStatePatch);
|
||||
return {
|
||||
keys: [keys.liveStateKey, keys.structureStateKey, keys.deadlineQueueKey],
|
||||
script: AUCTION_HYDRATE_STATE_SCRIPT,
|
||||
values: [
|
||||
input.matchId,
|
||||
input.auctionLifecycleId,
|
||||
String(input.revision),
|
||||
input.phase,
|
||||
String(input.auctionHistorySequence),
|
||||
String(input.maximumBidRoundDurationSeconds),
|
||||
input.structureStateJson,
|
||||
String(liveStatePatchPairs.length / 2),
|
||||
...liveStatePatchPairs,
|
||||
],
|
||||
};
|
||||
}
|
||||
|
||||
export const AUCTION_HYDRATE_STATE_SCRIPT = defineAuctionRedisScript(
|
||||
'auction.hydrateState',
|
||||
`
|
||||
local liveAuctionStateKey = KEYS[1]
|
||||
local auctionStructureStateKey = KEYS[2]
|
||||
local bidRoundDeadlineQueueKey = KEYS[3]
|
||||
|
||||
local matchId = ARGV[1]
|
||||
local mongoAuctionLifecycleId = ARGV[2]
|
||||
local mongoRevision = tonumber(ARGV[3])
|
||||
local phase = ARGV[4]
|
||||
local auctionHistorySequence = ARGV[5]
|
||||
local maximumBidRoundDurationSeconds = tonumber(ARGV[6])
|
||||
local structureStateJson = ARGV[7]
|
||||
local liveStatePatchPairCount = tonumber(ARGV[8])
|
||||
|
||||
local redisTime = redis.call('TIME')
|
||||
local currentRedisTimestampMS = (tonumber(redisTime[1]) * 1000) + math.floor(tonumber(redisTime[2]) / 1000)
|
||||
local redisRevision = tonumber(redis.call('HGET', liveAuctionStateKey, 'revision') or '-1')
|
||||
local redisAuctionLifecycleId = redis.call('HGET', liveAuctionStateKey, 'auctionLifecycleId')
|
||||
|
||||
if not liveStatePatchPairCount or #ARGV ~= 8 + (liveStatePatchPairCount * 2) then
|
||||
return {'REJECTED', 'INVALID_PATCH_ARITY', tostring(currentRedisTimestampMS)}
|
||||
end
|
||||
|
||||
local shouldHydrate = false
|
||||
if redisRevision < 0 then
|
||||
shouldHydrate = true
|
||||
elseif mongoRevision > redisRevision then
|
||||
shouldHydrate = true
|
||||
elseif mongoRevision == redisRevision and mongoAuctionLifecycleId ~= redisAuctionLifecycleId then
|
||||
shouldHydrate = true
|
||||
end
|
||||
|
||||
if not shouldHydrate then
|
||||
return {'NOOP', tostring(redisRevision), tostring(currentRedisTimestampMS)}
|
||||
end
|
||||
|
||||
local hydratedRevision = mongoRevision + 1
|
||||
redis.call('SET', auctionStructureStateKey, structureStateJson)
|
||||
local hsetArgs = {
|
||||
liveAuctionStateKey,
|
||||
'auctionLifecycleId',
|
||||
mongoAuctionLifecycleId,
|
||||
'revision',
|
||||
tostring(hydratedRevision),
|
||||
'phase',
|
||||
phase,
|
||||
'currentAuctionHistorySequence',
|
||||
auctionHistorySequence,
|
||||
'currentHighestBidPointAmount',
|
||||
'0',
|
||||
'currentHighestBidderTeamIndex',
|
||||
'-1'
|
||||
}
|
||||
local patchIndex = 9
|
||||
for i = 1, liveStatePatchPairCount do
|
||||
table.insert(hsetArgs, ARGV[patchIndex])
|
||||
table.insert(hsetArgs, ARGV[patchIndex + 1])
|
||||
patchIndex = patchIndex + 2
|
||||
end
|
||||
redis.call('HSET', unpack(hsetArgs))
|
||||
|
||||
if phase == 'bidding' then
|
||||
local currentBidRoundDeadlineTimestampMS = currentRedisTimestampMS + (maximumBidRoundDurationSeconds * 1000)
|
||||
redis.call('HSET', liveAuctionStateKey, 'currentBidRoundDeadlineTimestampMS', tostring(currentBidRoundDeadlineTimestampMS))
|
||||
redis.call('ZADD', bidRoundDeadlineQueueKey, currentBidRoundDeadlineTimestampMS, matchId)
|
||||
else
|
||||
redis.call('ZREM', bidRoundDeadlineQueueKey, matchId)
|
||||
end
|
||||
|
||||
return {'OK', tostring(hydratedRevision), tostring(currentRedisTimestampMS)}
|
||||
`,
|
||||
);
|
||||
Reference in new issue
Block a user