perf: 提升集群稳定性；支持2节点集群；

Author: Cyaim

Cyaim.WebSocketServer/Cyaim.WebSocketServer/Infrastructure/Cluster/RaftNode.cs

@@ -297,14 +297,52 @@ private async Task StartElectionAsync()
 
             _logger.LogInformation($"Election result: {votesReceived}/{votesNeeded} votes received");
 
-            if (votesReceived >= votesNeeded && State == RaftNodeState.Candidate)
+            var totalNodes = knownNodes.Count + 1;
+            var isTwoNodeCluster = totalNodes == 2;
+
+            // Special handling for 2-node clusters or when majority cannot be achieved / 2节点集群或无法达到多数的特殊处理
+            if (votesReceived < votesNeeded && State == RaftNodeState.Candidate)
             {
-                _logger.LogInformation($"Node {_nodeId} won election with {votesReceived} votes, becoming leader");
-                BecomeLeader();
+                if (isTwoNodeCluster)
+                {
+                    _logger.LogInformation($"Two-node cluster detected. Using network quality-based leader selection.");
+                    
+                    // Add a small random delay to avoid simultaneous elections / 添加小的随机延迟以避免同时选举
+                    var randomDelay = new Random().Next(100, 300);
+                    await Task.Delay(randomDelay);
+                    
+                    // Re-check state in case we received a heartbeat from the other node / 重新检查状态，以防我们从另一个节点收到心跳
+                    if (State != RaftNodeState.Candidate)
+                    {
+                        _logger.LogInformation($"Node {_nodeId} state changed during delay, aborting leader selection");
+                        return;
+                    }
+                    
+                    // For 2-node clusters, select leader based on network quality / 对于2节点集群，基于网络质量选择Leader
+                    var shouldBecomeLeader = await ShouldBecomeLeaderBasedOnNetworkQuality(knownNodes);
+                    
+                    if (shouldBecomeLeader)
+                    {
+                        _logger.LogInformation($"Node {_nodeId} selected as leader based on network quality in 2-node cluster");
+                        BecomeLeader();
+                        return;
+                    }
+                    else
+                    {
+                        _logger.LogInformation($"Node {_nodeId} will wait for other node to become leader based on network quality");
+                        // Wait a bit longer before retrying / 在重试前等待更长时间
+                        await Task.Delay(1000);
+                    }
+                }
+                else
+                {
+                    _logger.LogInformation($"Node {_nodeId} did not receive enough votes ({votesReceived}/{votesNeeded}), will retry");
+                }
             }
-            else if (State == RaftNodeState.Candidate)
+            else if (votesReceived >= votesNeeded && State == RaftNodeState.Candidate)
             {
-                _logger.LogInformation($"Node {_nodeId} did not receive enough votes ({votesReceived}/{votesNeeded}), will retry");
+                _logger.LogInformation($"Node {_nodeId} won election with {votesReceived} votes, becoming leader");
+                BecomeLeader();
             }
         }
 
@@ -755,6 +793,87 @@ private List<string> GetKnownNodeIds()
             return nodeIds;
         }
 
+        /// <summary>
+        /// Determine if this node should become leader based on network quality (for 2-node clusters) / 基于网络质量确定此节点是否应成为Leader（用于2节点集群）
+        /// </summary>
+        /// <param name="knownNodes">List of known node IDs / 已知节点ID列表</param>
+        /// <returns>True if this node should become leader / 如果此节点应成为Leader返回 true</returns>
+        private async Task<bool> ShouldBecomeLeaderBasedOnNetworkQuality(List<string> knownNodes)
+        {
+            if (knownNodes.Count == 0)
+            {
+                return true; // Only node, become leader / 唯一节点，成为Leader
+            }
+
+            if (_transport is Transports.WebSocketClusterTransport wsTransport)
+            {
+                try
+                {
+                    // Measure network quality to all other nodes / 测量到所有其他节点的网络质量
+                    var qualityScores = new Dictionary<string, int>();
+                    var myTotalQuality = 0;
+
+                    foreach (var nodeId in knownNodes)
+                    {
+                        var quality = await wsTransport.GetNetworkQualityAsync(nodeId);
+                        qualityScores[nodeId] = quality;
+                        myTotalQuality += quality;
+                        _logger.LogDebug($"Network quality to node {nodeId}: {quality}/100");
+                    }
+
+                    // For 2-node cluster, compare our quality with the other node's quality
+                    // 对于2节点集群，比较我们的质量与另一个节点的质量
+                    if (knownNodes.Count == 1)
+                    {
+                        var otherNodeId = knownNodes[0];
+                        var otherQuality = qualityScores[otherNodeId];
+
+                        // If we have better or equal network quality, we should be leader
+                        // 如果我们有更好或相等的网络质量，我们应该成为Leader
+                        // Also consider: if we can't measure the other node's quality to us,
+                        // we'll use a tie-breaker (node ID comparison)
+                        // 同时考虑：如果我们无法测量另一个节点到我们的质量，我们将使用平局决胜（节点ID比较）
+                        
+                        if (myTotalQuality > otherQuality)
+                        {
+                            _logger.LogInformation($"Node {_nodeId} has better network quality ({myTotalQuality} vs {otherQuality}), becoming leader");
+                            return true;
+                        }
+                        else if (myTotalQuality < otherQuality)
+                        {
+                            _logger.LogInformation($"Other node has better network quality ({otherQuality} vs {myTotalQuality}), waiting");
+                            return false;
+                        }
+                        else
+                        {
+                            // Tie: use node ID as tie-breaker (lexicographically smaller becomes leader)
+                            // 平局：使用节点ID作为平局决胜（字典序较小的成为Leader）
+                            var shouldLead = string.Compare(_nodeId, otherNodeId, StringComparison.Ordinal) < 0;
+                            _logger.LogInformation($"Network quality tie ({myTotalQuality} = {otherQuality}), using node ID comparison: {_nodeId} {(shouldLead ? "<" : ">")} {otherNodeId}");
+                            return shouldLead;
+                        }
+                    }
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogWarning(ex, "Error evaluating network quality, using node ID as tie-breaker");
+                    // Fallback to node ID comparison / 回退到节点ID比较
+                    if (knownNodes.Count == 1)
+                    {
+                        return string.Compare(_nodeId, knownNodes[0], StringComparison.Ordinal) < 0;
+                    }
+                }
+            }
+
+            // Fallback: use node ID comparison / 回退：使用节点ID比较
+            if (knownNodes.Count == 1)
+            {
+                return string.Compare(_nodeId, knownNodes[0], StringComparison.Ordinal) < 0;
+            }
+
+            return false;
+        }
+
         /// <summary>
         /// Check if this node is the leader / 检查此节点是否为领导者
         /// </summary>

