@roomkit/gateway 1.0.0

package/dist/src/ws/message-router.service.js

@@ -0,0 +1,715 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var MessageRouterService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageRouterService = void 0;
+const common_1 = require("@nestjs/common");
+const uuid_1 = require("uuid");
+const core_1 = require("@roomkit/core");
+const config_service_1 = require("../config/config.service");
+const redis_service_1 = require("../redis/redis.service");
+const connection_service_1 = require("../connection/connection.service");
+const session_service_1 = require("../session/session.service");
+let MessageRouterService = MessageRouterService_1 = class MessageRouterService {
+    configService;
+    redisService;
+    connectionService;
+    sessionService;
+    logger = new common_1.Logger(MessageRouterService_1.name);
+    // 房间路由缓存 (roomId -> workerId)
+    roomRoutes = new Map();
+    constructor(configService, redisService, connectionService, sessionService) {
+        this.configService = configService;
+        this.redisService = redisService;
+        this.connectionService = connectionService;
+        this.sessionService = sessionService;
+        // 监听路由更新
+        this.initializeRouteUpdateListener();
+    }
+    /**
+     * 初始化路由更新监听
+     */
+    initializeRouteUpdateListener() {
+        this.redisService.onMessage(core_1.RedisChannels.routeUpdate(), (message) => {
+            try {
+                const update = JSON.parse(message);
+                this.handleRouteUpdate(update);
+            }
+            catch (error) {
+                this.logger.error('Failed to parse route update:', error);
+            }
+        });
+    }
+    /**
+     * 处理路由更新
+     */
+    handleRouteUpdate(update) {
+        if (update.type === 'room-migrated') {
+            const { roomId, oldWorkerId, newWorkerId } = update;
+            this.logger.log(`Route updated: room ${roomId} migrated from ${oldWorkerId} to ${newWorkerId}`);
+            // 更新本地缓存
+            this.roomRoutes.set(roomId, newWorkerId);
+            // 通知房间内的玩家（可选）
+            // 可以发送一个迁移通知，让客户端知道房间已迁移
+        }
+    }
+    /**
+     * 处理客户端消息
+     * 使用字符串消息类型格式：{ type: 'gw:auth', payload: {...} }
+     */
+    async handleMessage(connection, message) {
+        // 提取消息类型
+        const msgType = message.msgType;
+        const payload = message.payload;
+        // 更新活动时间
+        this.connectionService.touch(connection.id);
+        // 智能刷新session TTL（如果用户已认证）
+        // 只在TTL剩余不足2分钟时才刷新，避免频繁写入
+        if (connection.userId) {
+            await this.sessionService.refreshSession(connection.userId, false);
+        }
+        // 必须有消息类型
+        if (!msgType) {
+            this.sendErrorByType(connection.id, 'INVALID_MESSAGE_FORMAT');
+            return;
+        }
+        // 认证消息
+        if (msgType === core_1.MessageType.AUTH) {
+            await this.handleAuthRequest(connection, payload);
+            return;
+        }
+        // 心跳消息
+        if (msgType === core_1.MessageType.HEARTBEAT) {
+            const heartbeatPayload = payload;
+            this.connectionService.sendByType(connection.id, core_1.MessageType.HEARTBEAT_ACK, {
+                timestamp: heartbeatPayload?.timestamp,
+                serverTime: Date.now(),
+            });
+            return;
+        }
+        // ========== 连接层认证必须先完成 ==========
+        // 所有非 auth/heartbeat 消息都要求用户已认证
+        // 这确保了：
+        // 1. userId 在 Gateway 层确定，不可更改
+        // 2. 同一连接只有一个 userId
+        // 3. Session 正确写入
+        if (connection.status !== 'identified' && connection.status !== 'in-room') {
+            this.sendErrorByType(connection.id, 'NOT_AUTHENTICATED');
+            return;
+        }
+        // ========== 房间管理消息 ==========
+        if (msgType === core_1.MessageType.MSG_ROOM_JOIN) {
+            await this.handleJoinRoom(connection, payload);
+            return;
+        }
+        if (msgType === core_1.MessageType.MSG_ROOM_JOIN_OR_CREATE) {
+            await this.handleJoinOrCreate(connection, payload, message.token, message.reqId);
+            return;
+        }
+        if (msgType === core_1.MessageType.ROOM_CREATE) {
+            await this.handleCreateRoom(connection, payload);
+            return;
+        }
+        if (msgType === core_1.MessageType.ROOM_LEAVE) {
+            await this.handleLeaveRoom(connection, payload, message.roomId);
+            return;
+        }
+        if (msgType === core_1.MessageType.ROOM_LIST) {
+            await this.handleRoomList(connection, payload);
+            return;
+        }
+        if (msgType === core_1.MessageType.RECONNECT) {
+            await this.handleReconnect(connection, payload);
+            return;
+        }
+        // 游戏逻辑消息：转发到Worker
+        const targetRoomId = message.roomId || (connection.rooms?.size === 1 ? [...connection.rooms][0] : undefined);
+        if (!targetRoomId) {
+            this.sendErrorByType(connection.id, 'ROOM_ID_REQUIRED');
+            return;
+        }
+        if (!connection.rooms?.has(targetRoomId)) {
+            this.sendErrorByType(connection.id, 'NOT_IN_ROOM');
+            return;
+        }
+        await this.forwardToWorkerByType(connection, msgType, payload, targetRoomId, message.token);
+    }
+    /**
+     * 发送错误消息
+     */
+    sendErrorByType(connectionId, error) {
+        this.connectionService.sendByType(connectionId, core_1.MessageType.ERROR, {
+            error,
+            serverTime: Date.now(),
+        });
+    }
+    /**
+     * 转发消息到 Worker
+     */
+    async forwardToWorkerByType(connection, msgType, payload, roomId, token) {
+        // 优先使用缓存的路由
+        let workerId = this.roomRoutes.get(roomId);
+        // 如果缓存中没有，从 Redis 查询
+        if (!workerId) {
+            const result = await this.redisService.client.get(core_1.RedisKeys.roomWorker(roomId));
+            workerId = result || undefined;
+            if (workerId) {
+                // 更新缓存
+                this.roomRoutes.set(roomId, workerId);
+            }
+        }
+        if (!workerId) {
+            this.sendErrorByType(connection.id, 'ROOM_NOT_FOUND');
+            return;
+        }
+        const message = {
+            type: 'client-message',
+            requestId: (0, uuid_1.v4)(),
+            gatewayId: this.configService.gatewayId,
+            connectionId: connection.id,
+            userId: connection.userId,
+            roomId,
+            msgType,
+            payload,
+            timestamp: Date.now(),
+            token,
+        };
+        await this.redisService.publish(core_1.RedisChannels.rpcWorker(workerId), message);
+    }
+    /**
+     * 处理鉴权请求
+     */
+    async handleAuthRequest(connection, payload) {
+        if (connection.status !== 'connected') {
+            this.connectionService.sendByType(connection.id, core_1.MessageType.AUTH_FAIL, {
+                success: false,
+                error: 'INVALID_STATE',
+                serverTime: Date.now(),
+            });
+            return;
+        }
+        // 验证请求格式
+        const parseResult = core_1.AuthRequestSchema.safeParse(payload);
+        if (!parseResult.success) {
+            this.connectionService.sendByType(connection.id, core_1.MessageType.AUTH_FAIL, {
+                success: false,
+                error: 'INVALID_PAYLOAD',
+                serverTime: Date.now(),
+            });
+            return;
+        }
+        this.connectionService.updateStatus(connection.id, 'authenticating');
+        // 选择一个Worker处理鉴权
+        const workerId = await this.selectAuthWorker();
+        if (!workerId) {
+            this.connectionService.updateStatus(connection.id, 'connected');
+            this.connectionService.sendByType(connection.id, core_1.MessageType.AUTH_FAIL, {
+                success: false,
+                error: 'NO_WORKER_AVAILABLE',
+                serverTime: Date.now(),
+            });
+            return;
+        }
+        // 转发鉴权请求到Worker
+        const message = {
+            type: 'auth', // NOTICE: 鉴权消息类型是否有必要和MessageType.AUTH一致？
+            requestId: (0, uuid_1.v4)(),
+            gatewayId: this.configService.gatewayId,
+            connectionId: connection.id,
+            msgType: core_1.MessageType.AUTH,
+            payload: parseResult.data,
+            timestamp: Date.now(),
+        };
+        await this.redisService.publish(core_1.RedisChannels.rpcWorker(workerId), message);
+    }
+    /**
+     * 处理房间列表请求
+     */
+    async handleRoomList(connection, payload) {
+        // TODO: 实现房间列表查询
+        this.connectionService.sendByType(connection.id, core_1.MessageType.MSG_ROOM_LIST_OK, {
+            rooms: [],
+        });
+    }
+    /**
+     * 处理重连请求
+     *
+     * 统一的重连处理策略：
+     *
+     * **客户端视角**：
+     * - 客户端只知道 WebSocket 断开了
+     * - 无法区分是自己网络问题还是 Gateway 重启
+     * - 只需发送 sessionToken，不需要指定重连类型
+     *
+     * **服务端处理**：
+     * - Gateway 收到重连请求时，内存中已无旧 Connection 对象
+     * - 无论是客户端断连还是 Gateway 重启，处理流程相同：
+     *   1. 恢复 Gateway 本地连接映射
+     *   2. 通知 Worker 更新连接信息（Gateway ID + Connection ID）
+     *   3. 不发送房间状态（客户端已有状态）
+     *
+     * **Worker 重启场景**：
+     * - 不通过重连机制处理
+     * - Worker 应该有独立的容错恢复机制：
+     *   - 启动时从 Redis/持久化恢复房间状态
+     *   - 或延迟加载：收到消息时发现房间不存在，再恢复
+     * - 对客户端和 Gateway 透明
+     */
+    async handleReconnect(connection, payload) {
+        // 只允许未认证的连接进行重连
+        if (connection.status !== 'connected') {
+            this.connectionService.sendByType(connection.id, core_1.MessageType.MSG_RECONNECT_FAIL, {
+                success: false,
+                error: 'INVALID_STATE',
+            });
+            return;
+        }
+        const request = payload;
+        if (!request?.sessionToken) {
+            this.connectionService.sendByType(connection.id, core_1.MessageType.MSG_RECONNECT_FAIL, {
+                success: false,
+                error: 'INVALID_PAYLOAD',
+            });
+            return;
+        }
+        // 从 Redis 获取会话信息
+        const session = await this.sessionService.getSessionByToken(request.sessionToken);
+        if (!session) {
+            this.connectionService.sendByType(connection.id, core_1.MessageType.MSG_RECONNECT_FAIL, {
+                success: false,
+                error: 'SESSION_NOT_FOUND',
+            });
+            return;
+        }
+        const { userId, rooms } = session;
+        // 踢掉旧连接（如果存在且还活着）
+        if (session.connectionId && session.gatewayId) {
+            if (session.gatewayId === this.configService.gatewayId) {
+                // 本地 Gateway，检查连接是否还存在
+                const oldConnection = this.connectionService.getConnection(session.connectionId);
+                if (oldConnection) {
+                    this.logger.log(`Kicking old connection ${session.connectionId} during reconnect for user ${userId}`);
+                    this.connectionService.removeConnection(session.connectionId, 'reconnect-elsewhere');
+                }
+            }
+            else {
+                // 其他 Gateway，发送踢出消息（可能 Gateway 已重启，消息会丢失，无所谓）
+                const kickMessage = {
+                    type: 'kick-connection',
+                    requestId: (0, uuid_1.v4)(),
+                    gatewayId: this.configService.gatewayId,
+                    connectionId: session.connectionId,
+                    payload: { reason: 'reconnect-elsewhere' },
+                    timestamp: Date.now(),
+                };
+                await this.redisService.publish(core_1.RedisChannels.rpcGateway(session.gatewayId), kickMessage);
+            }
+        }
+        // 更新连接状态
+        this.connectionService.setUserId(connection.id, userId);
+        this.connectionService.updateStatus(connection.id, 'identified');
+        // 更新会话信息
+        await this.sessionService.updateConnectionInfo(userId, this.configService.gatewayId, connection.id);
+        // 恢复房间连接
+        const roomsInfo = [];
+        for (const roomInfo of rooms) {
+            const { roomId, gameType } = roomInfo;
+            // 验证房间是否还存在
+            const workerId = await this.redisService.client.get(core_1.RedisKeys.roomWorker(roomId));
+            if (!workerId) {
+                this.logger.warn(`Room ${roomId} not found during reconnect for user ${userId}`);
+                // 房间已不存在，从会话中移除
+                await this.sessionService.removeRoomFromSession(userId, roomId);
+                continue;
+            }
+            // 更新本地连接的房间信息
+            this.connectionService.addRoom(connection.id, roomId);
+            // 通知 Worker 更新房间成员的连接信息（轻量级通知，不发送状态）
+            const updateMessage = {
+                type: 'reconnect-room',
+                requestId: (0, uuid_1.v4)(),
+                gatewayId: this.configService.gatewayId,
+                connectionId: connection.id,
+                userId,
+                roomId,
+                payload: {
+                    sendState: false, // 明确告知不需要发送状态
+                },
+                timestamp: Date.now(),
+            };
+            await this.redisService.publish(core_1.RedisChannels.rpcWorker(workerId), updateMessage);
+            roomsInfo.push({ roomId, gameType });
+        }
+        // 发送重连成功响应
+        const response = {
+            userId,
+            rooms: roomsInfo,
+        };
+        this.connectionService.sendByType(connection.id, core_1.MessageType.MSG_RECONNECT_OK, response);
+        // 强制刷新 session TTL（重连后重置过期时间）
+        await this.sessionService.refreshSession(userId, true);
+        this.logger.log(`User ${userId} reconnected successfully, rejoined ${roomsInfo.length} rooms`);
+    }
+    /**
+     * 创建房间
+     */
+    async handleCreateRoom(connection, payload) {
+        const parseResult = core_1.CreateRoomRequestSchema.safeParse(payload);
+        if (!parseResult.success) {
+            this.connectionService.sendByType(connection.id, core_1.MessageType.ROOM_CREATE_FAIL, {
+                success: false,
+                error: 'INVALID_PAYLOAD',
+            });
+            return;
+        }
+        const { roomId: customRoomId, gameType, maxPlayers, config } = parseResult.data;
+        // 使用客户端指定的房间号，或自动生成
+        const roomId = customRoomId || `room_${(0, uuid_1.v4)().substring(0, 8)}`;
+        // 选择合适的Worker
+        const workerId = await this.selectWorker(gameType);
+        if (!workerId) {
+            this.connectionService.sendByType(connection.id, core_1.MessageType.ROOM_CREATE_FAIL, {
+                success: false,
+                error: 'NO_WORKER_AVAILABLE',
+            });
+            return;
+        }
+        // 使用 SETNX 原子操作：只有当 key 不存在时才设置成功
+        // 这样可以防止并发创建相同房间号的竞态条件
+        const setResult = await this.redisService.client.setnx(core_1.RedisKeys.roomWorker(roomId), workerId);
+        if (setResult === 0) {
+            // key 已存在，说明房间已被创建
+            this.connectionService.sendByType(connection.id, core_1.MessageType.ROOM_CREATE_FAIL, {
+                success: false,
+                error: 'ROOM_ALREADY_EXISTS',
+            });
+            return;
+        }
+        // 转发创建请求到Worker
+        const message = {
+            type: 'client-message',
+            requestId: (0, uuid_1.v4)(),
+            gatewayId: this.configService.gatewayId,
+            connectionId: connection.id,
+            userId: connection.userId,
+            roomId,
+            msgType: core_1.MessageType.ROOM_CREATE,
+            payload: { roomId, gameType, maxPlayers, config },
+            timestamp: Date.now(),
+        };
+        await this.redisService.publish(core_1.RedisChannels.rpcWorker(workerId), message);
+    }
+    /**
+     * 加入房间
+     */
+    async handleJoinRoom(connection, payload) {
+        const parseResult = core_1.JoinRoomRequestSchema.safeParse(payload);
+        if (!parseResult.success) {
+            this.connectionService.sendByType(connection.id, core_1.MessageType.ROOM_JOIN_FAIL, {
+                success: false,
+                error: 'INVALID_PAYLOAD',
+            });
+            return;
+        }
+        const { roomId } = parseResult.data;
+        // 查询房间所在Worker
+        const workerId = await this.redisService.client.get(core_1.RedisKeys.roomWorker(roomId));
+        if (!workerId) {
+            this.connectionService.sendByType(connection.id, core_1.MessageType.ROOM_JOIN_FAIL, {
+                success: false,
+                error: 'ROOM_NOT_FOUND',
+            });
+            return;
+        }
+        // 转发加入请求
+        const message = {
+            type: 'client-message',
+            requestId: (0, uuid_1.v4)(),
+            gatewayId: this.configService.gatewayId,
+            connectionId: connection.id,
+            userId: connection.userId,
+            roomId,
+            msgType: core_1.MessageType.ROOM_JOIN,
+            payload: parseResult.data,
+            timestamp: Date.now(),
+        };
+        await this.redisService.publish(core_1.RedisChannels.rpcWorker(workerId), message);
+    }
+    /**
+     * 离开房间
+     *
+     * 多房间模式：需要指定要离开的 roomId
+     * 单房间兼容：如果只在一个房间，可以不指定
+     */
+    async handleLeaveRoom(connection, payload, messageRoomId) {
+        // 从 payload 或 message.roomId 获取要离开的房间
+        const payloadRoomId = payload?.roomId;
+        const targetRoomId = payloadRoomId || messageRoomId ||
+            (connection.rooms.size === 1 ? [...connection.rooms][0] : undefined);
+        if (!targetRoomId) {
+            this.connectionService.sendByType(connection.id, core_1.MessageType.MSG_ERROR, {
+                success: false,
+                error: 'ROOM_ID_REQUIRED',
+            });
+            return;
+        }
+        if (!connection.rooms.has(targetRoomId)) {
+            this.connectionService.sendByType(connection.id, core_1.MessageType.MSG_ERROR, {
+                success: false,
+                error: 'NOT_IN_ROOM',
+            });
+            return;
+        }
+        const workerId = await this.redisService.client.get(core_1.RedisKeys.roomWorker(targetRoomId));
+        if (workerId) {
+            const message = {
+                type: 'client-message',
+                requestId: (0, uuid_1.v4)(),
+                gatewayId: this.configService.gatewayId,
+                connectionId: connection.id,
+                userId: connection.userId,
+                roomId: targetRoomId,
+                msgType: core_1.MessageType.ROOM_LEAVE,
+                payload: { roomId: targetRoomId },
+                timestamp: Date.now(),
+            };
+            await this.redisService.publish(core_1.RedisChannels.rpcWorker(workerId), message);
+        }
+    }
+    /**
+     * 转发消息到Worker
+     *
+     * @param connection 连接
+     * @param msgType 消息类型
+     * @param payload 消息内容
+     * @param roomId 目标房间ID
+     */
+    async forwardToWorker(connection, msgType, payload, roomId) {
+        const workerId = await this.redisService.client.get(core_1.RedisKeys.roomWorker(roomId));
+        if (!workerId) {
+            this.sendErrorByType(connection.id, 'ROOM_NOT_FOUND');
+            return;
+        }
+        const message = {
+            type: 'client-message',
+            requestId: (0, uuid_1.v4)(),
+            gatewayId: this.configService.gatewayId,
+            connectionId: connection.id,
+            userId: connection.userId,
+            roomId,
+            msgType,
+            payload,
+            timestamp: Date.now(),
+        };
+        await this.redisService.publish(core_1.RedisChannels.rpcWorker(workerId), message);
+    }
+    /**
+     * 选择处理鉴权的Worker
+     */
+    async selectAuthWorker() {
+        const workers = await this.getHealthyWorkers();
+        if (workers.length === 0)
+            return null;
+        return workers[Math.floor(Math.random() * workers.length)];
+    }
+    /**
+     * 根据游戏类型选择Worker
+     */
+    async selectWorker(gameType) {
+        // 先尝试按游戏类型选择
+        let workers = await this.redisService.client.smembers(core_1.RedisKeys.workersByType(gameType));
+        // 过滤出健康的Worker
+        workers = await this.filterHealthyWorkers(workers);
+        // 如果没有专门的Worker，从所有Worker中选择
+        if (workers.length === 0) {
+            workers = await this.getHealthyWorkers();
+        }
+        if (workers.length === 0)
+            return null;
+        // TODO: 实现更智能的负载均衡
+        return workers[Math.floor(Math.random() * workers.length)];
+    }
+    /**
+     * 获取所有健康的Worker
+     */
+    async getHealthyWorkers() {
+        const allWorkers = await this.redisService.client.smembers(core_1.RedisKeys.workersAll());
+        return this.filterHealthyWorkers(allWorkers);
+    }
+    /**
+     * 过滤出健康的Worker（心跳未超时且非draining状态）
+     */
+    async filterHealthyWorkers(workerIds) {
+        const HEARTBEAT_TIMEOUT = 30000; // 30秒超时
+        const now = Date.now();
+        const healthyWorkers = [];
+        for (const workerId of workerIds) {
+            const workerData = await this.redisService.client.hgetall(core_1.RedisKeys.worker(workerId));
+            if (!workerData || !workerData.lastHeartbeat) {
+                // 没有心跳信息，跳过
+                continue;
+            }
+            // 跳过draining状态的Worker
+            if (workerData.status === 'draining') {
+                this.logger.debug(`Worker ${workerId} is draining, skipping`);
+                continue;
+            }
+            const lastHeartbeat = parseInt(workerData.lastHeartbeat);
+            if (now - lastHeartbeat <= HEARTBEAT_TIMEOUT) {
+                // 心跳正常且状态为active
+                healthyWorkers.push(workerId);
+            }
+            else {
+                this.logger.debug(`Worker ${workerId} heartbeat timeout: ${now - lastHeartbeat}ms`);
+            }
+        }
+        return healthyWorkers;
+    }
+    /**
+     * 加入或创建房间（Colyseus 风格的 concurrentJoinOrCreateRoomLock）
+     *
+     * 实现原理：
+     * 1. 使用 HINCRBY 原子递增计数器，返回值为 1 的是第一个请求（负责创建）
+     * 2. 其他请求（返回值 > 1）等待创建完成
+     * 3. 创建完成后，Worker 广播通知，所有等待者自动加入
+     * 4. 所有请求都发送到同一个 Worker，由 Worker 统一处理
+     *
+     * @param connection 客户端连接
+     * @param payload 请求载荷
+     * @param token 可选的认证令牌（用于 Room.onAuth）
+     */
+    async handleJoinOrCreate(connection, payload, token, clientReqId) {
+        const parseResult = core_1.JoinOrCreateRequestSchema.safeParse(payload);
+        if (!parseResult.success) {
+            this.connectionService.sendByType(connection.id, core_1.MessageType.ROOM_JOIN_FAIL, {
+                success: false,
+                error: 'INVALID_PAYLOAD',
+            });
+            return;
+        }
+        const { roomId, gameType, maxPlayers, config, waitTimeout = 5000 } = parseResult.data;
+        // 检查房间是否已经存在
+        const existingWorkerId = await this.redisService.client.get(core_1.RedisKeys.roomWorker(roomId));
+        if (existingWorkerId) {
+            // 房间已存在，直接加入
+            await this.forwardJoinRequest(connection, roomId, existingWorkerId, true, token);
+            return;
+        }
+        // 原子递增并发计数器，同时设置过期时间
+        const lockKey = core_1.RedisKeys.roomCreatingLock(roomId);
+        const lockTimeout = Math.ceil((waitTimeout + 5000) / 1000); // 转换为秒
+        // 使用 Lua 脚本实现原子的 HINCRBY + EXPIRE
+        const script = `
+      local count = redis.call('HINCRBY', KEYS[1], 'count', 1)
+      if count == 1 then
+        redis.call('EXPIRE', KEYS[1], ARGV[1])
+      end
+      return count
+    `;
+        const requestCount = await this.redisService.client.eval(script, 1, lockKey, lockTimeout);
+        this.logger.debug(`[JoinOrCreate] ${connection.id} for room ${roomId}, requestCount=${requestCount}`);
+        // 选择 Worker（所有请求都发送到同一个 Worker）
+        let workerId = null;
+        if (requestCount === 1) {
+            // 第一个请求，选择 Worker 并记录
+            workerId = await this.selectWorker(gameType);
+            if (!workerId) {
+                // 清理锁
+                await this.redisService.client.del(lockKey);
+                this.logger.warn(`[JoinOrCreate] No worker available for gameType: ${gameType}`);
+                this.connectionService.sendByType(connection.id, core_1.MessageType.ROOM_JOIN_FAIL, {
+                    success: false,
+                    error: 'NO_WORKER_AVAILABLE',
+                });
+                return;
+            }
+            this.logger.debug(`[JoinOrCreate] Selected worker: ${workerId} for gameType: ${gameType}`);
+            await this.redisService.client.hset(lockKey, 'workerId', workerId);
+            // 预先设置房间到 Worker 的映射
+            await this.redisService.client.set(core_1.RedisKeys.roomWorker(roomId), workerId);
+        }
+        else {
+            // 等待 workerId 被设置（第一个请求可能还没选好）
+            // 最多等待 500ms，每 5ms 检查一次
+            for (let i = 0; i < 100; i++) {
+                workerId = await this.redisService.client.hget(lockKey, 'workerId');
+                if (workerId)
+                    break;
+                await new Promise(r => setTimeout(r, 5));
+            }
+            if (!workerId) {
+                this.connectionService.sendByType(connection.id, core_1.MessageType.ROOM_JOIN_FAIL, {
+                    success: false,
+                    error: 'WORKER_SELECTION_TIMEOUT',
+                });
+                return;
+            }
+        }
+        // 所有请求都转发到 Worker，由 Worker 统一处理
+        // Worker 会：
+        // - 对 requestCount=1 的请求：创建房间并加入
+        // - 对 requestCount>1 的请求：等待房间创建完成后加入
+        const message = {
+            type: 'client-message',
+            requestId: clientReqId || (0, uuid_1.v4)(), // 使用客户端的 reqId，如果没有则生成
+            gatewayId: this.configService.gatewayId,
+            connectionId: connection.id,
+            userId: connection.userId,
+            roomId,
+            msgType: core_1.MessageType.MSG_ROOM_JOIN_OR_CREATE,
+            payload: {
+                roomId,
+                gameType,
+                maxPlayers,
+                config,
+                requestCount,
+                waitTimeout,
+                token, // 传递认证令牌给 Worker（用于 Room.onAuth）
+            },
+            timestamp: Date.now(),
+        };
+        this.logger.debug(`[JoinOrCreate] Publishing message to worker ${workerId}, channel: ${core_1.RedisChannels.rpcWorker(workerId)}`);
+        await this.redisService.publish(core_1.RedisChannels.rpcWorker(workerId), message);
+    }
+    /**
+     * 转发加入请求（用于房间已存在时的 joinOrCreate）
+     *
+     * @param connection 客户端连接
+     * @param roomId 房间ID
+     * @param workerId 目标Worker ID
+     * @param isJoinOrCreate 是否为 joinOrCreate 操作
+     * @param token 可选的认证令牌
+     */
+    async forwardJoinRequest(connection, roomId, workerId, isJoinOrCreate, token) {
+        const msgType = isJoinOrCreate ? core_1.MessageType.MSG_ROOM_JOIN_OR_CREATE : core_1.MessageType.ROOM_JOIN;
+        const message = {
+            type: 'client-message',
+            requestId: (0, uuid_1.v4)(),
+            gatewayId: this.configService.gatewayId,
+            connectionId: connection.id,
+            userId: connection.userId,
+            roomId,
+            msgType,
+            payload: { roomId, requestCount: 0, token }, // requestCount=0 表示房间已存在，直接加入
+            timestamp: Date.now(),
+        };
+        await this.redisService.publish(core_1.RedisChannels.rpcWorker(workerId), message);
+    }
+};
+exports.MessageRouterService = MessageRouterService;
+exports.MessageRouterService = MessageRouterService = MessageRouterService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [config_service_1.ConfigService,
+        redis_service_1.RedisService,
+        connection_service_1.ConnectionService,
+        session_service_1.SessionService])
+], MessageRouterService);
+//# sourceMappingURL=message-router.service.js.map