755 lines
19 KiB
Go
755 lines
19 KiB
Go
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
|
||
}
|