@sonamu-kit/websocket-redis-adapter 0.0.0-stage → 0.12.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,113 @@
1
+ import { type WebSocketAudience, type WebSocketPresenceRegistration, type WebSocketPresenceStore, type WebSocketRoomId, type WebSocketRoutingPlan, type WebSocketUserId } from "sonamu";
2
+ import { type RedisWebSocketConnection } from "./connection";
3
+ export type RedisWebSocketPresenceStoreStatus = {
4
+ ready: boolean;
5
+ rebuildPending: boolean;
6
+ };
7
+ type NodeKeys = {
8
+ sessions: string;
9
+ rooms: string;
10
+ users: string;
11
+ namespaces: string;
12
+ };
13
+ /**
14
+ * 노드별 키는 해시태그 `{nodeId}`를 공유해 Redis Cluster에서도 한 slot에 놓인다.
15
+ */
16
+ export declare function nodeKeysOf(prefix: string, nodeId: string): NodeKeys;
17
+ /**
18
+ * node-redis 기반 presence store. 자기 노드 세션의 replica를 Redis에 두고, 다른 노드로의 라우팅과 클러스터 인원수를 제공한다.
19
+ *
20
+ * - 각 mutation은 메모리 snapshot을 즉시 갱신하고, 세션 상태 JSON을 Lua 스크립트 하나(EVALSHA)로 Redis에 반영한다.
21
+ * - 모든 Redis 호출은 commandDeadlineMs 안에 끝난다. 쓰기가 실패하거나 deadline을 넘기면 rebuild 대기가 되고,
22
+ * standalone `ready`, Sentinel `MASTER_CHANGE`, 다음 성공한 heartbeat 중 먼저 오는 시점에 노드 키 전체를 메모리로 다시 쓴다.
23
+ * - heartbeat는 노드 키 TTL과 `<prefix>:nodes` score를 갱신하고 오래된 노드를 정리한다.
24
+ */
25
+ export declare class RedisWebSocketPresenceStore implements WebSocketPresenceStore {
26
+ readonly nodeId: string;
27
+ private readonly connection;
28
+ private readonly keys;
29
+ private readonly nodesKey;
30
+ private readonly sessions;
31
+ private readonly inFlight;
32
+ private started;
33
+ private closing;
34
+ private shutdownPromise;
35
+ private heartbeatTimer;
36
+ private heartbeatRunning;
37
+ private rebuildTimer;
38
+ private rebuildRunning;
39
+ private rebuildRequested;
40
+ private rebuildPending;
41
+ private sessionsPersisted;
42
+ private pendingWrites;
43
+ private failureGeneration;
44
+ /** @internal createRedisWebSocketAdapter가 생성한다. */
45
+ constructor(connection: RedisWebSocketConnection);
46
+ getStatus(): RedisWebSocketPresenceStoreStatus;
47
+ register(input: WebSocketPresenceRegistration): Promise<void>;
48
+ activate(sessionId: string): Promise<void>;
49
+ unregister(sessionId: string): Promise<void>;
50
+ setUserId(sessionId: string, userId: WebSocketUserId): Promise<void>;
51
+ clearUserId(sessionId: string): Promise<void>;
52
+ join(sessionId: string, roomId: WebSocketRoomId): Promise<void>;
53
+ leave(sessionId: string, roomId: WebSocketRoomId): Promise<void>;
54
+ /**
55
+ * nodeId 관점의 라우팅 계획. 원격 노드는 heartbeat가 nodeTimeoutMs 안인 노드 중 audience count가 있는 노드다.
56
+ * 세션 목록은 읽지 않고, 노드별 count 조회를 한 번의 pipeline으로 보낸다.
57
+ */
58
+ resolveRoute(audience: WebSocketAudience, nodeId: string): Promise<WebSocketRoutingPlan>;
59
+ /** 살아 있는 모든 노드의 활성 방 인원수 합계. 자기 노드는 메모리, 원격 노드는 Redis count로 센다. */
60
+ getRoomMemberCount(roomId: WebSocketRoomId, namespace?: string): Promise<number>;
61
+ /**
62
+ * 진행 중인 쓰기를 drainTimeoutMs까지 기다린 뒤 노드 키를 지우고 nodes에서 자기 노드를 뺀다.
63
+ * 이후 들어오는 mutation은 Redis에 쓰지 않으므로 늦은 쓰기가 키를 되살리지 않는다.
64
+ */
65
+ shutdown(): Promise<void>;
66
+ private close;
67
+ private mutate;
68
+ /**
69
+ * 세션 하나를 Redis에 반영한다.
70
+ *
71
+ * 불변식: 모든 쓰기(세션 반영과 rebuild)는 명령을 보내는 바로 그 tick의 메모리 상태를 절대값으로 쓴다.
72
+ * - 세션 반영 스크립트는 Redis에 있던 이전 JSON과 새 JSON을 비교해 count를 맞추므로, 같은 상태를 두 번 써도 count가 두 번 변하지 않는다.
73
+ * - 한 연결의 명령은 보낸 순서대로 실행되므로, 나중에 보낸 쓰기일수록 더 최신 메모리를 담는다.
74
+ * rebuild가 먼저 보낸 세션 반영을 덮어써도 rebuild snapshot이 그 변경을 이미 담고 있고,
75
+ * rebuild 뒤에 보낸 세션 반영은 rebuild 결과 위에 최신 상태를 쓴다.
76
+ * - NOSCRIPT 재시도와 ready 대기 뒤에도 snapshot을 다시 만들므로 오래된 상태를 늦게 보내는 일이 없다.
77
+ * 따라서 마지막 쓰기가 성공하면 Redis는 그 시점의 메모리와 같다.
78
+ */
79
+ private applySession;
80
+ private write;
81
+ private countOnLiveNodes;
82
+ private start;
83
+ private runHeartbeat;
84
+ /**
85
+ * nodes score와 키 TTL을 한 번의 pipeline으로 갱신한다.
86
+ * 노드 키 4개의 PEXPIRE 결과(키가 있었는지)를 메모리상 있어야 할 키와 비교해 키 유실을 별도 왕복 없이 알아챈다.
87
+ * 있어야 할 키가 하나라도 없었으면 false를 돌려준다.
88
+ */
89
+ private sendHeartbeat;
90
+ /**
91
+ * 메모리 상태에서 Redis에 반드시 있어야 할 노드 키를 Lua 스크립트 규칙대로 계산한다.
92
+ * - sessions: 세션이 하나라도 있으면(비활성 포함) 있다
93
+ * - namespaces: 활성 세션이 하나라도 있으면 있다
94
+ * - rooms: 방에 들어간 활성 세션이 있으면 있다
95
+ * - users: userId가 있는 활성 세션이 있으면 있다
96
+ * 아직 세션을 쓴 적이 없거나 끝나지 않은 쓰기가 있으면 메모리가 Redis보다 앞서 있을 수 있으므로 판정하지 않는다(undefined).
97
+ * 반대 방향(메모리상 없어야 할 키가 있음)은 eviction으로 생기지 않으므로 보지 않는다.
98
+ */
99
+ private expectedNodeKeys;
100
+ private markRebuildPending;
101
+ /**
102
+ * 짧은 간격의 계기를 하나로 모은다. 첫 계기부터 REBUILD_DEBOUNCE_MS 뒤에 실행하고, 그 사이의 계기는 타이머를 다시 걸지 않는다.
103
+ * 계기가 debounce보다 자주 와도(짧은 heartbeat 주기, 반복 이벤트) rebuild가 무한히 밀리지 않는다.
104
+ */
105
+ private scheduleRebuild;
106
+ /**
107
+ * 노드 키를 메모리 snapshot으로 다시 쓴다. 이미 진행 중이면 끝난 뒤 한 번 더 실행해 마지막 계기를 놓치지 않는다.
108
+ */
109
+ private rebuild;
110
+ private track;
111
+ }
112
+ export {};
113
+ //# sourceMappingURL=presence-store.d.ts.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"presence-store.d.ts","sourceRoot":"","sources":["../src/presence-store.ts"],"names":[],"mappings":"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"}
@@ -0,0 +1,450 @@
1
+ import { APPLY_SESSION_SCRIPT, COUNT_AUDIENCE_SCRIPT, REBUILD_NODE_SCRIPT } from "./scripts.js";
2
+ import { z } from "zod";
3
+ import { parseWebSocketSessionNodeId } from "sonamu";
4
+ //#region src/presence-store.ts
5
+ const REBUILD_DEBOUNCE_MS = 200;
6
+ /**
7
+ * 노드별 키는 해시태그 `{nodeId}`를 공유해 Redis Cluster에서도 한 slot에 놓인다.
8
+ */
9
+ function nodeKeysOf(prefix, nodeId) {
10
+ return {
11
+ sessions: `${prefix}:{${nodeId}}:sessions`,
12
+ rooms: `${prefix}:{${nodeId}}:rooms`,
13
+ users: `${prefix}:{${nodeId}}:users`,
14
+ namespaces: `${prefix}:{${nodeId}}:namespaces`
15
+ };
16
+ }
17
+ const TaggedUserIdSchema = z.union([z.number().transform((userId) => `n:${String(userId)}`), z.string().transform((userId) => `s:${userId}`)]);
18
+ function tagUserId(userId) {
19
+ return TaggedUserIdSchema.parse(userId);
20
+ }
21
+ function serializeSession(session, nodeId) {
22
+ return JSON.stringify({
23
+ sessionId: session.sessionId,
24
+ nodeId,
25
+ namespace: session.namespace,
26
+ active: session.active,
27
+ rooms: [...session.rooms],
28
+ userId: session.userId === void 0 ? null : tagUserId(session.userId),
29
+ connectedAt: session.connectedAt,
30
+ lastSeenAt: session.lastSeenAt
31
+ });
32
+ }
33
+ function scopedNamespace(namespace) {
34
+ return namespace === "" ? void 0 : namespace;
35
+ }
36
+ function matchesNamespace(session, namespace) {
37
+ const scoped = scopedNamespace(namespace);
38
+ return scoped === void 0 || session.namespace === scoped;
39
+ }
40
+ function matchesAudience(session, audience) {
41
+ if (audience.type === "union") return audience.audiences.some((child) => matchesAudience(session, child));
42
+ if (!matchesNamespace(session, audience.namespace)) return false;
43
+ if (audience.type === "room") return session.rooms.has(audience.roomId);
44
+ if (audience.type === "user") return session.userId === audience.userId;
45
+ if (audience.type === "connections") return audience.connectionIds.includes(session.sessionId);
46
+ return true;
47
+ }
48
+ /**
49
+ * audience를 count 조건과 세션 ID로 라우팅할 노드로 나눈다. connections는 세션 ID에 든 노드 ID만으로 라우팅한다.
50
+ */
51
+ function collectRouting(audience, leaves, connectionNodeIds) {
52
+ switch (audience.type) {
53
+ case "all":
54
+ leaves.push({
55
+ k: "all",
56
+ ns: scopedNamespace(audience.namespace)
57
+ });
58
+ return;
59
+ case "room":
60
+ leaves.push({
61
+ k: "room",
62
+ ns: scopedNamespace(audience.namespace),
63
+ id: audience.roomId
64
+ });
65
+ return;
66
+ case "user":
67
+ leaves.push({
68
+ k: "user",
69
+ ns: scopedNamespace(audience.namespace),
70
+ id: tagUserId(audience.userId)
71
+ });
72
+ return;
73
+ case "connections":
74
+ for (const sessionId of audience.connectionIds) {
75
+ const nodeId = parseWebSocketSessionNodeId(sessionId);
76
+ if (nodeId !== void 0) connectionNodeIds.add(nodeId);
77
+ }
78
+ return;
79
+ case "union": for (const child of audience.audiences) collectRouting(child, leaves, connectionNodeIds);
80
+ }
81
+ }
82
+ /**
83
+ * node-redis 기반 presence store. 자기 노드 세션의 replica를 Redis에 두고, 다른 노드로의 라우팅과 클러스터 인원수를 제공한다.
84
+ *
85
+ * - 각 mutation은 메모리 snapshot을 즉시 갱신하고, 세션 상태 JSON을 Lua 스크립트 하나(EVALSHA)로 Redis에 반영한다.
86
+ * - 모든 Redis 호출은 commandDeadlineMs 안에 끝난다. 쓰기가 실패하거나 deadline을 넘기면 rebuild 대기가 되고,
87
+ * standalone `ready`, Sentinel `MASTER_CHANGE`, 다음 성공한 heartbeat 중 먼저 오는 시점에 노드 키 전체를 메모리로 다시 쓴다.
88
+ * - heartbeat는 노드 키 TTL과 `<prefix>:nodes` score를 갱신하고 오래된 노드를 정리한다.
89
+ */
90
+ var RedisWebSocketPresenceStore = class {
91
+ nodeId;
92
+ connection;
93
+ keys;
94
+ nodesKey;
95
+ sessions = /* @__PURE__ */ new Map();
96
+ inFlight = /* @__PURE__ */ new Set();
97
+ started = false;
98
+ closing = false;
99
+ shutdownPromise;
100
+ heartbeatTimer;
101
+ heartbeatRunning = false;
102
+ rebuildTimer;
103
+ rebuildRunning = false;
104
+ rebuildRequested = false;
105
+ rebuildPending = false;
106
+ sessionsPersisted = false;
107
+ pendingWrites = 0;
108
+ failureGeneration = 0;
109
+ /** @internal createRedisWebSocketAdapter가 생성한다. */
110
+ constructor(connection) {
111
+ this.connection = connection;
112
+ this.nodeId = connection.options.nodeId;
113
+ this.keys = nodeKeysOf(connection.options.prefix, this.nodeId);
114
+ this.nodesKey = `${connection.options.prefix}:nodes`;
115
+ connection.onConnectionReady(() => {
116
+ this.runHeartbeat();
117
+ });
118
+ connection.onMasterChange(() => {
119
+ if (!this.started) return;
120
+ this.markRebuildPending();
121
+ this.scheduleRebuild();
122
+ });
123
+ }
124
+ getStatus() {
125
+ return {
126
+ ready: this.connection.isReady,
127
+ rebuildPending: this.rebuildPending
128
+ };
129
+ }
130
+ register(input) {
131
+ if (input.nodeId !== this.nodeId) return Promise.reject(/* @__PURE__ */ new Error(`Redis presence store for node ${this.nodeId} cannot register a session of node ${input.nodeId}.`));
132
+ if (this.closing) return Promise.resolve();
133
+ const connectedAt = input.connectedAt.getTime();
134
+ this.sessions.set(input.sessionId, {
135
+ sessionId: input.sessionId,
136
+ namespace: input.namespace,
137
+ active: input.active,
138
+ rooms: /* @__PURE__ */ new Set(),
139
+ connectedAt,
140
+ lastSeenAt: connectedAt
141
+ });
142
+ return this.applySession(input.sessionId);
143
+ }
144
+ activate(sessionId) {
145
+ return this.mutate(sessionId, (session) => {
146
+ session.active = true;
147
+ });
148
+ }
149
+ unregister(sessionId) {
150
+ if (this.closing || !this.sessions.delete(sessionId)) return Promise.resolve();
151
+ return this.applySession(sessionId);
152
+ }
153
+ setUserId(sessionId, userId) {
154
+ return this.mutate(sessionId, (session) => {
155
+ session.userId = userId;
156
+ });
157
+ }
158
+ clearUserId(sessionId) {
159
+ return this.mutate(sessionId, (session) => {
160
+ delete session.userId;
161
+ });
162
+ }
163
+ join(sessionId, roomId) {
164
+ return this.mutate(sessionId, (session) => {
165
+ session.rooms.add(roomId);
166
+ });
167
+ }
168
+ leave(sessionId, roomId) {
169
+ return this.mutate(sessionId, (session) => {
170
+ session.rooms.delete(roomId);
171
+ });
172
+ }
173
+ /**
174
+ * nodeId 관점의 라우팅 계획. 원격 노드는 heartbeat가 nodeTimeoutMs 안인 노드 중 audience count가 있는 노드다.
175
+ * 세션 목록은 읽지 않고, 노드별 count 조회를 한 번의 pipeline으로 보낸다.
176
+ */
177
+ async resolveRoute(audience, nodeId) {
178
+ const localSessionIds = nodeId === this.nodeId ? [...this.sessions.values()].filter((session) => session.active && matchesAudience(session, audience)).map((session) => session.sessionId) : [];
179
+ const leaves = [];
180
+ const remoteNodeIds = /* @__PURE__ */ new Set();
181
+ collectRouting(audience, leaves, remoteNodeIds);
182
+ if (leaves.length > 0) {
183
+ const counts = await this.countOnLiveNodes(leaves, nodeId);
184
+ for (const [candidate, count] of counts) if (count > 0) remoteNodeIds.add(candidate);
185
+ }
186
+ remoteNodeIds.delete(nodeId);
187
+ return {
188
+ localSessionIds,
189
+ remoteNodeIds: [...remoteNodeIds].toSorted()
190
+ };
191
+ }
192
+ /** 살아 있는 모든 노드의 활성 방 인원수 합계. 자기 노드는 메모리, 원격 노드는 Redis count로 센다. */
193
+ async getRoomMemberCount(roomId, namespace) {
194
+ const audience = {
195
+ type: "room",
196
+ roomId,
197
+ namespace
198
+ };
199
+ let total = 0;
200
+ for (const session of this.sessions.values()) if (session.active && matchesAudience(session, audience)) total += 1;
201
+ const counts = await this.countOnLiveNodes([{
202
+ k: "room",
203
+ ns: scopedNamespace(namespace),
204
+ id: roomId
205
+ }], this.nodeId);
206
+ for (const count of counts.values()) total += count;
207
+ return total;
208
+ }
209
+ /**
210
+ * 진행 중인 쓰기를 drainTimeoutMs까지 기다린 뒤 노드 키를 지우고 nodes에서 자기 노드를 뺀다.
211
+ * 이후 들어오는 mutation은 Redis에 쓰지 않으므로 늦은 쓰기가 키를 되살리지 않는다.
212
+ */
213
+ shutdown() {
214
+ this.shutdownPromise ??= this.close();
215
+ return this.shutdownPromise;
216
+ }
217
+ async close() {
218
+ this.closing = true;
219
+ clearInterval(this.heartbeatTimer);
220
+ clearTimeout(this.rebuildTimer);
221
+ this.rebuildTimer = void 0;
222
+ if (this.started) {
223
+ let drainTimer;
224
+ try {
225
+ await Promise.race([Promise.allSettled(this.inFlight), new Promise((resolve) => {
226
+ drainTimer = setTimeout(resolve, this.connection.options.drainTimeoutMs);
227
+ })]);
228
+ } finally {
229
+ clearTimeout(drainTimer);
230
+ }
231
+ await this.connection.run((commands) => Promise.all([commands.del(Object.values(this.keys)), commands.zRem(this.nodesKey, this.nodeId)])).catch(() => {});
232
+ }
233
+ this.sessions.clear();
234
+ await this.connection.release("store");
235
+ }
236
+ mutate(sessionId, update) {
237
+ const session = this.sessions.get(sessionId);
238
+ if (this.closing || !session) return Promise.resolve();
239
+ update(session);
240
+ session.lastSeenAt = Date.now();
241
+ return this.applySession(sessionId);
242
+ }
243
+ /**
244
+ * 세션 하나를 Redis에 반영한다.
245
+ *
246
+ * 불변식: 모든 쓰기(세션 반영과 rebuild)는 명령을 보내는 바로 그 tick의 메모리 상태를 절대값으로 쓴다.
247
+ * - 세션 반영 스크립트는 Redis에 있던 이전 JSON과 새 JSON을 비교해 count를 맞추므로, 같은 상태를 두 번 써도 count가 두 번 변하지 않는다.
248
+ * - 한 연결의 명령은 보낸 순서대로 실행되므로, 나중에 보낸 쓰기일수록 더 최신 메모리를 담는다.
249
+ * rebuild가 먼저 보낸 세션 반영을 덮어써도 rebuild snapshot이 그 변경을 이미 담고 있고,
250
+ * rebuild 뒤에 보낸 세션 반영은 rebuild 결과 위에 최신 상태를 쓴다.
251
+ * - NOSCRIPT 재시도와 ready 대기 뒤에도 snapshot을 다시 만들므로 오래된 상태를 늦게 보내는 일이 없다.
252
+ * 따라서 마지막 쓰기가 성공하면 Redis는 그 시점의 메모리와 같다.
253
+ */
254
+ applySession(sessionId) {
255
+ const keyTtl = String(this.connection.options.keyTtlMs);
256
+ this.pendingWrites += 1;
257
+ const done = () => {
258
+ this.pendingWrites -= 1;
259
+ };
260
+ const writing = this.write(async (commands, token) => {
261
+ let wroteSession = false;
262
+ await this.connection.evalScript(commands, token, APPLY_SESSION_SCRIPT, Object.values(this.keys), () => {
263
+ if (this.closing) return;
264
+ const session = this.sessions.get(sessionId);
265
+ wroteSession = session !== void 0;
266
+ return [
267
+ sessionId,
268
+ session ? serializeSession(session, this.nodeId) : "",
269
+ keyTtl
270
+ ];
271
+ });
272
+ if (wroteSession) this.sessionsPersisted = true;
273
+ });
274
+ writing.then(done, done);
275
+ return writing;
276
+ }
277
+ write(operation) {
278
+ this.start();
279
+ const wait = this.connection.whenUsable();
280
+ const execute = () => this.closing ? Promise.resolve() : this.connection.run(operation).then(() => void 0, (cause) => {
281
+ this.markRebuildPending();
282
+ throw cause;
283
+ });
284
+ return this.track(wait ? wait.then(execute) : execute());
285
+ }
286
+ async countOnLiveNodes(leaves, excludeNodeId) {
287
+ if (this.closing) throw new Error("Redis presence store is shut down.");
288
+ this.start();
289
+ const wait = this.connection.whenUsable();
290
+ if (wait) await wait;
291
+ if (this.closing) throw new Error("Redis presence store is shut down.");
292
+ const prefix = this.connection.options.prefix;
293
+ const leavesJson = JSON.stringify(leaves);
294
+ return this.connection.run(async (commands, token) => {
295
+ const candidates = (await commands.zRangeByScore(this.nodesKey, Date.now() - this.connection.options.nodeTimeoutMs, "+inf")).filter((candidate) => candidate !== excludeNodeId);
296
+ const counts = await Promise.all(candidates.map((candidate) => {
297
+ const keys = nodeKeysOf(prefix, candidate);
298
+ return this.connection.evalScript(commands, token, COUNT_AUDIENCE_SCRIPT, [
299
+ keys.rooms,
300
+ keys.users,
301
+ keys.namespaces
302
+ ], () => this.closing ? void 0 : [leavesJson]);
303
+ }));
304
+ return new Map(candidates.map((candidate, index) => [candidate, counts[index] ?? 0]));
305
+ });
306
+ }
307
+ start() {
308
+ if (this.started || this.closing) return;
309
+ this.started = true;
310
+ this.connection.start();
311
+ this.heartbeatTimer = setInterval(() => {
312
+ this.runHeartbeat();
313
+ }, this.connection.options.heartbeatIntervalMs);
314
+ this.heartbeatTimer.unref();
315
+ this.runHeartbeat();
316
+ }
317
+ runHeartbeat() {
318
+ if (!this.started || this.closing || this.heartbeatRunning) return;
319
+ this.heartbeatRunning = true;
320
+ const wait = this.connection.whenUsable();
321
+ const execute = () => this.closing ? Promise.resolve(void 0) : this.connection.run((commands) => this.sendHeartbeat(commands));
322
+ const heartbeat = (wait ? wait.then(execute) : execute()).then((keysIntact) => {
323
+ if (this.closing) return;
324
+ if (keysIntact === false) this.rebuildPending = true;
325
+ if (this.rebuildPending) this.scheduleRebuild();
326
+ }, () => {
327
+ this.markRebuildPending();
328
+ });
329
+ this.track(heartbeat.finally(() => {
330
+ this.heartbeatRunning = false;
331
+ }));
332
+ }
333
+ /**
334
+ * nodes score와 키 TTL을 한 번의 pipeline으로 갱신한다.
335
+ * 노드 키 4개의 PEXPIRE 결과(키가 있었는지)를 메모리상 있어야 할 키와 비교해 키 유실을 별도 왕복 없이 알아챈다.
336
+ * 있어야 할 키가 하나라도 없었으면 false를 돌려준다.
337
+ */
338
+ async sendHeartbeat(commands) {
339
+ const now = Date.now();
340
+ const { keyTtlMs } = this.connection.options;
341
+ const expected = this.expectedNodeKeys();
342
+ const [sessions, rooms, users, namespaces] = await Promise.all([
343
+ commands.pExpire(this.keys.sessions, keyTtlMs),
344
+ commands.pExpire(this.keys.rooms, keyTtlMs),
345
+ commands.pExpire(this.keys.users, keyTtlMs),
346
+ commands.pExpire(this.keys.namespaces, keyTtlMs),
347
+ commands.zAdd(this.nodesKey, now, this.nodeId),
348
+ commands.zRemRangeByScore(this.nodesKey, "-inf", now - keyTtlMs),
349
+ commands.pExpire(this.nodesKey, keyTtlMs)
350
+ ]);
351
+ if (expected === void 0) return true;
352
+ return (sessions || !expected.sessions) && (rooms || !expected.rooms) && (users || !expected.users) && (namespaces || !expected.namespaces);
353
+ }
354
+ /**
355
+ * 메모리 상태에서 Redis에 반드시 있어야 할 노드 키를 Lua 스크립트 규칙대로 계산한다.
356
+ * - sessions: 세션이 하나라도 있으면(비활성 포함) 있다
357
+ * - namespaces: 활성 세션이 하나라도 있으면 있다
358
+ * - rooms: 방에 들어간 활성 세션이 있으면 있다
359
+ * - users: userId가 있는 활성 세션이 있으면 있다
360
+ * 아직 세션을 쓴 적이 없거나 끝나지 않은 쓰기가 있으면 메모리가 Redis보다 앞서 있을 수 있으므로 판정하지 않는다(undefined).
361
+ * 반대 방향(메모리상 없어야 할 키가 있음)은 eviction으로 생기지 않으므로 보지 않는다.
362
+ */
363
+ expectedNodeKeys() {
364
+ if (!this.sessionsPersisted || this.pendingWrites > 0) return;
365
+ const expected = {
366
+ sessions: this.sessions.size > 0,
367
+ rooms: false,
368
+ users: false,
369
+ namespaces: false
370
+ };
371
+ for (const session of this.sessions.values()) {
372
+ if (!session.active) continue;
373
+ expected.namespaces = true;
374
+ if (session.rooms.size > 0) expected.rooms = true;
375
+ if (session.userId !== void 0) expected.users = true;
376
+ }
377
+ return expected;
378
+ }
379
+ markRebuildPending() {
380
+ if (this.closing) return;
381
+ this.rebuildPending = true;
382
+ this.failureGeneration += 1;
383
+ }
384
+ /**
385
+ * 짧은 간격의 계기를 하나로 모은다. 첫 계기부터 REBUILD_DEBOUNCE_MS 뒤에 실행하고, 그 사이의 계기는 타이머를 다시 걸지 않는다.
386
+ * 계기가 debounce보다 자주 와도(짧은 heartbeat 주기, 반복 이벤트) rebuild가 무한히 밀리지 않는다.
387
+ */
388
+ scheduleRebuild() {
389
+ if (this.closing || this.rebuildTimer !== void 0) return;
390
+ this.rebuildTimer = setTimeout(() => {
391
+ this.rebuildTimer = void 0;
392
+ this.rebuild();
393
+ }, REBUILD_DEBOUNCE_MS);
394
+ this.rebuildTimer.unref();
395
+ }
396
+ /**
397
+ * 노드 키를 메모리 snapshot으로 다시 쓴다. 이미 진행 중이면 끝난 뒤 한 번 더 실행해 마지막 계기를 놓치지 않는다.
398
+ */
399
+ rebuild() {
400
+ if (this.closing) return;
401
+ if (this.rebuildRunning) {
402
+ this.rebuildRequested = true;
403
+ return;
404
+ }
405
+ this.rebuildRunning = true;
406
+ const generation = this.failureGeneration;
407
+ const keyTtl = String(this.connection.options.keyTtlMs);
408
+ const rebuilding = this.connection.run(async (commands, token) => {
409
+ let wroteSessions = false;
410
+ await this.connection.evalScript(commands, token, REBUILD_NODE_SCRIPT, Object.values(this.keys), () => {
411
+ if (this.closing) return;
412
+ const args = [keyTtl];
413
+ for (const session of this.sessions.values()) args.push(session.sessionId, serializeSession(session, this.nodeId));
414
+ wroteSessions = this.sessions.size > 0;
415
+ return args;
416
+ });
417
+ if (wroteSessions) this.sessionsPersisted = true;
418
+ if (this.closing) return true;
419
+ return this.sendHeartbeat(commands);
420
+ }).then((keysIntact) => {
421
+ if (!keysIntact) {
422
+ this.rebuildPending = true;
423
+ this.scheduleRebuild();
424
+ return;
425
+ }
426
+ if (generation === this.failureGeneration) this.rebuildPending = false;
427
+ }, () => {
428
+ this.markRebuildPending();
429
+ }).finally(() => {
430
+ this.rebuildRunning = false;
431
+ if (this.rebuildRequested) {
432
+ this.rebuildRequested = false;
433
+ if (this.rebuildPending) this.scheduleRebuild();
434
+ }
435
+ });
436
+ this.track(rebuilding);
437
+ }
438
+ track(promise) {
439
+ this.inFlight.add(promise);
440
+ const forget = () => {
441
+ this.inFlight.delete(promise);
442
+ };
443
+ promise.then(forget, forget);
444
+ return promise;
445
+ }
446
+ };
447
+ //#endregion
448
+ export { RedisWebSocketPresenceStore };
449
+
450
+ //# sourceMappingURL=presence-store.js.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"presence-store.js","names":[],"sources":["../src/presence-store.ts"],"sourcesContent":["import {\n parseWebSocketSessionNodeId,\n type WebSocketAudience,\n type WebSocketPresenceRegistration,\n type WebSocketPresenceStore,\n type WebSocketRoomId,\n type WebSocketRoutingPlan,\n type WebSocketUserId,\n} from \"sonamu\";\nimport { z } from \"zod\";\n\nimport { type RedisWebSocketConnection } from \"./connection\";\nimport { APPLY_SESSION_SCRIPT, COUNT_AUDIENCE_SCRIPT, REBUILD_NODE_SCRIPT } from \"./scripts\";\n\nexport type RedisWebSocketPresenceStoreStatus = {\n // 명령용 연결이 지금 ready인지\n ready: boolean;\n // 쓰기 실패나 deadline 초과로 노드 키를 메모리 상태로 다시 써야 하는지\n rebuildPending: boolean;\n};\n\ntype LocalSession = {\n sessionId: string;\n namespace: string;\n active: boolean;\n rooms: Set<WebSocketRoomId>;\n connectedAt: number;\n lastSeenAt: number;\n userId?: WebSocketUserId;\n};\n\n// countAudience 스크립트 조건. namespace가 없으면 스크립트가 그 노드의 활성 namespace로 펼친다\ntype CountLeaf = { k: \"all\"; ns?: string } | { k: \"room\" | \"user\"; ns?: string; id: string };\n\ntype NodeKeys = {\n sessions: string;\n rooms: string;\n users: string;\n namespaces: string;\n};\n\n// MASTER_CHANGE가 짧은 간격으로 여러 번 와도 rebuild를 한 번만 하도록 모으는 창\nconst REBUILD_DEBOUNCE_MS = 200;\n\n/**\n * 노드별 키는 해시태그 `{nodeId}`를 공유해 Redis Cluster에서도 한 slot에 놓인다.\n */\nexport function nodeKeysOf(prefix: string, nodeId: string): NodeKeys {\n return {\n sessions: `${prefix}:{${nodeId}}:sessions`,\n rooms: `${prefix}:{${nodeId}}:rooms`,\n users: `${prefix}:{${nodeId}}:users`,\n namespaces: `${prefix}:{${nodeId}}:namespaces`,\n };\n}\n\n// 타입 태그를 붙여 1과 \"1\"을 다른 사용자로 다룬다\nconst TaggedUserIdSchema = z.union([\n z.number().transform((userId) => `n:${String(userId)}`),\n z.string().transform((userId) => `s:${userId}`),\n]);\n\nfunction tagUserId(userId: WebSocketUserId): string {\n return TaggedUserIdSchema.parse(userId);\n}\n\nfunction serializeSession(session: LocalSession, nodeId: string): string {\n return JSON.stringify({\n sessionId: session.sessionId,\n nodeId,\n namespace: session.namespace,\n active: session.active,\n rooms: [...session.rooms],\n userId: session.userId === undefined ? null : tagUserId(session.userId),\n connectedAt: session.connectedAt,\n lastSeenAt: session.lastSeenAt,\n });\n}\n\n// core와 같이 namespace가 없거나 빈 문자열이면 모든 namespace를 본다\nfunction scopedNamespace(namespace: string | undefined): string | undefined {\n return namespace === \"\" ? undefined : namespace;\n}\n\nfunction matchesNamespace(session: LocalSession, namespace: string | undefined): boolean {\n const scoped = scopedNamespace(namespace);\n return scoped === undefined || session.namespace === scoped;\n}\n\nfunction matchesAudience(session: LocalSession, audience: WebSocketAudience): boolean {\n if (audience.type === \"union\") {\n return audience.audiences.some((child) => matchesAudience(session, child));\n }\n if (!matchesNamespace(session, audience.namespace)) {\n return false;\n }\n if (audience.type === \"room\") {\n return session.rooms.has(audience.roomId);\n }\n if (audience.type === \"user\") {\n // userId는 타입까지 같아야 한다\n return session.userId === audience.userId;\n }\n if (audience.type === \"connections\") {\n return audience.connectionIds.includes(session.sessionId);\n }\n return true;\n}\n\n/**\n * audience를 count 조건과 세션 ID로 라우팅할 노드로 나눈다. connections는 세션 ID에 든 노드 ID만으로 라우팅한다.\n */\nfunction collectRouting(\n audience: WebSocketAudience,\n leaves: CountLeaf[],\n connectionNodeIds: Set<string>,\n): void {\n switch (audience.type) {\n case \"all\":\n leaves.push({ k: \"all\", ns: scopedNamespace(audience.namespace) });\n return;\n case \"room\":\n leaves.push({ k: \"room\", ns: scopedNamespace(audience.namespace), id: audience.roomId });\n return;\n case \"user\":\n leaves.push({\n k: \"user\",\n ns: scopedNamespace(audience.namespace),\n id: tagUserId(audience.userId),\n });\n return;\n case \"connections\":\n for (const sessionId of audience.connectionIds) {\n const nodeId = parseWebSocketSessionNodeId(sessionId);\n if (nodeId !== undefined) {\n connectionNodeIds.add(nodeId);\n }\n }\n return;\n case \"union\":\n for (const child of audience.audiences) {\n collectRouting(child, leaves, connectionNodeIds);\n }\n }\n}\n\n/**\n * node-redis 기반 presence store. 자기 노드 세션의 replica를 Redis에 두고, 다른 노드로의 라우팅과 클러스터 인원수를 제공한다.\n *\n * - 각 mutation은 메모리 snapshot을 즉시 갱신하고, 세션 상태 JSON을 Lua 스크립트 하나(EVALSHA)로 Redis에 반영한다.\n * - 모든 Redis 호출은 commandDeadlineMs 안에 끝난다. 쓰기가 실패하거나 deadline을 넘기면 rebuild 대기가 되고,\n * standalone `ready`, Sentinel `MASTER_CHANGE`, 다음 성공한 heartbeat 중 먼저 오는 시점에 노드 키 전체를 메모리로 다시 쓴다.\n * - heartbeat는 노드 키 TTL과 `<prefix>:nodes` score를 갱신하고 오래된 노드를 정리한다.\n */\nexport class RedisWebSocketPresenceStore implements WebSocketPresenceStore {\n readonly nodeId: string;\n private readonly connection: RedisWebSocketConnection;\n private readonly keys: NodeKeys;\n private readonly nodesKey: string;\n private readonly sessions = new Map<string, LocalSession>();\n private readonly inFlight = new Set<Promise<void>>();\n\n private started = false;\n private closing = false;\n private shutdownPromise: Promise<void> | undefined;\n private heartbeatTimer: ReturnType<typeof setInterval> | undefined;\n private heartbeatRunning = false;\n private rebuildTimer: ReturnType<typeof setTimeout> | undefined;\n private rebuildRunning = false;\n private rebuildRequested = false;\n private rebuildPending = false;\n // 세션 JSON 쓰기가 한 번이라도 성공해 sessions 키가 있어야 하는지. 첫 쓰기보다 먼저 나간 heartbeat를 키 유실로 오인하지 않게 한다\n private sessionsPersisted = false;\n // 아직 끝나지 않은 세션 쓰기 수. 진행 중인 쓰기가 있으면 메모리가 Redis보다 앞서 있을 수 있어 키 유실 판정을 하지 않는다\n private pendingWrites = 0;\n // rebuild 도중 새 쓰기 실패가 생겼는지 구분하기 위한 세대 번호\n private failureGeneration = 0;\n\n /** @internal createRedisWebSocketAdapter가 생성한다. */\n constructor(connection: RedisWebSocketConnection) {\n this.connection = connection;\n this.nodeId = connection.options.nodeId;\n this.keys = nodeKeysOf(connection.options.prefix, this.nodeId);\n this.nodesKey = `${connection.options.prefix}:nodes`;\n connection.onConnectionReady(() => {\n // 재연결 직후 heartbeat를 보내고, 성공하면 대기 중인 rebuild가 이어진다\n this.runHeartbeat();\n });\n connection.onMasterChange(() => {\n // 아직 쓰기 전이면 다시 쓸 키도 없다\n if (!this.started) {\n return;\n }\n // failover에서는 비동기 복제로 직전 쓰기가 유실될 수 있으므로 매번 rebuild를 예약한다\n this.markRebuildPending();\n this.scheduleRebuild();\n });\n }\n\n getStatus(): RedisWebSocketPresenceStoreStatus {\n return { ready: this.connection.isReady, rebuildPending: this.rebuildPending };\n }\n\n register(input: WebSocketPresenceRegistration): Promise<void> {\n if (input.nodeId !== this.nodeId) {\n return Promise.reject(\n new Error(\n `Redis presence store for node ${this.nodeId} cannot register a session of node ${input.nodeId}.`,\n ),\n );\n }\n if (this.closing) {\n return Promise.resolve();\n }\n const connectedAt = input.connectedAt.getTime();\n this.sessions.set(input.sessionId, {\n sessionId: input.sessionId,\n namespace: input.namespace,\n active: input.active,\n rooms: new Set(),\n connectedAt,\n lastSeenAt: connectedAt,\n });\n return this.applySession(input.sessionId);\n }\n\n activate(sessionId: string): Promise<void> {\n return this.mutate(sessionId, (session) => {\n session.active = true;\n });\n }\n\n unregister(sessionId: string): Promise<void> {\n if (this.closing || !this.sessions.delete(sessionId)) {\n return Promise.resolve();\n }\n return this.applySession(sessionId);\n }\n\n setUserId(sessionId: string, userId: WebSocketUserId): Promise<void> {\n return this.mutate(sessionId, (session) => {\n session.userId = userId;\n });\n }\n\n clearUserId(sessionId: string): Promise<void> {\n return this.mutate(sessionId, (session) => {\n delete session.userId;\n });\n }\n\n join(sessionId: string, roomId: WebSocketRoomId): Promise<void> {\n return this.mutate(sessionId, (session) => {\n session.rooms.add(roomId);\n });\n }\n\n leave(sessionId: string, roomId: WebSocketRoomId): Promise<void> {\n return this.mutate(sessionId, (session) => {\n session.rooms.delete(roomId);\n });\n }\n\n /**\n * nodeId 관점의 라우팅 계획. 원격 노드는 heartbeat가 nodeTimeoutMs 안인 노드 중 audience count가 있는 노드다.\n * 세션 목록은 읽지 않고, 노드별 count 조회를 한 번의 pipeline으로 보낸다.\n */\n async resolveRoute(audience: WebSocketAudience, nodeId: string): Promise<WebSocketRoutingPlan> {\n const localSessionIds =\n nodeId === this.nodeId\n ? [...this.sessions.values()]\n .filter((session) => session.active && matchesAudience(session, audience))\n .map((session) => session.sessionId)\n : [];\n\n const leaves: CountLeaf[] = [];\n const remoteNodeIds = new Set<string>();\n collectRouting(audience, leaves, remoteNodeIds);\n\n if (leaves.length > 0) {\n const counts = await this.countOnLiveNodes(leaves, nodeId);\n for (const [candidate, count] of counts) {\n if (count > 0) {\n remoteNodeIds.add(candidate);\n }\n }\n }\n remoteNodeIds.delete(nodeId);\n\n return { localSessionIds, remoteNodeIds: [...remoteNodeIds].toSorted() };\n }\n\n /** 살아 있는 모든 노드의 활성 방 인원수 합계. 자기 노드는 메모리, 원격 노드는 Redis count로 센다. */\n async getRoomMemberCount(roomId: WebSocketRoomId, namespace?: string): Promise<number> {\n // 자기 노드는 메모리에서 센다. Redis 반영이 늦거나(rebuild 대기) 키가 사라져도 자기 노드 인원은 정확하다\n const audience: WebSocketAudience = { type: \"room\", roomId, namespace };\n let total = 0;\n for (const session of this.sessions.values()) {\n if (session.active && matchesAudience(session, audience)) {\n total += 1;\n }\n }\n // 원격 노드만 Redis에서 센다\n const counts = await this.countOnLiveNodes(\n [{ k: \"room\", ns: scopedNamespace(namespace), id: roomId }],\n this.nodeId,\n );\n for (const count of counts.values()) {\n total += count;\n }\n return total;\n }\n\n /**\n * 진행 중인 쓰기를 drainTimeoutMs까지 기다린 뒤 노드 키를 지우고 nodes에서 자기 노드를 뺀다.\n * 이후 들어오는 mutation은 Redis에 쓰지 않으므로 늦은 쓰기가 키를 되살리지 않는다.\n */\n shutdown(): Promise<void> {\n this.shutdownPromise ??= this.close();\n return this.shutdownPromise;\n }\n\n private async close(): Promise<void> {\n // 이 시점부터 아직 보내지 않은 쓰기와 heartbeat는 Redis로 나가지 않는다(prepare 단계에서 closing을 확인한다)\n this.closing = true;\n clearInterval(this.heartbeatTimer);\n clearTimeout(this.rebuildTimer);\n this.rebuildTimer = undefined;\n\n if (this.started) {\n let drainTimer: ReturnType<typeof setTimeout> | undefined;\n try {\n await Promise.race([\n Promise.allSettled(this.inFlight),\n new Promise<void>((resolve) => {\n drainTimer = setTimeout(resolve, this.connection.options.drainTimeoutMs);\n }),\n ]);\n } finally {\n // 빨리 끝난 drain이 event loop를 붙잡지 않게 한다\n clearTimeout(drainTimer);\n }\n // 같은 연결에서 앞서 보낸 늦은 쓰기보다 뒤에 실행되므로 그 쓰기가 만든 키도 함께 지운다\n await this.connection\n .run((commands) =>\n Promise.all([\n commands.del(Object.values(this.keys)),\n commands.zRem(this.nodesKey, this.nodeId),\n ]),\n )\n .catch(() => {});\n }\n this.sessions.clear();\n await this.connection.release(\"store\");\n }\n\n private mutate(sessionId: string, update: (session: LocalSession) => void): Promise<void> {\n const session = this.sessions.get(sessionId);\n if (this.closing || !session) {\n return Promise.resolve();\n }\n update(session);\n session.lastSeenAt = Date.now();\n return this.applySession(sessionId);\n }\n\n /**\n * 세션 하나를 Redis에 반영한다.\n *\n * 불변식: 모든 쓰기(세션 반영과 rebuild)는 명령을 보내는 바로 그 tick의 메모리 상태를 절대값으로 쓴다.\n * - 세션 반영 스크립트는 Redis에 있던 이전 JSON과 새 JSON을 비교해 count를 맞추므로, 같은 상태를 두 번 써도 count가 두 번 변하지 않는다.\n * - 한 연결의 명령은 보낸 순서대로 실행되므로, 나중에 보낸 쓰기일수록 더 최신 메모리를 담는다.\n * rebuild가 먼저 보낸 세션 반영을 덮어써도 rebuild snapshot이 그 변경을 이미 담고 있고,\n * rebuild 뒤에 보낸 세션 반영은 rebuild 결과 위에 최신 상태를 쓴다.\n * - NOSCRIPT 재시도와 ready 대기 뒤에도 snapshot을 다시 만들므로 오래된 상태를 늦게 보내는 일이 없다.\n * 따라서 마지막 쓰기가 성공하면 Redis는 그 시점의 메모리와 같다.\n */\n private applySession(sessionId: string): Promise<void> {\n const keyTtl = String(this.connection.options.keyTtlMs);\n this.pendingWrites += 1;\n const done = () => {\n this.pendingWrites -= 1;\n };\n const writing = this.write(async (commands, token) => {\n let wroteSession = false;\n await this.connection.evalScript(\n commands,\n token,\n APPLY_SESSION_SCRIPT,\n Object.values(this.keys),\n () => {\n if (this.closing) {\n return undefined;\n }\n const session = this.sessions.get(sessionId);\n wroteSession = session !== undefined;\n return [sessionId, session ? serializeSession(session, this.nodeId) : \"\", keyTtl];\n },\n );\n if (wroteSession) {\n this.sessionsPersisted = true;\n }\n });\n writing.then(done, done);\n return writing;\n }\n\n private write(operation: Parameters<RedisWebSocketConnection[\"run\"]>[0]): Promise<void> {\n this.start();\n const wait = this.connection.whenUsable();\n const execute = () =>\n // ready를 기다리는 사이 shutdown이 시작됐으면 정리된 노드 키를 되살리지 않도록 버린다\n this.closing\n ? Promise.resolve()\n : this.connection.run(operation).then(\n () => undefined,\n (cause: unknown) => {\n // 서버에서 실행됐을 수도 있으므로 결과와 무관하게 메모리로 다시 써야 한다\n this.markRebuildPending();\n throw cause;\n },\n );\n return this.track(wait ? wait.then(execute) : execute());\n }\n\n private async countOnLiveNodes(\n leaves: CountLeaf[],\n excludeNodeId?: string,\n ): Promise<Map<string, number>> {\n // shutdown 뒤에는 연결을 새로 시작하거나 ready 대기를 걸지 않는다\n if (this.closing) {\n throw new Error(\"Redis presence store is shut down.\");\n }\n this.start();\n const wait = this.connection.whenUsable();\n if (wait) {\n await wait;\n }\n // ready를 기다리는 사이 shutdown됐으면 조회를 보내지 않는다(런타임은 원격 없이 로컬만 쓴다)\n if (this.closing) {\n throw new Error(\"Redis presence store is shut down.\");\n }\n const prefix = this.connection.options.prefix;\n const leavesJson = JSON.stringify(leaves);\n return this.connection.run(async (commands, token) => {\n const liveNodeIds = await commands.zRangeByScore(\n this.nodesKey,\n Date.now() - this.connection.options.nodeTimeoutMs,\n \"+inf\",\n );\n const candidates = liveNodeIds.filter((candidate) => candidate !== excludeNodeId);\n // 같은 tick에 보내므로 node-redis가 한 번의 pipeline으로 묶어 보낸다\n const counts = await Promise.all(\n candidates.map((candidate) => {\n const keys = nodeKeysOf(prefix, candidate);\n return this.connection.evalScript(\n commands,\n token,\n COUNT_AUDIENCE_SCRIPT,\n [keys.rooms, keys.users, keys.namespaces],\n // NOSCRIPT 재시도 전에 shutdown됐으면 보내지 않는다\n () => (this.closing ? undefined : [leavesJson]),\n );\n }),\n );\n return new Map<string, number>(\n candidates.map((candidate, index) => [candidate, counts[index] ?? 0]),\n );\n });\n }\n\n // 첫 사용 때 연결과 heartbeat를 시작한다\n private start(): void {\n if (this.started || this.closing) {\n return;\n }\n this.started = true;\n this.connection.start();\n this.heartbeatTimer = setInterval(() => {\n this.runHeartbeat();\n }, this.connection.options.heartbeatIntervalMs);\n this.heartbeatTimer.unref();\n // 첫 mutation보다 먼저 보내 nodes에 바로 등록되게 한다\n this.runHeartbeat();\n }\n\n private runHeartbeat(): void {\n if (!this.started || this.closing || this.heartbeatRunning) {\n return;\n }\n this.heartbeatRunning = true;\n const wait = this.connection.whenUsable();\n const execute = (): Promise<boolean | undefined> =>\n this.closing\n ? Promise.resolve(undefined)\n : this.connection.run((commands) => this.sendHeartbeat(commands));\n const heartbeat = (wait ? wait.then(execute) : execute()).then(\n (keysIntact) => {\n if (this.closing) {\n return;\n }\n // 명령 실패 없이 노드 키가 사라진 경우(eviction, FLUSHDB)는 메모리상 있어야 할 키가 없는 것으로 알아챈다\n // 쓰기 실패가 아니므로 failureGeneration은 올리지 않는다. 이 heartbeat보다 뒤에 보낸 rebuild가 성공하면 키가 복구된 것이고,\n // 앞서 보낸 rebuild였다면 다음 heartbeat가 다시 알아챈다\n if (keysIntact === false) {\n this.rebuildPending = true;\n }\n // 연결은 유지된 채 응답만 멈췄다 돌아오면 ready도 MASTER_CHANGE도 없으므로 heartbeat 성공이 rebuild 계기가 된다\n if (this.rebuildPending) {\n this.scheduleRebuild();\n }\n },\n () => {\n // heartbeat가 실패하면 TTL이 갱신되지 않아 키가 만료될 수 있으므로 복구 뒤 다시 써야 한다\n this.markRebuildPending();\n },\n );\n this.track(\n heartbeat.finally(() => {\n this.heartbeatRunning = false;\n }),\n );\n }\n\n /**\n * nodes score와 키 TTL을 한 번의 pipeline으로 갱신한다.\n * 노드 키 4개의 PEXPIRE 결과(키가 있었는지)를 메모리상 있어야 할 키와 비교해 키 유실을 별도 왕복 없이 알아챈다.\n * 있어야 할 키가 하나라도 없었으면 false를 돌려준다.\n */\n private async sendHeartbeat(\n commands: Parameters<Parameters<RedisWebSocketConnection[\"run\"]>[0]>[0],\n ): Promise<boolean> {\n const now = Date.now();\n const { keyTtlMs } = this.connection.options;\n // 기대값은 명령을 보내는 시점의 메모리로 정한다. 같은 연결의 앞선 쓰기는 이 PEXPIRE보다 먼저 실행된다\n const expected = this.expectedNodeKeys();\n const [sessions, rooms, users, namespaces] = await Promise.all([\n commands.pExpire(this.keys.sessions, keyTtlMs),\n commands.pExpire(this.keys.rooms, keyTtlMs),\n commands.pExpire(this.keys.users, keyTtlMs),\n commands.pExpire(this.keys.namespaces, keyTtlMs),\n commands.zAdd(this.nodesKey, now, this.nodeId),\n // keyTtlMs가 지난 노드는 키도 만료됐으므로 live-node set에서 정리해 크기를 제한한다\n commands.zRemRangeByScore(this.nodesKey, \"-inf\", now - keyTtlMs),\n commands.pExpire(this.nodesKey, keyTtlMs),\n ]);\n if (expected === undefined) {\n return true;\n }\n return (\n (sessions || !expected.sessions) &&\n (rooms || !expected.rooms) &&\n (users || !expected.users) &&\n (namespaces || !expected.namespaces)\n );\n }\n\n /**\n * 메모리 상태에서 Redis에 반드시 있어야 할 노드 키를 Lua 스크립트 규칙대로 계산한다.\n * - sessions: 세션이 하나라도 있으면(비활성 포함) 있다\n * - namespaces: 활성 세션이 하나라도 있으면 있다\n * - rooms: 방에 들어간 활성 세션이 있으면 있다\n * - users: userId가 있는 활성 세션이 있으면 있다\n * 아직 세션을 쓴 적이 없거나 끝나지 않은 쓰기가 있으면 메모리가 Redis보다 앞서 있을 수 있으므로 판정하지 않는다(undefined).\n * 반대 방향(메모리상 없어야 할 키가 있음)은 eviction으로 생기지 않으므로 보지 않는다.\n */\n private expectedNodeKeys():\n | { sessions: boolean; rooms: boolean; users: boolean; namespaces: boolean }\n | undefined {\n if (!this.sessionsPersisted || this.pendingWrites > 0) {\n return undefined;\n }\n const expected = {\n sessions: this.sessions.size > 0,\n rooms: false,\n users: false,\n namespaces: false,\n };\n for (const session of this.sessions.values()) {\n if (!session.active) {\n continue;\n }\n expected.namespaces = true;\n if (session.rooms.size > 0) {\n expected.rooms = true;\n }\n if (session.userId !== undefined) {\n expected.users = true;\n }\n }\n return expected;\n }\n\n private markRebuildPending(): void {\n if (this.closing) {\n return;\n }\n this.rebuildPending = true;\n this.failureGeneration += 1;\n }\n\n /**\n * 짧은 간격의 계기를 하나로 모은다. 첫 계기부터 REBUILD_DEBOUNCE_MS 뒤에 실행하고, 그 사이의 계기는 타이머를 다시 걸지 않는다.\n * 계기가 debounce보다 자주 와도(짧은 heartbeat 주기, 반복 이벤트) rebuild가 무한히 밀리지 않는다.\n */\n private scheduleRebuild(): void {\n if (this.closing || this.rebuildTimer !== undefined) {\n return;\n }\n this.rebuildTimer = setTimeout(() => {\n this.rebuildTimer = undefined;\n this.rebuild();\n }, REBUILD_DEBOUNCE_MS);\n this.rebuildTimer.unref();\n }\n\n /**\n * 노드 키를 메모리 snapshot으로 다시 쓴다. 이미 진행 중이면 끝난 뒤 한 번 더 실행해 마지막 계기를 놓치지 않는다.\n */\n private rebuild(): void {\n if (this.closing) {\n return;\n }\n if (this.rebuildRunning) {\n this.rebuildRequested = true;\n return;\n }\n this.rebuildRunning = true;\n const generation = this.failureGeneration;\n const keyTtl = String(this.connection.options.keyTtlMs);\n\n const rebuilding = this.connection\n .run(async (commands, token) => {\n let wroteSessions = false;\n // snapshot은 보내기 직전에 만든다(applySession의 불변식 참고)\n await this.connection.evalScript(\n commands,\n token,\n REBUILD_NODE_SCRIPT,\n Object.values(this.keys),\n () => {\n if (this.closing) {\n return undefined;\n }\n const args = [keyTtl];\n for (const session of this.sessions.values()) {\n args.push(session.sessionId, serializeSession(session, this.nodeId));\n }\n wroteSessions = this.sessions.size > 0;\n return args;\n },\n );\n if (wroteSessions) {\n this.sessionsPersisted = true;\n }\n if (this.closing) {\n return true;\n }\n return this.sendHeartbeat(commands);\n })\n .then(\n (keysIntact) => {\n if (!keysIntact) {\n // rebuild 직후 heartbeat가 키 유실을 확인했으면 대기를 유지하고 debounce를 거쳐 다시 rebuild한다\n this.rebuildPending = true;\n this.scheduleRebuild();\n return;\n }\n // rebuild 도중 새 쓰기 실패가 없었을 때만 대기를 해제한다\n if (generation === this.failureGeneration) {\n this.rebuildPending = false;\n }\n },\n () => {\n this.markRebuildPending();\n },\n )\n .finally(() => {\n this.rebuildRunning = false;\n // 진행 중에 들어온 계기는 아직 복구할 것이 남은 경우에만 다시 실행한다\n if (this.rebuildRequested) {\n this.rebuildRequested = false;\n if (this.rebuildPending) {\n this.scheduleRebuild();\n }\n }\n });\n this.track(rebuilding);\n }\n\n private track(promise: Promise<void>): Promise<void> {\n this.inFlight.add(promise);\n const forget = () => {\n this.inFlight.delete(promise);\n };\n promise.then(forget, forget);\n return promise;\n }\n}\n"],"mappings":"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"}