Initial commit
This commit is contained in:
@@ -0,0 +1,754 @@
|
||||
package connect
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"net"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"go.uber.org/zap"
|
||||
)
|
||||
|
||||
// Layer 传输层类型（9 层策略）
|
||||
type Layer int
|
||||
|
||||
const (
|
||||
// LayerDirectUDP Direct-UDP 直连（WireGuard over UDP）- 最高效
|
||||
LayerDirectUDP Layer = iota
|
||||
|
||||
// LayerFakeTCP Direct-FakeTCP（UDP 封装 TCP 头部，欺骗防火墙）
|
||||
LayerFakeTCP
|
||||
|
||||
// LayerRealTCP Direct-RealTCP（P2P TCP 直连）
|
||||
LayerRealTCP
|
||||
|
||||
// LayerTURNUDP TURN-UDP 中继（标准 RFC 5766）
|
||||
LayerTURNUDP
|
||||
|
||||
// LayerTURNQUIC TURN-QUIC 中继（私有扩展，RFC 9000）
|
||||
LayerTURNQUIC
|
||||
|
||||
// LayerTURNTCP TURN-TCP 中继（TCP 中继）
|
||||
LayerTURNTCP
|
||||
|
||||
// LayerTURNTLS TURN-TLS 中继（TLS 加密，RFC 8656）
|
||||
LayerTURNTLS
|
||||
|
||||
// LayerWebRTC WebRTC DataChannel（DTLS 加密）
|
||||
LayerWebRTC
|
||||
|
||||
// LayerWS WS/WSS 兜底（仅 80/443 端口，终极兜底）
|
||||
LayerWS
|
||||
|
||||
// LayerCount 传输层总数
|
||||
LayerCount
|
||||
)
|
||||
|
||||
// String 实现 Stringer 接口
|
||||
func (l Layer) String() string {
|
||||
switch l {
|
||||
case LayerDirectUDP:
|
||||
return "Direct-UDP"
|
||||
case LayerFakeTCP:
|
||||
return "Direct-FakeTCP"
|
||||
case LayerRealTCP:
|
||||
return "Direct-RealTCP"
|
||||
case LayerTURNUDP:
|
||||
return "TURN-UDP"
|
||||
case LayerTURNQUIC:
|
||||
return "TURN-QUIC"
|
||||
case LayerTURNTCP:
|
||||
return "TURN-TCP"
|
||||
case LayerTURNTLS:
|
||||
return "TURN-TLS"
|
||||
case LayerWebRTC:
|
||||
return "WebRTC"
|
||||
case LayerWS:
|
||||
return "WS/WSS"
|
||||
default:
|
||||
return "Unknown"
|
||||
}
|
||||
}
|
||||
|
||||
// DefaultLayerOrder 默认优先级顺序（从最优到兜底）
|
||||
// 根据 MeshRay_项目文档 v2.0.1 第 132-153 行定义
|
||||
var DefaultLayerOrder = []Layer{
|
||||
LayerDirectUDP, // 1. Direct-UDP - 公网/锥型 NAT，首选链路
|
||||
LayerFakeTCP, // 2. Direct-FakeTCP - 校园网、酒店 Wi-Fi、UDP 被 QoS 限速
|
||||
LayerRealTCP, // 3. Direct-RealTCP - 完全禁用 UDP，仅允许 TCP 出站
|
||||
LayerTURNUDP, // 4. TURN-UDP 中继 - 无 P2P 直连，但 UDP 可通
|
||||
LayerTURNQUIC, // 5. TURN-QUIC 中继 - UDP 可通但弱网（4G/5G、高丢包）【私有扩展】
|
||||
LayerTURNTCP, // 6. TURN-TCP 中继 - UDP 封禁，仅放行 TCP
|
||||
LayerTURNTLS, // 7. TURN-TLS 中继 - 企业防火墙 DPI，仅放行 HTTPS
|
||||
LayerWebRTC, // 8. WebRTC 终极兜底 - 最严格隔离内网、代理环境
|
||||
LayerWS, // 9. WS/WSS 兜底 - 仅放行 80/443 端口，且封锁 TURN
|
||||
}
|
||||
|
||||
// TransportFactory 传输工厂接口 - 每种传输方式必须实现
|
||||
type TransportFactory interface {
|
||||
// Layer 返回传输层类型
|
||||
Layer() Layer
|
||||
|
||||
// Dial 建立连接到对端
|
||||
// 返回标准的 net.Conn 接口
|
||||
Dial(ctx context.Context, config *DialConfig) (net.Conn, error)
|
||||
|
||||
// Name 返回传输方式名称（用于日志）
|
||||
Name() string
|
||||
}
|
||||
|
||||
// DialConfig 拨号配置
|
||||
type DialConfig struct {
|
||||
// PeerID 对端标识
|
||||
PeerID string
|
||||
|
||||
// PeerPublicKey 对端公钥
|
||||
PeerPublicKey string
|
||||
|
||||
// STUNServers STUN 服务器列表（用于 P2P）
|
||||
STUNServers []string
|
||||
|
||||
// TURNServers TURN 服务器列表
|
||||
TURNServers []string
|
||||
|
||||
// WSServers WebSocket 服务器列表
|
||||
WSServers []string
|
||||
|
||||
// SignalingServers WebRTC 第三方信令服务器列表
|
||||
SignalingServers []string
|
||||
|
||||
// ICESServers ICE 服务器列表（STUN+TURN 的组合）
|
||||
ICESServers []string
|
||||
|
||||
// Timeout 连接超时
|
||||
Timeout time.Duration
|
||||
|
||||
// Logger 日志记录器
|
||||
Logger *zap.Logger
|
||||
}
|
||||
|
||||
// StrategyScheduler 9 层策略调度器（主动调度层）
|
||||
// 职责：
|
||||
// 1. 按优先级选择链路（P2P → Mesh中继 → TURN-UDP → ... → WS/WSS）
|
||||
// 2. 根据网络环境自动切换（500ms 超时 / 10s 丢包率 > 10%）
|
||||
// 3. 切换后探测恢复并自动切回高性能链路（30s）
|
||||
type StrategyScheduler struct {
|
||||
layerFactories map[Layer]TransportFactory // 各层的工厂
|
||||
layerOrder []Layer // 优先级顺序
|
||||
logger *zap.Logger
|
||||
|
||||
// 每个 Peer 的降级控制器
|
||||
fallbackControllers map[string]*FallbackController // peerID -> controller
|
||||
fallbackMu sync.RWMutex
|
||||
|
||||
// 当前活跃连接
|
||||
activeConnections map[string]activeConn // peerID -> 连接信息
|
||||
connMu sync.RWMutex
|
||||
|
||||
// 统计
|
||||
stats *SchedulerStats
|
||||
|
||||
// 连接变更回调（通知上层 ConnManager）
|
||||
OnConnectionUpdate func(peerID string, conn net.Conn, err error)
|
||||
}
|
||||
|
||||
// activeConn 活跃连接信息
|
||||
type activeConn struct {
|
||||
conn net.Conn
|
||||
layer Layer
|
||||
peerID string
|
||||
established time.Time
|
||||
config *DialConfig
|
||||
}
|
||||
|
||||
// SchedulerStats 调度器统计
|
||||
type SchedulerStats struct {
|
||||
mu sync.RWMutex
|
||||
totalDials int64
|
||||
successDials int64
|
||||
fallbackCount int64
|
||||
recoveryCount int64
|
||||
layerDialCount map[Layer]int64
|
||||
layerFailCount map[Layer]int64
|
||||
}
|
||||
|
||||
// NewStrategyScheduler 创建策略调度器
|
||||
func NewStrategyScheduler(logger *zap.Logger) *StrategyScheduler {
|
||||
return &StrategyScheduler{
|
||||
layerFactories: make(map[Layer]TransportFactory),
|
||||
layerOrder: DefaultLayerOrder,
|
||||
logger: logger,
|
||||
fallbackControllers: make(map[string]*FallbackController),
|
||||
activeConnections: make(map[string]activeConn),
|
||||
stats: &SchedulerStats{
|
||||
layerDialCount: make(map[Layer]int64),
|
||||
layerFailCount: make(map[Layer]int64),
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
// RegisterFactory 注册传输工厂
|
||||
func (s *StrategyScheduler) RegisterFactory(factory TransportFactory) {
|
||||
layer := factory.Layer()
|
||||
s.layerFactories[layer] = factory
|
||||
s.logger.Debug("注册传输工厂",
|
||||
zap.String("layer", layer.String()),
|
||||
zap.String("name", factory.Name()))
|
||||
}
|
||||
|
||||
// SetLayerOrder 设置优先级顺序
|
||||
func (s *StrategyScheduler) SetLayerOrder(order []Layer) {
|
||||
if len(order) == 0 {
|
||||
s.logger.Warn("空的层级顺序，使用默认顺序")
|
||||
return
|
||||
}
|
||||
s.layerOrder = order
|
||||
s.logger.Info("更新传输层优先级顺序", zap.Any("order", order))
|
||||
}
|
||||
|
||||
// Dial 按优先级顺序尝试建立连接
|
||||
// 这是核心方法，实现了 9 层策略调度
|
||||
func (s *StrategyScheduler) Dial(config *DialConfig) (net.Conn, error) {
|
||||
ctx := context.Background()
|
||||
if config.Timeout > 0 {
|
||||
var cancel context.CancelFunc
|
||||
ctx, cancel = context.WithTimeout(ctx, config.Timeout)
|
||||
defer cancel()
|
||||
}
|
||||
|
||||
s.logger.Info("开始 8 层策略调度连接",
|
||||
zap.String("peer_id", config.PeerID),
|
||||
zap.Int("total_layers", len(s.layerOrder)))
|
||||
|
||||
// 统计
|
||||
s.stats.mu.Lock()
|
||||
s.stats.totalDials++
|
||||
s.stats.mu.Unlock()
|
||||
|
||||
var lastErr error
|
||||
for i, layer := range s.layerOrder {
|
||||
factory, ok := s.layerFactories[layer]
|
||||
if !ok {
|
||||
s.logger.Debug("该传输层未注册，跳过",
|
||||
zap.String("layer", layer.String()))
|
||||
continue
|
||||
}
|
||||
|
||||
s.logger.Debug("尝试第 N 层传输",
|
||||
zap.Int("index", i),
|
||||
zap.String("layer", layer.String()),
|
||||
zap.String("name", factory.Name()))
|
||||
|
||||
// 统计该层拨号次数
|
||||
s.stats.mu.Lock()
|
||||
s.stats.layerDialCount[layer]++
|
||||
s.stats.mu.Unlock()
|
||||
|
||||
startTime := time.Now()
|
||||
conn, err := factory.Dial(ctx, config)
|
||||
duration := time.Since(startTime)
|
||||
|
||||
if err == nil {
|
||||
// 成功！
|
||||
s.stats.mu.Lock()
|
||||
s.stats.successDials++
|
||||
s.stats.mu.Unlock()
|
||||
|
||||
// 记录活跃连接
|
||||
s.connMu.Lock()
|
||||
s.activeConnections[config.PeerID] = activeConn{
|
||||
conn: conn,
|
||||
layer: layer,
|
||||
peerID: config.PeerID,
|
||||
established: time.Now(),
|
||||
config: config,
|
||||
}
|
||||
s.connMu.Unlock()
|
||||
|
||||
// 创建或更新降级控制器
|
||||
s.ensureFallbackController(config.PeerID, layer)
|
||||
|
||||
s.logger.Info("连接建立成功",
|
||||
zap.String("layer", layer.String()),
|
||||
zap.String("name", factory.Name()),
|
||||
zap.String("peer_id", config.PeerID),
|
||||
zap.String("remote_addr", conn.RemoteAddr().String()),
|
||||
zap.Duration("duration", duration))
|
||||
|
||||
// 包装连接，用于监控
|
||||
return newMonitoredConn(conn, config.PeerID, layer, s), nil
|
||||
}
|
||||
|
||||
// 失败，统计
|
||||
s.stats.mu.Lock()
|
||||
s.stats.layerFailCount[layer]++
|
||||
s.stats.mu.Unlock()
|
||||
|
||||
// 记录失败并继续尝试下一层
|
||||
lastErr = err
|
||||
s.logger.Warn("该传输层连接失败，尝试下一层",
|
||||
zap.String("layer", layer.String()),
|
||||
zap.Duration("duration", duration),
|
||||
zap.Error(err))
|
||||
}
|
||||
|
||||
// 所有层都失败
|
||||
return nil, fmt.Errorf("所有传输层均失败，最后错误：%w", lastErr)
|
||||
}
|
||||
|
||||
// reconnectToLayer 触发重连到指定层级
|
||||
func (s *StrategyScheduler) reconnectToLayer(peerID string, toLayer Layer) {
|
||||
s.connMu.RLock()
|
||||
ac, exists := s.activeConnections[peerID]
|
||||
s.connMu.RUnlock()
|
||||
|
||||
if !exists || ac.config == nil {
|
||||
s.logger.Warn("重连失败：找不到活跃连接配置", zap.String("peer_id", peerID))
|
||||
return
|
||||
}
|
||||
|
||||
factory, ok := s.layerFactories[toLayer]
|
||||
if !ok {
|
||||
s.logger.Error("重连失败：找不到目标层级工厂", zap.String("layer", toLayer.String()))
|
||||
return
|
||||
}
|
||||
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
||||
defer cancel()
|
||||
|
||||
conn, err := factory.Dial(ctx, ac.config)
|
||||
if err != nil {
|
||||
s.logger.Error("降级重连失败", zap.Error(err))
|
||||
if s.OnConnectionUpdate != nil {
|
||||
s.OnConnectionUpdate(peerID, nil, err)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
wrappedConn := newMonitoredConn(conn, peerID, toLayer, s)
|
||||
|
||||
s.connMu.Lock()
|
||||
if oldAc, exists := s.activeConnections[peerID]; exists {
|
||||
oldAc.conn.Close()
|
||||
}
|
||||
s.activeConnections[peerID] = activeConn{
|
||||
conn: wrappedConn,
|
||||
layer: toLayer,
|
||||
peerID: peerID,
|
||||
established: time.Now(),
|
||||
config: ac.config,
|
||||
}
|
||||
s.connMu.Unlock()
|
||||
|
||||
if s.OnConnectionUpdate != nil {
|
||||
s.OnConnectionUpdate(peerID, wrappedConn, nil)
|
||||
}
|
||||
}
|
||||
|
||||
// ensureFallbackController 确保对端有降级控制器
|
||||
func (s *StrategyScheduler) ensureFallbackController(peerID string, initialLayer Layer) {
|
||||
s.fallbackMu.Lock()
|
||||
defer s.fallbackMu.Unlock()
|
||||
|
||||
if _, exists := s.fallbackControllers[peerID]; !exists {
|
||||
controller := NewFallbackController(
|
||||
initialLayer,
|
||||
func(from, to Layer) {
|
||||
// 降级回调
|
||||
s.stats.mu.Lock()
|
||||
s.stats.fallbackCount++
|
||||
s.stats.mu.Unlock()
|
||||
|
||||
s.logger.Warn("链路降级",
|
||||
zap.String("peer_id", peerID),
|
||||
zap.String("from_layer", from.String()),
|
||||
zap.String("to_layer", to.String()))
|
||||
|
||||
// 触发重连到新层级
|
||||
go s.reconnectToLayer(peerID, to)
|
||||
},
|
||||
func(to Layer) {
|
||||
// 恢复回调
|
||||
s.stats.mu.Lock()
|
||||
s.stats.recoveryCount++
|
||||
s.stats.mu.Unlock()
|
||||
|
||||
s.logger.Info("链路恢复",
|
||||
zap.String("peer_id", peerID),
|
||||
zap.String("to_layer", to.String()))
|
||||
|
||||
// 回调处理已经在 probeHighLayers 中完成并传递了新连接
|
||||
},
|
||||
s.logger,
|
||||
s, // pass scheduler to access activeConnections
|
||||
)
|
||||
s.fallbackControllers[peerID] = controller
|
||||
}
|
||||
}
|
||||
|
||||
// RecordLatency 记录延迟（供 MonitoredConn 调用）
|
||||
func (s *StrategyScheduler) RecordLatency(peerID string, success bool, duration time.Duration) {
|
||||
s.fallbackMu.RLock()
|
||||
controller, exists := s.fallbackControllers[peerID]
|
||||
s.fallbackMu.RUnlock()
|
||||
|
||||
if exists {
|
||||
controller.CheckAndFallback(success, duration)
|
||||
}
|
||||
}
|
||||
|
||||
// GetActiveLayer 获取当前活跃的传输层（用于监控）
|
||||
func (s *StrategyScheduler) GetActiveLayer() Layer {
|
||||
// 返回第一个活跃连接的层级
|
||||
s.connMu.RLock()
|
||||
defer s.connMu.RUnlock()
|
||||
|
||||
for _, ac := range s.activeConnections {
|
||||
return ac.layer
|
||||
}
|
||||
return LayerDirectUDP // 默认值
|
||||
}
|
||||
|
||||
// GetAllActiveLayers 获取所有 Peer 的活跃层级（用于全局监控）
|
||||
func (s *StrategyScheduler) GetAllActiveLayers() map[string]Layer {
|
||||
s.connMu.RLock()
|
||||
defer s.connMu.RUnlock()
|
||||
|
||||
result := make(map[string]Layer)
|
||||
for peerID, ac := range s.activeConnections {
|
||||
result[peerID] = ac.layer
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
// GetPeerLayer 获取指定 Peer 的当前层级
|
||||
func (s *StrategyScheduler) GetPeerLayer(peerID string) Layer {
|
||||
s.connMu.RLock()
|
||||
defer s.connMu.RUnlock()
|
||||
|
||||
if ac, exists := s.activeConnections[peerID]; exists {
|
||||
return ac.layer
|
||||
}
|
||||
return LayerDirectUDP // 默认值
|
||||
}
|
||||
|
||||
// GetStats 获取统计信息
|
||||
func (s *StrategyScheduler) GetStats() map[string]interface{} {
|
||||
s.stats.mu.RLock()
|
||||
defer s.stats.mu.RUnlock()
|
||||
|
||||
layerStats := make(map[string]int64)
|
||||
for layer, count := range s.stats.layerDialCount {
|
||||
layerStats[layer.String()+"_dial"] = count
|
||||
}
|
||||
for layer, count := range s.stats.layerFailCount {
|
||||
layerStats[layer.String()+"_fail"] = count
|
||||
}
|
||||
|
||||
return map[string]interface{}{
|
||||
"total_dials": s.stats.totalDials,
|
||||
"success_dials": s.stats.successDials,
|
||||
"fallback_count": s.stats.fallbackCount,
|
||||
"recovery_count": s.stats.recoveryCount,
|
||||
"layer_stats": layerStats,
|
||||
}
|
||||
}
|
||||
|
||||
// ClosePeer 关闭指定 Peer 的连接和控制器
|
||||
func (s *StrategyScheduler) ClosePeer(peerID string) {
|
||||
// 关闭连接
|
||||
s.connMu.Lock()
|
||||
if ac, exists := s.activeConnections[peerID]; exists {
|
||||
ac.conn.Close()
|
||||
delete(s.activeConnections, peerID)
|
||||
}
|
||||
s.connMu.Unlock()
|
||||
|
||||
// 移除降级控制器
|
||||
s.fallbackMu.Lock()
|
||||
if controller, exists := s.fallbackControllers[peerID]; exists {
|
||||
// 停止恢复探测器
|
||||
if controller.recoveryTimer != nil {
|
||||
controller.recoveryTimer.Stop()
|
||||
}
|
||||
delete(s.fallbackControllers, peerID)
|
||||
}
|
||||
s.fallbackMu.Unlock()
|
||||
|
||||
s.logger.Debug("已关闭 Peer 连接和控制器",
|
||||
zap.String("peer_id", peerID))
|
||||
}
|
||||
|
||||
// MonitoredConn 带监控的连接包装器
|
||||
type MonitoredConn struct {
|
||||
net.Conn
|
||||
peerID string
|
||||
layer Layer
|
||||
scheduler *StrategyScheduler
|
||||
}
|
||||
|
||||
// newMonitoredConn 创建带监控的连接
|
||||
func newMonitoredConn(conn net.Conn, peerID string, layer Layer, scheduler *StrategyScheduler) *MonitoredConn {
|
||||
return &MonitoredConn{
|
||||
Conn: conn,
|
||||
peerID: peerID,
|
||||
layer: layer,
|
||||
scheduler: scheduler,
|
||||
}
|
||||
}
|
||||
|
||||
// Read 重写 Read 方法，记录延迟
|
||||
func (c *MonitoredConn) Read(b []byte) (n int, err error) {
|
||||
start := time.Now()
|
||||
n, err = c.Conn.Read(b)
|
||||
duration := time.Since(start)
|
||||
|
||||
// 记录成功/失败
|
||||
c.scheduler.RecordLatency(c.peerID, err == nil, duration)
|
||||
|
||||
return n, err
|
||||
}
|
||||
|
||||
// Write 重写 Write 方法，记录延迟
|
||||
func (c *MonitoredConn) Write(b []byte) (n int, err error) {
|
||||
start := time.Now()
|
||||
n, err = c.Conn.Write(b)
|
||||
duration := time.Since(start)
|
||||
|
||||
// 记录成功/失败
|
||||
c.scheduler.RecordLatency(c.peerID, err == nil, duration)
|
||||
|
||||
return n, err
|
||||
}
|
||||
|
||||
// FallbackController 降级控制器
|
||||
type FallbackController struct {
|
||||
currentLayer Layer // 当前使用的层
|
||||
windowStart time.Time // 滑动窗口起始时间
|
||||
packetCount int // 总包数
|
||||
lostPacketCount int // 丢包数
|
||||
mu chan struct{} // 互斥锁（用 channel 实现）
|
||||
triggerFallback func(Layer, Layer) // 降级触发回调
|
||||
triggerRecovery func(Layer) // 恢复触发回调
|
||||
logger *zap.Logger
|
||||
recoveryTimer *time.Timer // 恢复探测定时器
|
||||
scheduler *StrategyScheduler
|
||||
}
|
||||
|
||||
const (
|
||||
// TimeoutThreshold 单次超时阈值
|
||||
TimeoutThreshold = 500 * time.Millisecond
|
||||
|
||||
// PacketLossThreshold 丢包率阈值
|
||||
PacketLossThreshold = 0.10 // 10%
|
||||
|
||||
// RecoveryInterval 恢复探测间隔
|
||||
RecoveryInterval = 30 * time.Second
|
||||
|
||||
// SlidingWindowDuration 滑动窗口时长
|
||||
SlidingWindowDuration = 10 * time.Second
|
||||
)
|
||||
|
||||
// NewFallbackController 创建降级控制器
|
||||
func NewFallbackController(
|
||||
initialLayer Layer,
|
||||
onFallback func(Layer, Layer),
|
||||
onRecovery func(Layer),
|
||||
logger *zap.Logger,
|
||||
scheduler *StrategyScheduler,
|
||||
) *FallbackController {
|
||||
fc := &FallbackController{
|
||||
currentLayer: initialLayer,
|
||||
mu: make(chan struct{}, 1),
|
||||
triggerFallback: onFallback,
|
||||
triggerRecovery: onRecovery,
|
||||
logger: logger,
|
||||
scheduler: scheduler,
|
||||
}
|
||||
|
||||
// 启动恢复探测
|
||||
fc.startRecoveryProbe()
|
||||
|
||||
return fc
|
||||
}
|
||||
|
||||
// CheckAndFallback 检查是否需要降级
|
||||
// 在每次连接操作后调用
|
||||
func (fc *FallbackController) CheckAndFallback(success bool, duration time.Duration) {
|
||||
select {
|
||||
case fc.mu <- struct{}{}:
|
||||
defer func() { <-fc.mu }()
|
||||
default:
|
||||
// 锁被占用，说明正在处理，直接返回
|
||||
return
|
||||
}
|
||||
|
||||
// 重置滑动窗口
|
||||
if time.Since(fc.windowStart) > SlidingWindowDuration {
|
||||
fc.windowStart = time.Now()
|
||||
fc.packetCount = 0
|
||||
fc.lostPacketCount = 0
|
||||
}
|
||||
|
||||
// 统计
|
||||
fc.packetCount++
|
||||
if !success || duration > TimeoutThreshold {
|
||||
fc.lostPacketCount++
|
||||
}
|
||||
|
||||
// 检查是否达到阈值
|
||||
if fc.packetCount >= 10 {
|
||||
lossRate := float64(fc.lostPacketCount) / float64(fc.packetCount)
|
||||
if lossRate > PacketLossThreshold {
|
||||
fc.triggerFallbackLocked()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// triggerFallbackLocked 执行降级（已持有锁）
|
||||
func (fc *FallbackController) triggerFallbackLocked() {
|
||||
currentIndex := int(fc.currentLayer)
|
||||
if currentIndex >= int(LayerCount)-1 {
|
||||
// 已经是最低优先级，无法降级
|
||||
fc.logger.Warn("已是最底层级，无法降级",
|
||||
zap.String("current_layer", fc.currentLayer.String()))
|
||||
return
|
||||
}
|
||||
|
||||
nextLayer := Layer(currentIndex + 1)
|
||||
|
||||
// 在更新 currentLayer 之前保存旧值用于回调
|
||||
oldLayer := fc.currentLayer
|
||||
|
||||
fc.logger.Warn("触发降级",
|
||||
zap.String("from_layer", oldLayer.String()),
|
||||
zap.String("to_layer", nextLayer.String()))
|
||||
|
||||
fc.currentLayer = nextLayer
|
||||
fc.resetWindow()
|
||||
|
||||
if fc.triggerFallback != nil {
|
||||
fc.triggerFallback(oldLayer, nextLayer)
|
||||
}
|
||||
|
||||
// 重置恢复定时器
|
||||
fc.startRecoveryProbe()
|
||||
}
|
||||
|
||||
// startRecoveryProbe 启动恢复探测
|
||||
func (fc *FallbackController) startRecoveryProbe() {
|
||||
if fc.recoveryTimer != nil {
|
||||
fc.recoveryTimer.Stop()
|
||||
}
|
||||
|
||||
fc.recoveryTimer = time.AfterFunc(RecoveryInterval, func() {
|
||||
fc.probeHigherLayers()
|
||||
})
|
||||
}
|
||||
|
||||
// probeHigherLayers 探测更高层级
|
||||
func (fc *FallbackController) probeHigherLayers() {
|
||||
select {
|
||||
case fc.mu <- struct{}{}:
|
||||
defer func() { <-fc.mu }()
|
||||
default:
|
||||
return
|
||||
}
|
||||
|
||||
currentIndex := int(fc.currentLayer)
|
||||
if currentIndex == 0 {
|
||||
// 已经是最高优先级，无需探测
|
||||
return
|
||||
}
|
||||
|
||||
// 尝试上一层
|
||||
higherLayer := Layer(currentIndex - 1)
|
||||
fc.logger.Info("探测更高层级",
|
||||
zap.String("current_layer", fc.currentLayer.String()),
|
||||
zap.String("probe_layer", higherLayer.String()))
|
||||
|
||||
// 获取 PeerID 及 Config
|
||||
fc.scheduler.connMu.RLock()
|
||||
var peerID string
|
||||
var config *DialConfig
|
||||
for pid, ac := range fc.scheduler.activeConnections {
|
||||
if ac.layer == fc.currentLayer {
|
||||
peerID = pid
|
||||
config = ac.config
|
||||
break
|
||||
}
|
||||
}
|
||||
fc.scheduler.connMu.RUnlock()
|
||||
|
||||
if config == nil {
|
||||
fc.logger.Warn("探测更高层级失败：找不到有效 DialConfig")
|
||||
return
|
||||
}
|
||||
|
||||
factory, ok := fc.scheduler.layerFactories[higherLayer]
|
||||
if !ok {
|
||||
fc.logger.Debug("更高层级未注册工厂，跳过探测")
|
||||
return
|
||||
}
|
||||
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
||||
defer cancel()
|
||||
|
||||
conn, err := factory.Dial(ctx, config)
|
||||
if err == nil {
|
||||
fc.logger.Info("更高层级探测成功，准备切换")
|
||||
|
||||
wrappedConn := newMonitoredConn(conn, peerID, higherLayer, fc.scheduler)
|
||||
|
||||
fc.scheduler.connMu.Lock()
|
||||
if ac, exists := fc.scheduler.activeConnections[peerID]; exists {
|
||||
ac.conn.Close() // Close old
|
||||
ac.conn = wrappedConn
|
||||
ac.layer = higherLayer
|
||||
fc.scheduler.activeConnections[peerID] = ac
|
||||
}
|
||||
fc.scheduler.connMu.Unlock()
|
||||
|
||||
if fc.scheduler.OnConnectionUpdate != nil {
|
||||
fc.scheduler.OnConnectionUpdate(peerID, wrappedConn, nil)
|
||||
}
|
||||
|
||||
// 触发恢复回调
|
||||
fc.triggerRecoveryLocked(higherLayer)
|
||||
} else {
|
||||
fc.logger.Debug("更高层级探测失败", zap.Error(err))
|
||||
}
|
||||
}
|
||||
|
||||
// triggerRecoveryLocked 执行恢复（已持有锁）
|
||||
func (fc *FallbackController) triggerRecoveryLocked(higherLayer Layer) {
|
||||
fc.logger.Info("触发恢复",
|
||||
zap.String("from_layer", fc.currentLayer.String()),
|
||||
zap.String("to_layer", higherLayer.String()))
|
||||
|
||||
fc.currentLayer = higherLayer
|
||||
fc.resetWindow()
|
||||
|
||||
if fc.triggerRecovery != nil {
|
||||
fc.triggerRecovery(higherLayer)
|
||||
}
|
||||
}
|
||||
|
||||
// resetWindow 重置滑动窗口
|
||||
func (fc *FallbackController) resetWindow() {
|
||||
fc.windowStart = time.Now()
|
||||
fc.packetCount = 0
|
||||
fc.lostPacketCount = 0
|
||||
}
|
||||
|
||||
// GetCurrentLayer 获取当前层级
|
||||
func (fc *FallbackController) GetCurrentLayer() Layer {
|
||||
select {
|
||||
case fc.mu <- struct{}{}:
|
||||
defer func() { <-fc.mu }()
|
||||
default:
|
||||
return fc.currentLayer
|
||||
}
|
||||
return fc.currentLayer
|
||||
}
|
||||
Reference in New Issue
Block a user