Cyaim.WebSocketServer/Cyaim.WebSocketServer/Infrastructure/Cluster/Transports/WebSocketClusterTransport.cs

@@ -386,6 +386,93 @@ public bool IsNodeConnected(string nodeId)
             return false;
         }
 
+        /// <summary>
+        /// Measure network latency to a node / 测量到节点的网络延迟
+        /// </summary>
+        /// <param name="nodeId">Target node ID / 目标节点 ID</param>
+        /// <returns>Latency in milliseconds, or -1 if node is not connected / 延迟（毫秒），如果节点未连接则返回 -1</returns>
+        public async Task<long> MeasureLatencyAsync(string nodeId)
+        {
+            if (!IsNodeConnected(nodeId))
+            {
+                return -1;
+            }
+
+            try
+            {
+                // Measure latency by sending a small message and measuring response time
+                // 通过发送小消息并测量响应时间来测量延迟
+                // For simplicity, we'll use connection state and a simple heuristic
+                // 为简单起见，我们将使用连接状态和简单的启发式方法
+                
+                // Check connection state and estimate latency based on connection quality
+                // 检查连接状态并根据连接质量估计延迟
+                if (_connections.TryGetValue(nodeId, out var connection))
+                {
+                    if (connection.State == WebSocketState.Open)
+                    {
+                        // Estimate latency: if connection is stable, assume low latency
+                        // 估计延迟：如果连接稳定，假设低延迟
+                        // In a production system, you'd track actual RTT from message exchanges
+                        // 在生产系统中，您会跟踪消息交换的实际RTT
+                        
+                        // For now, return a conservative estimate (50ms for local, 100ms for remote)
+                        // 目前，返回保守估计（本地50ms，远程100ms）
+                        var node = _nodes.TryGetValue(nodeId, out var n) ? n : null;
+                        if (node != null)
+                        {
+                            // If address is localhost, assume low latency / 如果地址是localhost，假设低延迟
+                            if (node.Address == "localhost" || node.Address == "127.0.0.1")
+                            {
+                                return 5; // Very low latency for local / 本地延迟非常低
+                            }
+                        }
+                        return 50; // Default estimate for connected node / 已连接节点的默认估计
+                    }
+                }
+                
+                return -1;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogWarning(ex, $"Failed to measure latency to node {nodeId}");
+                return -1;
+            }
+        }
+
+        /// <summary>
+        /// Get network quality score for a node (0-100, higher is better) / 获取节点的网络质量分数（0-100，越高越好）
+        /// </summary>
+        /// <param name="nodeId">Target node ID / 目标节点 ID</param>
+        /// <returns>Quality score (0-100) / 质量分数（0-100）</returns>
+        public async Task<int> GetNetworkQualityAsync(string nodeId)
+        {
+            if (!IsNodeConnected(nodeId))
+            {
+                return 0;
+            }
+
+            try
+            {
+                var latency = await MeasureLatencyAsync(nodeId);
+                if (latency < 0)
+                {
+                    return 0;
+                }
+
+                // Calculate quality score based on latency / 基于延迟计算质量分数
+                // Lower latency = higher quality / 延迟越低 = 质量越高
+                // 0ms = 100, 100ms = 50, 200ms+ = 0
+                var quality = Math.Max(0, 100 - (int)(latency / 2));
+                return quality;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogWarning(ex, $"Failed to get network quality for node {nodeId}");
+                return 0;
+            }
+        }
+
         /// <summary>
         /// Register a node to connect to / 注册要连接的节点
         /// </summary>