WebRTC P2P 信令服务架构设计文档

技术要求

• 开发语言：Go（服务端）、JavaScript（浏览器端）、Python（测试）
• 核心库：
  • WebRTC：pion/webrtc（Go）、native WebRTC API（浏览器）
  • WebSocket：gorilla/websocket（Go）
  • SSH/SFTP：golang.org/x/crypto/ssh（Go）
  • 测试工具：websocket-client（Python）、aiortc（Python）

关键指标

• 连接建立时间：< 5 秒
• 数据传输延迟：< 100ms（P2P 模式）
• 并发会话数：< 100
• 错误率：< 1%

第二阶段：性能、容错与安全增强

架构设计

• 增强的信令服务器：添加连接质量监控和负载均衡
• 智能 WebRTC 连接管理：实现连接质量评估和自动模式切换
• 完善的会话管理：添加会话负载均衡和故障转移
• 增强的安全机制：实现完整的认证和授权

核心组件

1. 连接质量监控
   • 网络延迟监测
   • 丢包率监测
   • 带宽监测
   • 自动模式切换
2. 错误处理与恢复
   • 完善的错误处理机制
   • 网络异常自动恢复
   • 会话状态同步
3. 性能优化
   • 数据压缩
   • 批量处理
   • 连接复用
   • 内存优化
4. 安全增强
   • 令牌认证机制
   • SSH 主机密钥验证
   • 敏感信息加密
   • 访问控制
5. 负载均衡
   • 会话负载均衡
   • 连接池管理
   • 故障转移

技术要求

• 新增库：
  • 监控库：prometheus（可选）
  • 加密库：crypto/tls（Go）
  • 负载均衡：自定义实现

关键指标

• 连接建立时间：< 3 秒
• 数据传输延迟：< 50ms（P2P 模式）
• 并发会话数：< 500
• 错误率：< 0.1%
• 恢复时间：< 10 秒（网络故障）

第三阶段：监控、集群与高级特性

架构设计

• 信令服务器集群：实现高可用和水平扩展
• 远程代理集群：实现多代理负载均衡和故障转移
• 完整的监控系统：实现全系统监控和告警
• 高级特性：实现多租户、API 和管理界面

核心组件

1. 信令服务器集群
   • 集群发现和管理
   • 负载均衡
   • 高可用
   • 数据同步
2. 远程代理集群
   • 代理发现和注册
   • 智能负载均衡
   • 故障自动转移
   • 健康检查
3. 监控与告警
   • 系统指标监控
   • 服务状态监控
   • 网络质量监控
   • 智能告警
4. 高级特性
   • 多租户支持
   • RESTful API
   • 管理界面
   • 配置中心

技术要求

• 新增库：
  • 集群管理：etcd（可选）
  • 监控：prometheus + grafana
  • API 框架：gin（Go）
  • 前端框架：React/Vue（可选）

关键指标

• 系统可用性：> 99.9%
• 并发会话数：> 1000
• 响应时间：< 200ms（API）
• 故障恢复：< 30 秒（节点故障）
• 扩展性：支持水平扩展

业务模式

• 浏览器模式: WebSSH/WebFile 终端和文件管理
  • 直连模式：浏览器 → 信令服务器 → 目标服务器
  • 代理模式：浏览器 → WebRTC 隧道 → 远程代理 → 目标服务器
• 本地代理模式: APP 和目标服务器 TCP/UDP 通讯
  • APP → 本地代理 → WebRTC 隧道 → 远程代理 → 目标服务器

1. 名词定义

2. 通讯接口

2.1 WebSocket 接口

接口地址：

• HTTP 版本：ws://{host}:{port}/ws
  • 开发环境示例：ws://localhost:3800/ws
  • 生产环境示例：wss://example.com:3700/ws
• HTTPS 版本：wss://{host}:{port}/ws
  • 开发环境示例：wss://localhost:3800/ws
  • 生产环境示例：wss://example.com:3700/ws

URI 参数说明：

服务类型说明： 所有客户端使用统一的 WebSocket 端点，服务类型和连接模式信息通过注册指令体现：

• 客户端类型：浏览器类、本地代理类、远程代理类
• 功能类型：WebSSH 终端、文件传输、TCP/UDP 隧道中转等

连接模式说明：

• 直连模式（direct）：浏览器直接通过信令服务器连接目标服务器
  • 适用于 WebSSH 和 WebFile 功能
  • 不需要建立 WebRTC 连接
• 远程代理模式（remote_proxy）：通过 WebRTC 隧道连接到远程代理，再访问目标服务器
  • 适用于需要穿透防火墙的场景
  • 支持 P2P 和中继连接方式
• P2P 模式：浏览器/本地代理与远程代理之间建立直接的 P2P 连接
  • 优先使用，提供更低的延迟和更高的带宽
• 中继模式：通过 TURN 服务器中继浏览器/远程代理与远程代理之间的通信
  • 当 P2P 连接失败时使用
  • 确保在复杂网络环境下的连接可靠性

服务类型说明：

• WebSSH（webssh）：提供 SSH 终端访问服务
  • 通过 xterm.js 实现 Web 终端界面
  • 支持终端大小调整、颜色方案等高级功能
• WebFile（webfile）：提供文件传输和管理服务
  • 支持文件上传、下载、删除、重命名等操作
  • 支持大文件分块传输和断点续传

连接建立流程：

所有客户端通用流程

1. 客户端构建统一的 WebSocket URI：ws://{host}:{port}/ws（或 HTTPS 版本的 wss://{host}:{port}/ws）
2. 客户端通过 WebSocket 协议连接到指定 URI
3. 服务器验证连接请求
4. 连接建立成功后，客户端通过 register 消息发送注册信息，包括角色、类别、功能等
5. 服务器根据注册信息进行服务路由和配置
6. 客户端可以通过 connect_request 消息发起具体的连接请求，指定连接模式等参数

2.2 STUN/TURN 服务器配置机制

核心原则：

• STUN 服务器：本地代理、浏览器客户端和远程代理分别使用自己配置文件中的 STUN 服务器
• TURN 服务器：本地代理、浏览器客户端和远程代理统一使用远程代理配置文件中的 TURN 服务器
• TURN 配置获取：本地代理和浏览器客户端通过信令服务器从远程代理获取 TURN 服务器配置

详细流程：

1. 远程代理启动时：
   • 加载自身配置文件中的 STUN 服务器和 TURN 服务器
   • 为 TURN 服务器生成动态凭证（如果需要）
   • 向信令服务器注册，并提供 TURN 服务器配置信息
2. 本地代理启动时：
   • 加载自身配置文件中的 STUN 服务器
   • 向信令服务器注册
3. 浏览器客户端连接时：
   • 直接通过 WebSocket 连接信令服务器
   • 浏览器客户端可以使用自身配置的 STUN 服务器（如果有）
4. 连接建立时：
   • 客户端（本地代理/浏览器）发起连接请求（connect_request）
   • 信令服务器将请求转发给远程代理
   • 远程代理返回连接响应（connect_response），包含自身的 TURN 服务器配置
   • 信令服务器将远程代理的 TURN 服务器配置转发给客户端
5. WebRTC 连接建立：
   • 本地代理使用自身配置的 STUN 服务器和远程代理提供的 TURN 服务器建立 WebRTC 连接
   • 浏览器客户端使用自身配置的 STUN 服务器（如果有）和远程代理提供的 TURN 服务器建立 WebRTC 连接
   • 远程代理使用自身配置的 STUN 服务器和自身配置的 TURN 服务器建立 WebRTC 连接

配置文件说明：

• 本地代理配置文件：仅包含 STUN 服务器配置
• 浏览器客户端：可在页面配置或使用默认 STUN 服务器
• 远程代理配置文件：包含 STUN 服务器和 TURN 服务器配置

安全考虑：

• TURN 服务器凭证由远程代理动态生成，确保安全性
• 信令服务器仅转发 TURN 服务器配置，不存储敏感信息
• 浏览器客户端的 STUN 服务器配置应从安全可靠的来源获取

连接请求信息

客户端在注册后，通过 connect_request 消息传递以下信息：

• 客户端详细信息（类型、子类型、版本等）
• 连接参数（模式、协议、超时设置等）
• SSH 访问参数（仅浏览器类 ssh 子类型时使用）
• 目标代理 ID
• 能力需求
• 代理令牌

核心用途：

• 统一连接入口：为所有客户端（浏览器和 APP）提供统一的 WebSocket 连接入口
• 信令交换通道：作为 WebRTC 连接建立和管理的信令传输通道
• 服务协商机制：通过注册协议实现客户端类型、连接模式和功能需求的动态协商
• 跨平台支持：同时支持浏览器类和 APP 类客户端，实现统一的通信架构
• 灵活的服务路由：服务器根据客户端注册信息进行动态服务路由和配置
• 多种功能支持：同时支持 WebSSH 终端、文件传输、P2P 连接和中继传输等多种功能

重要约束：

• 信令服务器和远程代理都作为 SSH/SFTP 客户端连接目标服务器
• 直连模式：信令服务器直接连接目标服务器
• 代理模式：远程代理连接目标服务器
• 所有 SSH/SFTP 连接使用项目统一的连接管理器

支持的消息类型：

消息体参数定义：

1. register (注册请求)

{
  "type": "register",
  "request_id": "req_123456789",
  "from": "browser_abc123",
  "timestamp": "2023-01-01T12:00:00Z",
  "proxy_id": "browser_abc123",
  "role": "browser",
  "version": "v1.0.0"
}

注册指令说明： 注册指令包含以下核心信息，用于标识客户端的角色、类别和功能：

• 角色与类别：通过 role 字段和 proxy_id 前缀共同标识
  • role 字段：明确客户端类型（browser/app/local/remote）
  • proxy_id 前缀：与 role 字段保持一致（browser_/app_/local_/remote_）
• 版本信息：通过 version 字段提供客户端软件版本

服务路由逻辑： 服务器根据注册信息进行动态服务路由和配置：

• 浏览器类客户端：根据后续的连接请求中的 service_type 提供相应的 WebSSH 或 WebFile 功能
• APP 类客户端：支持 P2P 和中继连接功能
• 本地代理类客户端：提供 TCP/UDP 隧道中转服务
• 远程代理类客户端：作为目标服务器的接入点

连接模式信息： 连接模式信息通过后续的 connect_request 消息传递：

• 浏览器类：支持直连模式和代理模式
• APP 类：支持自动模式、P2P 模式和中继模式

2. register_response (注册响应)

{
  "type": "register_response",
  "request_id": "req_123456789",
  "from": "signaling_server",
  "to": "browser_abc123",
  "timestamp": "2023-01-01T12:00:01Z",
  "code": 200,
  "message": "Register successful",
  "success": true
}

3. connect_request (连接请求)

{
  "type": "connect_request",
  "request_id": "req_987654321",
  "from": "browser_abc123",
  "timestamp": "2023-01-01T12:00:02Z",
  "target_proxy_id": "remote_abc123",
  "mode_preference": "p2p",
  "proxy_token": "token_secure123",
  "connection_mode": "remote_proxy",
  "service_type": "webssh"
}

4. connect_response (连接响应)

{
  "type": "connect_response",
  "request_id": "req_987654321",
  "from": "signaling_server",
  "to": "browser_abc123",
  "timestamp": "2023-01-01T12:00:03Z",
  "code": 200,
  "message": "Connect request accepted",
  "success": true,
  "p2p_info": {
    "status": "available"
  },
  "relay_info": {
    "status": "available",
    "turn_servers": [
      {
        "urls": ["turn:turn.example.com:3478"],
        "username": "user123",
        "credential": "pass123"
      }
    ]
  }
}

5. sdp_offer (SDP Offer)

{
  "type": "sdp_offer",
  "request_id": "req_offer_123",
  "from": "browser_abc123",
  "to": "remote_abc123",
  "timestamp": "2023-01-01T12:00:04Z",
  "call_id": "call_abc123",
  "sdp": {
    "type": "offer",
    "sdp": "v=0\r\no=- 1234567890 1 IN IP4 192.168.1.1..."
  },
  "proxy_token": "token_secure123",
  "mode_preference": "auto"
}

6. sdp_answer (SDP Answer)

{
  "type": "sdp_answer",
  "request_id": "req_answer_123",
  "from": "remote_abc123",
  "to": "browser_abc123",
  "timestamp": "2023-01-01T12:00:05Z",
  "call_id": "call_abc123",
  "sdp": {
    "type": "answer",
    "sdp": "v=0\r\no=- 0123456789 1 IN IP4 10.0.0.1..."
  },
  "proxy_token": "token_secure123",
  "mode_preference": "auto"
}

7. ice_candidate (ICE Candidate)

{
  "type": "ice_candidate",
  "request_id": "req_ice_123",
  "from": "browser_abc123",
  "to": "remote_abc123",
  "timestamp": "2023-01-01T12:00:06Z",
  "call_id": "call_abc123",
  "candidate": {
    "candidate": "a=candidate:1 1 UDP 2130706431 192.168.1.1 50000 typ host...",
    "sdpMLineIndex": 0,
    "sdpMid": "audio"
  }
}

8. heartbeat (心跳检测)

{
  "type": "heartbeat",
  "request_id": "req_heartbeat_123",
  "from": "remote_abc123",
  "timestamp": "2023-01-01T12:00:30Z",
  "status": "online"
}

9. mode_switch (模式切换通知)

{
  "type": "mode_switch",
  "request_id": "req_switch_123",
  "from": "signaling_server",
  "to": "remote_abc123",
  "timestamp": "2023-01-01T12:00:10Z",
  "from_mode": "p2p",
  "to_mode": "relay",
  "reason": "P2P connection lost"
}

3. 关键数据结构

3.1 基础数据结构

SessionType（会话类型）

type SessionType uint8
const (
	SessionTypeWebSSHDirect SessionType = 0x01 // WebSSH 直连：浏览器→信令服务器→SSH 服务器
	SessionTypeWebSSHProxy SessionType = 0x02 // WebSSH 代理：浏览器→远程代理→SSH 服务器
	SessionTypeTunnel SessionType = 0x03 // 隧道转发：APP→本地代理→远程代理→目标服务器
)

SessionID（全局唯一会话 ID）

type SessionID struct {
	Type SessionType
	ClientID string
	LocalID uint32
	Timestamp uint32
}

PacketType（数据包类型）

type PacketType uint8
const (
	PacketTypeConnect PacketType = 0x01
	PacketTypeData PacketType = 0x02
	PacketTypeDisconnect PacketType = 0x03
	PacketTypeSSHConfig PacketType = 0x04
	PacketTypeControl PacketType = 0x05
)

Packet（隧道数据包）

type Packet struct {
	Type PacketType
	SessionID SessionID
	Data []byte
}

ProxyRole（代理角色）

type ProxyRole string
const (
	ProxyRoleLocal ProxyRole = "local"
	ProxyRoleRemote ProxyRole = "remote"
	ProxyRoleBrowser ProxyRole = "browser"
)

ProxyStatus（代理状态）

type ProxyStatus string
const (
	ProxyStatusOnline ProxyStatus = "online"
	ProxyStatusOffline ProxyStatus = "offline"
	ProxyStatusConnecting ProxyStatus = "connecting"
)

Capability（代理能力）

type Capability string
const (
	CapabilityTCP Capability = "tcp"
	CapabilityUDP Capability = "udp"
	CapabilityRelay Capability = "relay"
)

SDPInfo（SDP 信息）

type SDPInfo struct {
	Type string `json:"type"`
	SDP string `json:"sdp"`
}

ICECandidate（ICE 候选地址）

type ICECandidate struct {
	Candidate string `json:"candidate"`
	SDPMLineIndex int `json:"sdpMLineIndex"`
	SDPMid string `json:"sdpMid"`
}

STUNServer（STUN 服务器配置）

type STUNServer struct {
	URL string `json:"url"`
}

TURNServer（TURN 服务器配置）

type TURNServer struct {
	URLs []string `json:"urls"`
	Username string `json:"username"`
	Credential string `json:"credential"`
}

3.2 配置数据结构

TunnelConfig（隧道配置）

type TunnelConfig struct {
	LocalPort int `json:"local_port" yaml:"local_port"`
	TargetHost string `json:"target_host" yaml:"target_host"`
	TargetPort int `json:"target_port" yaml:"target_port"`
	Protocol string `json:"protocol" yaml:"protocol"`
}

3.3 信令消息结构

BaseMessage（基础消息结构）

type BaseMessage struct {
	Type MessageType `json:"type"`
	RequestID string `json:"request_id,omitempty"`
	From string `json:"from,omitempty"`
	To string `json:"to,omitempty"`
	Timestamp time.Time `json:"timestamp"`
}

RegisterMessage（注册消息）

type RegisterMessage struct {
	BaseMessage
	ProxyID string `json:"proxy_id"`
	Role ProxyRole `json:"role"`
	Capabilities []Capability `json:"capabilities"`
	Tunnels []TunnelConfig `json:"tunnels"`
	TurnServers []TURNServer `json:"turn_servers,omitempty"`
	Version string `json:"version"`
}

ConnectRequestMessage（连接请求）

type ConnectRequestMessage struct {
	BaseMessage
	TargetProxyID string `json:"target_proxy_id"`
	ModePreference string `json:"mode_preference"`
	ProxyToken string `json:"proxy_token"`
	ConnectionMode string `json:"connection_mode,omitempty"`
	ServiceType string `json:"service_type,omitempty"`
}

ClientInfo（客户端信息）

type ClientInfo struct {
	ClientType string `json:"client_type"`
	SubType string `json:"sub_type,omitempty"`
}

ConnectionParams（连接参数）

type ConnectionParams struct {
	Mode string `json:"mode"`
	Protocol string `json:"protocol"`
	Timeout int `json:"timeout"`
	RetryCount int `json:"retry_count"`
}

SSHParams（SSH 访问参数）

type SSHParams struct {
	Host string `json:"host"`
	Port int `json:"port"`
	Terminal TerminalConfig `json:"terminal"`
	AuthMethod string `json:"auth_method"`
	InitialCommand string `json:"initial_command"`
	KeepaliveInterval int `json:"keepalive_interval"`
}

SFTPParams（SFTP 访问参数）

type SFTPParams struct {
	Host string `json:"host"`
	Port int `json:"port"`
	AuthMethod string `json:"auth_method"`
	DefaultPath string `json:"default_path"`
	MaxFileSize int64 `json:"max_file_size,omitempty"`
	ChunkSize int `json:"chunk_size,omitempty"`
	EnableCompression bool `json:"enable_compression,omitempty"`
}

TerminalConfig（终端配置）

type TerminalConfig struct {
	Width int `json:"width"`
	Height int `json:"height"`
	Type string `json:"type"`
}

ConnectResponseMessage（连接响应）

type ConnectResponseMessage struct {
	BaseMessage
	Code int `json:"code"`
	Message string `json:"message"`
	Success bool `json:"success"`
	P2PInfo *P2PInfo `json:"p2p_info,omitempty"`
	RelayInfo *RelayInfo `json:"relay_info,omitempty"`
}

SSHConfigMessage（SSH 配置消息）

type SSHConfigMessage struct {
	BaseMessage
	TargetProxyID string `json:"target_proxy_id"`
	SSHConfig map[string]interface{} `json:"ssh_config"`
}

SFTPConfigMessage（SFTP 配置消息）

type SFTPConfigMessage struct {
	BaseMessage
	TargetProxyID string `json:"target_proxy_id"`
	SFTPConfig map[string]interface{} `json:"sftp_config"`
}

P2PInfo（P2P 连接信息）

type P2PInfo struct {
	Status string `json:"status"`
	ICEServers []ICEServer `json:"ice_servers"`
}

RelayInfo（中继连接信息）

type RelayInfo struct {
	Status string `json:"status"`
	ICEServers []ICEServer `json:"ice_servers"`
}

ICEServer（ICE 服务器配置）

type ICEServer struct {
	URLs []string `json:"urls"`
	Username string `json:"username,omitempty"`
	Credential string `json:"credential,omitempty"`
}

WebRTCConnection（WebRTC 连接）

type WebRTCConnection struct {
	CallID WebRTCCallID
	PeerConn *webrtc.PeerConnection
	DataChannels map[string]*webrtc.DataChannel
	SignalClient *SignalClient
	Config *ProxyConfig
	SessionManager *SessionManager
	IsConnected bool
	LastActive time.Time
	connectTimeout time.Duration
	connectDone chan bool
	mode ConnectionMode
	modeSwitching bool
	iceServers []ICEServer
	OnPacketReceived func(conn *WebRTCConnection, packet *Packet)
	RemoteProxyID string
	AssociatedSSHConfigs []*SSHSessionMapping
}

WebRTCManager（WebRTC 连接管理器）

type WebRTCManager struct {
	Connections map[WebRTCCallID]*WebRTCConnection
	ClientMappings map[string]*ClientConnectionInfo
	SignalClient *SignalClient
	Config *ProxyConfig
	metrics *WebRTCMetrics
	healthChecker *WebRTCHealthChecker
}

ClientConnectionInfo（客户端连接信息）

type ClientConnectionInfo struct {
	ClientID string
	CallIDs []WebRTCCallID
	ActiveCallID WebRTCCallID
	ConnectedAt time.Time
	LastActivity time.Time
	SSHSessionCount int
}

SSHSessionMapping（SSH 会话映射信息）

type SSHSessionMapping struct {
	SessionID SessionID
	ClientID string
	TargetHost string
	TargetPort int
	Username string
	EstablishedAt time.Time
}

WebRTCCallID（WebRTC 通话 ID）

type WebRTCCallID string

ConnectionMode（连接模式）

type ConnectionMode string
const (
	ConnectionModeP2P ConnectionMode = "p2p"
	ConnectionModeRelay ConnectionMode = "relay"
)

SessionManager（会话管理器）

type SessionManager struct {
	sessions map[SessionID]*Session
	mu sync.RWMutex
}

type Session struct {
	ID SessionID
	ClientID string
	LocalConn net.Conn
	TunnelInfo *TunnelInfo
	CreatedAt time.Time
	LastActive time.Time
}

type TunnelInfo struct {
	TargetHost string
	TargetPort int
	Protocol string
}

SignalClient（信令客户端）

type SignalClient struct {
	conn *websocket.Conn
	proxyID string
	messageHandler func(message []byte)
	reconnectStrategy *ReconnectStrategy
	mu sync.Mutex
}

type ReconnectStrategy struct {
	MaxRetries int
	RetryInterval time.Duration
	BackoffFactor float64
}

ProxyConfig（代理配置）

type ProxyConfig struct {
	ID string
	Host string
	Port int
	STUNServers []ICEServer
	TURNServers []ICEServer
	MaxConnections int
	HeartbeatInterval time.Duration
	LogLevel string
}

WebRTCMetrics（WebRTC 监控指标）

type WebRTCMetrics struct {
	TotalConnections int64 `json:"total_connections"`
	ActiveConnections int64 `json:"active_connections"`
	FailedConnections int64 `json:"failed_connections"`
	ReconnectAttempts int64 `json:"reconnect_attempts"`
	ICEFailures int64 `json:"ice_failures"`
	DataChannelsOpened int64 `json:"data_channels_opened"`
	DataChannelsClosed int64 `json:"data_channels_closed"`
	DataSentBytes int64 `json:"data_sent_bytes"`
	DataReceivedBytes int64 `json:"data_received_bytes"`
	LastActivity int64 `json:"last_activity"`
}

WebRTCHealthChecker（WebRTC 健康检查）

type WebRTCHealthChecker struct {
	interval time.Duration
	checkFunc func() HealthStatus
	status HealthStatus
	lastCheck time.Time
	alertHandler func(status HealthStatus)
}

type HealthStatus string
const (
	HealthStatusHealthy HealthStatus = "healthy"
	HealthStatusDegraded HealthStatus = "degraded"
	HealthStatusUnhealthy HealthStatus = "unhealthy"
)

SDPMessage（SDP 交换消息）

type SDPMessage struct {
	BaseMessage
	CallID string `json:"call_id"`
	SDP SDPInfo `json:"sdp"`
	ProxyToken string `json:"proxy_token"`
	ModePreference string `json:"mode_preference"`
}

ICEMessage（ICE Candidate 消息）

type ICEMessage struct {
	BaseMessage
	CallID string `json:"call_id"`
	Candidate ICECandidate `json:"candidate"`
}

HeartbeatMessage（心跳消息）

type HeartbeatMessage struct {
	BaseMessage
	Status string `json:"status"`
	Timestamp int64 `json:"timestamp"`
	Version string `json:"version"`
}

HeartbeatResponseMessage（心跳响应）

type HeartbeatResponseMessage struct {
	BaseMessage
	Success bool `json:"success"`
	Timestamp int64 `json:"timestamp"`
	ServerTime int64 `json:"server_time"`
}

ModeSwitchMessage（模式切换消息）

type ModeSwitchMessage struct {
	BaseMessage
	CallID string `json:"call_id"`
	FromMode string `json:"from_mode"`
	ToMode string `json:"to_mode"`
	Reason string `json:"reason"`
	Timestamp int64 `json:"timestamp"`
}

4. 关键业务流程

4.0 三阶段业务流程实现

第一阶段：基础业务流程

1. 代理注册流程：基本的代理注册和状态管理
2. P2P 连接建立流程：基本的 WebRTC 连接建立
3. WebSSH 代理流程：基本的 SSH 终端功能
4. WebSFTP 代理流程：基本的文件传输功能
5. 心跳检测流程：基本的心跳机制

第二阶段：增强业务流程

1. 智能连接管理：连接质量监控和自动模式切换
2. 高级会话管理：会话负载均衡和故障转移
3. 增强的错误处理：完善的错误处理和异常恢复
4. 安全认证流程：增强的认证和授权机制
5. 性能优化流程：数据压缩和批量处理

第三阶段：高级业务流程

1. 集群管理流程：信令服务器和远程代理集群管理
2. 监控告警流程：全系统监控和智能告警
3. 多租户管理流程：租户隔离和资源管理
4. API 管理流程：RESTful API 和管理界面
5. 配置中心流程：集中配置管理和动态更新

4.1 代理注册流程

1. 代理客户端启动：
   • 生成唯一代理 ID
   • 加载本地配置文件
2. 远程代理注册流程：
   • 通过 WebSocket 连接到信令服务器
   • 加载本地配置文件中的 TURN 服务器配置（仅在本地使用）
   • 信令服务器不存储 TURN 服务器的完整配置
   • 发送 register 消息，包含代理 ID、角色（remote）、能力和隧道配置
   • 信令服务器验证代理信息并记录代理状态
   • 信令服务器返回 register_response 消息，指示注册是否成功
   • 注册成功后，远程代理进入在线状态并开始发送心跳消息
3. 本地代理注册流程：
   • 通过 WebSocket 连接到信令服务器
   • 发送 register 消息，包含代理 ID、角色（local）、能力和隧道配置
   • 信令服务器验证代理信息并记录代理状态
   • 信令服务器返回 register_response 消息，指示注册是否成功
   • 注册成功后，本地代理进入在线状态并开始发送心跳消息

4.2 P2P 连接建立流程

1. 发起连接请求：
   • 浏览器客户端或本地代理发送 connect_request 消息，指定目标代理 ID 和连接模式偏好
   • 本地代理使用自身配置的 STUN 服务器进行 NAT 穿透准备
2. 信令服务器处理：
   • 检查目标代理是否在线
   • 向目标代理转发连接请求
3. 目标代理响应：
   • 远程代理接受请求，使用自身配置的 STUN 服务器进行 NAT 穿透准备
   • 远程代理动态生成 TURN 服务器的临时凭证
   • 远程代理发送包含临时 TURN 凭证的响应
   • 信令服务器返回 connect_response 消息给发起方，包含远程代理动态生成的 TURN 服务器临时配置
   • 注意：完整的 TURN 服务器配置仅存储在远程代理本地，不通过信令服务器持久化存储
4. WebRTC 连接建立：
   • 发起方使用自身配置的 STUN 服务器和远程代理提供的 TURN 服务器创建 SDP Offer
   • 发起方发送 sdp_offer 消息
   • 信令服务器转发 sdp_offer 到目标代理
   • 目标代理使用自身配置的 STUN 服务器和自身配置的 TURN 服务器创建 SDP Answer
   • 目标代理发送 sdp_answer 消息
   • 信令服务器转发 sdp_answer 到发起方
   • 双方开始交换 ICE Candidate 消息
   • 当 ICE 协商成功后，建立 P2P 连接
5. 连接失败处理：
   • 如果 P2P 连接失败，系统自动尝试切换到中继模式
   • 使用远程代理提供的 TURN 服务器作为中继节点

4.3 中继连接建立流程

直接使用中继模式

1. 发起连接请求：
   • 浏览器客户端或本地代理发送 connect_request 消息，明确指定连接模式为 force-relay
   • 本地代理使用自身配置的 STUN 服务器进行 NAT 穿透准备
2. 信令服务器处理：
   • 检查目标代理是否在线
   • 向目标代理转发连接请求
3. 目标代理响应：
   • 远程代理接受请求，使用自身配置的 STUN 服务器进行 NAT 穿透准备
   • 远程代理动态生成 TURN 服务器的临时凭证
   • 远程代理发送包含临时 TURN 凭证的响应
   • 信令服务器返回 connect_response 消息给发起方，包含远程代理动态生成的 TURN 服务器临时配置
   • 注意：完整的 TURN 服务器配置仅存储在远程代理本地，不通过信令服务器持久化存储
4. 中继连接建立：
   • 发起方使用自身配置的 STUN 服务器和远程代理提供的 TURN 服务器临时配置创建 SDP Offer
   • 发起方发送 sdp_offer 消息
   • 信令服务器转发 sdp_offer 到目标代理
   • 目标代理使用自身配置的 STUN 服务器和自身配置的 TURN 服务器创建 SDP Answer
   • 目标代理发送 sdp_answer 消息
   • 信令服务器转发 sdp_answer 到发起方
   • 双方开始交换 ICE Candidate 消息
   • 当 ICE 协商成功后，建立中继连接
   • coturn 服务器在两个连接之间转发流量

从 P2P 模式切换到中继模式

1. 连接质量检测：
   • 任一方向检测到 P2P 连接质量下降或中断
2. 模式切换触发：
   • 检测方触发模式切换逻辑
   • 信令服务器发送 mode_switch 消息通知双方切换到中继模式
3. 中继连接建立：
   • 双方断开当前 P2P 连接
   • 使用已获取的远程代理提供的 TURN 服务器临时配置重新建立连接
   • 发起方使用自身配置的 STUN 服务器和远程代理提供的 TURN 服务器临时配置创建 SDP Offer
   • 目标代理使用自身配置的 STUN 服务器和自身配置的 TURN 服务器创建 SDP Answer
   • 双方交换 SDP 和 ICE Candidate 消息
   • 建立中继连接，通过 coturn 服务器转发流量

4.4 WebSSH 代理流程

1. 浏览器客户端初始化：
   • 访问 WebSSH 代理页面
   • 页面加载完成后自动与信令服务器建立 WebSocket 连接
2. 用户配置与连接请求：
   • 用户输入目标代理 ID 和 SSH 连接信息（包括主机地址、端口、认证方式等）
   • 浏览器客户端发送 connect_request 消息，包含：
     • 目标代理 ID
     • 连接模式偏好
     • 代理通讯令牌
     • 连接模式（connection_mode: remote_proxy）
     • 服务类型（service_type: webssh）
3. 信令与连接建立：
   • 信令服务器处理连接请求，检查目标代理状态
   • 远程代理接受请求，使用自身配置的 STUN 服务器进行 NAT 穿透准备
   • 远程代理动态生成 TURN 服务器的临时凭证
   • 信令服务器返回 connect_response 消息，包含远程代理动态生成的 TURN 服务器临时配置
   • 浏览器客户端使用自身配置的 STUN 服务器（如果有）和远程代理提供的 TURN 服务器临时配置建立 P2P 或中继连接
   • 注意：完整的 TURN 服务器配置仅存储在远程代理本地，不通过信令服务器持久化存储
4. SSH 配置与会话建立：
   • 连接建立成功后，浏览器客户端发送 ssh_config 消息，包含详细的 SSH 配置信息
   • 远程代理接收 SSH 配置，与目标 SSH 服务器建立连接，执行认证
   • 认证成功后，浏览器客户端可以在 xterm.js 终端中发送 SSH 命令
   • 远程代理执行 SSH 命令并返回结果
   • 结果通过 WebRTC 连接实时返回给浏览器客户端显示
5. 多会话支持：
   • 系统支持通过同一个 WebRTC 通道建立多个 SSH 会话
   • 每个会话使用唯一的标识符进行区分
   • 远程代理维护会话映射，确保数据正确路由到对应的会话
6. 会话结束：
   • 用户关闭浏览器标签或显式断开连接
   • 浏览器客户端发送断开连接请求
   • 双方断开 WebRTC 连接和 WebSocket 连接

4.5 WebSFTP 代理流程

1. 浏览器客户端初始化：
   • 访问 WebSFTP 代理页面
   • 页面加载完成后自动与信令服务器建立 WebSocket 连接
2. 用户配置与连接请求：
   • 用户输入目标代理 ID 和 SFTP 连接信息（包括主机地址、端口、认证方式等）
   • 浏览器客户端发送 connect_request 消息，包含：
     • 目标代理 ID
     • 连接模式偏好
     • 代理通讯令牌
     • 连接模式（connection_mode: remote_proxy）
     • 服务类型（service_type: webfile）
3. 信令与连接建立：
   • 信令服务器处理连接请求，检查目标代理状态
   • 远程代理接受请求，使用自身配置的 STUN 服务器进行 NAT 穿透准备
   • 远程代理动态生成 TURN 服务器的临时凭证
   • 信令服务器返回 connect_response 消息，包含远程代理动态生成的 TURN 服务器临时配置
   • 浏览器客户端使用自身配置的 STUN 服务器（如果有）和远程代理提供的 TURN 服务器临时配置建立 P2P 或中继连接
   • 注意：完整的 TURN 服务器配置仅存储在远程代理本地，不通过信令服务器持久化存储
4. SFTP 配置与会话建立：
   • 连接建立成功后，浏览器客户端发送 sftp_config 消息，包含详细的 SFTP 配置信息
   • 远程代理接收 SFTP 配置，与目标 SFTP 服务器建立连接，执行认证
   • 认证成功后，浏览器客户端可以发送 sftp_command 消息进行文件操作
5. 文件操作：
   • 浏览器客户端可以进行以下文件操作：
     • 列出目录内容（ls 命令）
     • 创建目录（mkdir 命令）
     • 删除文件/目录（rm/rmdir 命令）
     • 重命名文件/目录（rename 命令）
     • 上传文件（put 命令）
     • 下载文件（get 命令）
   • 大文件传输采用分块上传/下载机制，支持断点续传
   • 文件操作命令和结果通过 WebRTC 连接实时传输
6. 文件传输优化：
   • 支持文件压缩传输，减少网络流量
   • 大文件上传/下载时显示进度条
   • 支持同时传输多个文件
   • 实现文件传输队列管理
7. 会话结束：
   • 用户关闭浏览器标签或显式断开连接
   • 浏览器客户端发送断开连接请求
   • 双方断开 WebRTC 连接和 WebSocket 连接
   • 未完成的文件传输自动中断并记录状态

4.6 心跳检测流程

1. 心跳发送机制：
   • 代理客户端默认每 30 秒发送一次 heartbeat 消息
   • 心跳消息包含当前状态、时间戳和版本号
   • 支持动态调整心跳间隔，根据网络状况自适应
2. 心跳接收与处理：
   • 信令服务器收到心跳消息后立即更新代理的最后心跳时间
   • 信令服务器返回 heartbeat_response 消息，包含响应状态和服务器时间
   • 代理客户端根据响应调整自身状态和心跳间隔
3. 容错与网络抖动处理：
   • 允许连续 3 次心跳失败（约 90 秒），仍保持代理为在线状态
   • 超过 3 次连续失败后，将代理标记为 connecting 状态（连接中）
   • 在 connecting 状态下，代理客户端尝试加速重连（每 5 秒一次）
   • 如果 120 秒内未恢复正常心跳，则标记为 offline（离线）
4. 离线恢复机制：
   • 当代理重新上线时，先尝试恢复之前的 WebSocket 连接
   • 如果恢复失败，则重新建立 WebSocket 连接
   • 重新建立连接后，发送 register 消息重新注册
   • 信令服务器恢复代理的在线状态并更新相关连接信息
5. 异常处理：
   • 代理客户端检测到网络异常时，主动减少心跳间隔，加速检测
   • 信令服务器定期清理长时间离线（超过 24 小时）的代理记录
   • 提供心跳统计和监控接口，便于运维人员查看代理状态

4.7 连接模式切换流程

1. 连接质量监测：
   • 双方定期监测 WebRTC 连接的质量指标（延迟、丢包率、带宽等）
   • 当指标超过阈值（如延迟>500ms 或丢包率>5%）时，触发切换检测
   • 支持手动和自动两种切换触发方式
2. 切换决策与准备：
   • 检测方评估当前网络状况，决定是否需要切换模式
   • 如果决定切换，提前获取所需的 TURN 服务器临时配置（如从 P2P 切换到中继）
   • 准备新连接所需的资源和参数
3. 无缝切换实现：
   • 信令服务器发送 mode_switch 消息通知双方准备切换
   • 双方在保持当前连接的同时，并行建立新的连接模式
   • 新连接建立成功后，进行数据传输测试
   • 测试通过后，平滑切换流量到新连接
   • 旧连接在流量完全切换后延迟 10 秒关闭，确保数据完整性
4. 切换类型支持：
   • P2P → 中继：当 P2P 连接质量下降时
   • 中继 → P2P：当网络状况改善，支持 P2P 连接时
   • 手动切换：用户或管理员可通过 API 或界面强制切换
5. 状态管理与通知：
   • 信令服务器实时记录和更新连接模式状态
   • 向双方发送模式切换状态通知
   • 提供连接模式切换历史记录
6. 异常处理：
   • 如果新连接建立失败，保持使用当前连接
   • 重试切换操作，最多尝试 3 次
   • 记录切换失败原因，便于后续分析和优化
7. 性能优化：
   • 预加载 TURN 服务器配置，减少切换延迟
   • 使用快速重传和拥塞控制算法，确保切换过程中数据不丢失
   • 支持连接复用，减少资源消耗

4.8 WebRTC 数据路由流程

4.8.1 数据包结构

WebRTC 数据通道使用自定义的数据包结构进行通信，确保数据的正确路由和处理：

+----------------+----------------+----------------+----------------+----------------+----------------+
| 数据包类型 (1B) | ClientID 长度 (4B)| ClientID(NB) | 会话类型 (4B) | 本地 ID(4B) | 时间戳 (4B) |
+----------------+----------------+----------------+----------------+----------------+----------------+
| 数据内容 (变长) |
+--------------------------------------------------------------------------------------------+

• 数据包类型：标识数据包的类型，如连接请求、数据传输、断开连接等
• ClientID：客户端唯一标识，确保数据包正确路由到对应的客户端
• 会话类型：标识会话的类型，如 WebSSH 直连、WebSSH 代理、隧道转发等
• 本地 ID：本地会话 ID，确保在同一客户端内的会话唯一性
• 时间戳：创建时间戳，用于会话管理和超时检测
• 数据内容：实际的业务数据，如 SSH 命令、终端输出等

4.8.2 路由关系

1. 浏览器 → 远程代理路由：
   • 浏览器通过 WebRTC 数据通道发送数据包
   • 数据包包含 SessionID，用于标识会话
   • 远程代理根据 SessionID 中的 ClientID 和 LocalID 路由数据包到对应的 SSH 会话
2. 远程代理 → 浏览器路由：
   • 远程代理从 SSH 服务器接收数据
   • 包装成数据包，添加对应的 SessionID
   • 通过 WebRTC 数据通道发送回浏览器
3. 本地代理 → 远程代理路由：
   • 本地代理从 APP 接收 TCP/UDP 数据
   • 包装成数据包，添加对应的 SessionID
   • 通过 WebRTC 数据通道发送到远程代理
4. 远程代理 → 本地代理路由：
   • 远程代理从目标服务器接收数据
   • 包装成数据包，添加对应的 SessionID
   • 通过 WebRTC 数据通道发送回本地代理

4.8.3 会话管理

1. 会话创建：
   • 当客户端发起新的连接请求时，创建新的 SessionID
   • 关联 SessionID 与对应的连接信息（如目标主机、端口等）
2. 会话维护：
   • 会话管理器跟踪所有活跃的会话
   • 定期检查会话的活跃状态
   • 清理超时或无效的会话
3. 会话复用：
   • 支持在同一 WebRTC 连接上复用多个 SSH 会话
   • 通过 SessionID 区分不同的会话
   • 减少连接建立的开销，提高系统性能

4.8.4 数据包处理流程

1. 数据接收：
   • WebRTC 连接接收数据通道消息
   • 解码数据包，提取 SessionID 和数据内容
2. 路由决策：
   • 根据 SessionID 中的 ClientID 和 LocalID 确定目标会话
   • 检查会话是否存在，不存在则创建或拒绝
3. 数据处理：
   • 根据数据包类型调用相应的处理函数
   • 处理连接请求、数据传输、断开连接等操作
4. 数据转发：
   • 将处理后的数据转发到目标服务器或客户端
   • 确保数据的完整性和顺序
5. 错误处理：
   • 处理数据包解码错误
   • 处理会话不存在的情况
   • 处理网络错误和超时

4.8.5 性能优化

1. 数据压缩：
   • 对传输的数据进行压缩，减少网络流量
   • 提高传输速度，特别是在低带宽环境下
2. 批量处理：
   • 批量发送小型数据包，减少数据通道的开销
   • 提高传输效率，减少网络拥塞
3. 连接复用：
   • 在同一 WebRTC 连接上复用多个会话
   • 减少连接建立的开销，提高系统性能
4. 负载均衡：
   • 在多个远程代理之间分配会话
   • 提高系统的并发处理能力
5. 故障转移：
   • 当当前连接失败时，自动切换到备用连接
   • 提高系统的可靠性和可用性

4.9 消息处理详细说明

4.9.1 ssh_config 消息

消息结构：

{
  "type": "ssh_config",
  "request_id": "req_ssh_config_123",
  "from": "browser_abc123",
  "to": "remote_abc123",
  "timestamp": "2023-01-01T12:00:00Z",
  "target_proxy_id": "remote_abc123",
  "ssh_config": {
    "host": "192.168.1.100",
    "port": 22,
    "username": "user",
    "password": "password",
    "terminal": {
      "width": 80,
      "height": 24,
      "type": "xterm-256color"
    },
    "auth_method": "password",
    "initial_command": "",
    "keepalive_interval": 60
  }
}

处理逻辑：

1. 接收消息：远程代理接收 ssh_config 消息
2. 验证配置：验证 SSH 配置的有效性，如主机地址、端口等
3. 建立连接：使用配置信息与目标 SSH 服务器建立连接
4. 认证处理：根据配置的认证方式执行认证，如密码认证、公钥认证等
5. 会话映射：创建 SSH 会话与 WebRTC 连接的映射关系
6. 返回响应：向浏览器客户端返回连接结果

4.9.2 sftp_config 消息

消息结构：

{
  "type": "sftp_config",
  "request_id": "req_sftp_config_123",
  "from": "browser_abc123",
  "to": "remote_abc123",
  "timestamp": "2023-01-01T12:00:00Z",
  "target_proxy_id": "remote_abc123",
  "sftp_config": {
    "host": "192.168.1.100",
    "port": 22,
    "username": "user",
    "password": "password",
    "default_path": "/home/user",
    "max_file_size": 104857600,
    "chunk_size": 65536,
    "enable_compression": true
  }
}

处理逻辑：

1. 接收消息：远程代理接收 sftp_config 消息
2. 验证配置：验证 SFTP 配置的有效性
3. 建立连接：使用配置信息与目标 SFTP 服务器建立连接
4. 认证处理：执行 SFTP 认证
5. 会话映射：创建 SFTP 会话与 WebRTC 连接的映射关系
6. 返回响应：向浏览器客户端返回连接结果

4.9.3 sftp_command 消息

消息结构：

{
  "type": "sftp_command",
  "request_id": "req_sftp_command_123",
  "from": "browser_abc123",
  "to": "remote_abc123",
  "timestamp": "2023-01-01T12:00:00Z",
  "target_proxy_id": "remote_abc123",
  "session_id": "0x02:browser_abc123:1:1672531200",
  "command": "ls",
  "params": {
    "path": "/home/user"
  }
}

支持的命令：

• ls：列出目录内容
• mkdir：创建目录
• rm：删除文件
• rmdir：删除目录
• rename：重命名文件或目录
• put：上传文件
• get：下载文件
• stat：获取文件或目录状态

处理逻辑：

1. 接收消息：远程代理接收 sftp_command 消息
2. 验证会话：验证会话 ID 的有效性
3. 执行命令：根据命令类型执行相应的 SFTP 操作
4. 处理结果：处理命令执行结果，如文件列表、操作状态等
5. 返回响应：向浏览器客户端返回命令执行结果

4.10 WebRTC 数据通道消息处理机制

4.10.1 消息结构

WebRTC 数据通道使用二进制消息格式，包含以下字段：

• 消息类型：标识消息的类型，如会话创建、数据传输、会话关闭等
• 会话 ID：唯一标识会话的 ID
• 数据长度：消息数据的长度
• 数据内容：实际的业务数据

4.10.2 处理流程

1. 消息接收：
   • WebRTC 数据通道接收二进制消息
   • 解析消息头，提取消息类型和会话 ID
2. 消息路由：
   • 根据会话 ID 查找对应的会话
   • 将消息路由到对应的处理函数
3. 消息处理：
   • 会话创建消息：建立新的会话连接
   • 数据传输消息：转发数据到目标服务器
   • 会话关闭消息：清理会话资源
4. 错误处理：
   • 处理消息解析错误
   • 处理会话不存在的情况
   • 处理网络错误和超时

4.10.3 会话管理实现

1. 会话创建：
   • 生成唯一的会话 ID
   • 创建会话对象，关联 WebRTC 连接
   • 初始化会话状态
2. 会话维护：
   • 定期更新会话的活动时间
   • 检测会话的健康状态
   • 处理会话的异常情况
3. 会话清理：
   • 清理超时的会话
   • 释放会话占用的资源
   • 通知相关组件会话状态变化

4.11 会话生命周期管理

4.11.1 WebSSH 会话生命周期

1. 会话创建：
   • 浏览器发送 connect_request 消息
   • 建立 WebRTC 连接
   • 浏览器发送 ssh_config 消息
   • 远程代理与 SSH 服务器建立连接
   • 创建会话 ID 和会话映射
2. 会话维护：
   • 浏览器发送 SSH 命令
   • 远程代理执行命令并返回结果
   • 浏览器显示终端输出
   • 定期更新会话活动时间
3. 会话关闭：
   • 浏览器发送断开连接请求
   • 远程代理关闭 SSH 连接
   • 清理会话资源
   • 关闭 WebRTC 数据通道

4.11.2 SFTP 会话生命周期

1. 会话创建：
   • 浏览器发送 connect_request 消息
   • 建立 WebRTC 连接
   • 浏览器发送 sftp_config 消息
   • 远程代理与 SFTP 服务器建立连接
   • 创建会话 ID 和会话映射
2. 会话维护：
   • 浏览器发送 sftp_command 消息
   • 远程代理执行 SFTP 操作
   • 浏览器显示操作结果
   • 定期更新会话活动时间
3. 会话关闭：
   • 浏览器发送断开连接请求
   • 远程代理关闭 SFTP 连接
   • 清理会话资源
   • 关闭 WebRTC 数据通道

4.11.3 隧道转发会话生命周期

1. 会话创建：
   • APP 连接到本地代理
   • 本地代理发送 connect_request 消息
   • 建立 WebRTC 连接
   • 远程代理与目标服务器建立连接
   • 创建会话 ID 和会话映射
2. 会话维护：
   • APP 发送 TCP/UDP 数据
   • 本地代理转发数据到远程代理
   • 远程代理转发数据到目标服务器
   • 目标服务器返回数据
   • 远程代理转发数据到本地代理
   • 本地代理转发数据到 APP
   • 定期更新会话活动时间
3. 会话关闭：
   • APP 关闭连接
   • 本地代理发送断开连接请求
   • 远程代理关闭与目标服务器的连接
   • 清理会话资源

4.12 WebRTC 连接状态管理

4.12.1 连接状态

WebRTC 连接有以下状态：

• disconnected：连接未建立
• connecting：连接正在建立
• connected：连接已建立
• disconnecting：连接正在关闭
• failed：连接失败

4.12.2 状态转换

1. disconnected → connecting：
   • 发起连接请求
   • 开始 ICE 协商
2. connecting → connected：
   • ICE 协商成功
   • 数据通道打开
3. connected → disconnecting：
   • 发起断开连接请求
   • 关闭数据通道
4. disconnecting → disconnected：
   • 关闭对等连接
   • 清理连接资源
5. connecting → failed：
   • ICE 协商失败
   • 连接建立超时
6. connected → failed：
   • 网络连接中断
   • 数据通道错误

4.12.3 状态管理实现

1. 状态追踪：
   • 定期检查 WebRTC 连接状态
   • 记录状态变化历史
   • 通知相关组件状态变化
2. 状态恢复：
   • 当连接失败时尝试重连
   • 根据网络状况调整重连策略
   • 重连成功后恢复会话
3. 状态监控：
   • 监控连接的健康状态
   • 检测连接的质量指标
   • 触发状态切换策略

4.13 错误处理和异常情况

4.13.1 WebRTC 连接失败处理

1. ICE 协商失败：
   • 尝试使用不同的 ICE 服务器
   • 切换到中继连接模式
   • 记录失败原因，便于后续分析
2. 数据通道建立失败：
   • 重试数据通道建立
   • 重新建立 WebRTC 连接
   • 通知应用层连接失败
3. 连接断开：
   • 检测断开原因
   • 尝试自动重连
   • 保持会话状态，重连后恢复

4.13.2 SSH 连接失败处理

1. 认证失败：
   • 通知浏览器认证失败
   • 允许用户重新输入认证信息
   • 记录认证失败次数，防止暴力破解
2. 连接超时：
   • 通知浏览器连接超时
   • 检查网络连接状态
   • 允许用户重新尝试连接
3. 服务器拒绝连接：
   • 通知浏览器连接被拒绝
   • 检查目标服务器状态
   • 记录拒绝原因，便于后续分析

4.13.3 SFTP 连接失败处理

1. 认证失败：
   • 通知浏览器认证失败
   • 允许用户重新输入认证信息
   • 记录认证失败次数，防止暴力破解
2. 文件操作失败：
   • 通知浏览器操作失败
   • 提供详细的错误信息
   • 允许用户重试操作
3. 传输错误：
   • 处理文件传输中断
   • 支持断点续传
   • 记录传输错误，便于后续分析

4.13.4 隧道转发失败处理

1. APP 连接失败：
   • 检查本地代理状态
   • 检查网络连接状态
   • 通知 APP 连接失败
2. 目标服务器连接失败：
   • 检查目标服务器状态
   • 通知本地代理连接失败
   • 尝试自动重连
3. 数据传输错误：
   • 处理传输中断
   • 保证数据完整性
   • 记录传输错误，便于后续分析

4.14 性能优化和可扩展性设计

4.14.1 性能优化策略

1. 数据压缩：
   • 对传输的数据进行压缩，减少网络流量
   • 支持不同的压缩算法，根据网络状况选择合适的算法
   • 对大文件传输特别有效
2. 批量处理：
   • 批量发送小型数据包，减少数据通道的开销
   • 提高传输效率，减少网络拥塞
   • 特别适用于频繁的小数据传输，如 SSH 终端操作
3. 连接复用：
   • 在同一 WebRTC 连接上复用多个会话
   • 减少连接建立的开销，提高系统性能
   • 支持在单个浏览器标签页中打开多个 SSH 会话
4. 负载均衡：
   • 在多个远程代理之间分配会话
   • 基于远程代理的负载情况进行动态分配
   • 提高系统的并发处理能力
5. 缓存机制：
   • 缓存常用的配置信息
   • 缓存文件传输的中间状态
   • 减少重复计算和网络传输

4.14.2 可扩展性设计

1. 模块化架构：
   • 采用模块化设计，便于添加新功能
   • 清晰的组件边界和接口定义
   • 支持插件机制，扩展系统功能
2. 水平扩展：
   • 支持多个信令服务器的集群部署
   • 支持多个远程代理的负载均衡
   • 支持动态添加和移除节点
3. 垂直扩展：
   • 优化单个节点的性能
   • 支持资源的动态分配
   • 支持配置的热更新
4. 服务发现：
   • 自动发现可用的远程代理
   • 基于健康检查的服务发现机制
   • 支持动态调整服务路由

4.15 安全性和认证机制

4.15.1 代理令牌机制

1. 令牌生成：
   • 远程代理生成安全的代理令牌
   • 令牌包含时间戳和签名，防止伪造
   • 支持令牌的有效期设置
2. 令牌验证：
   • 信令服务器验证代理令牌的有效性
   • 远程代理验证代理令牌的有效性
   • 令牌验证失败时拒绝连接请求
3. 令牌管理：
   • 支持令牌的刷新机制
   • 支持令牌的撤销机制
   • 定期轮换令牌，提高安全性

4.15.2 SSH 认证实现

1. 密码认证：
   • 安全传输密码，防止密码泄露
   • 支持密码复杂度检查
   • 支持密码尝试次数限制
2. 公钥认证：
   • 支持 SSH 公钥认证
   • 验证公钥的有效性
   • 支持多种公钥算法
3. 认证日志：
   • 记录认证尝试和结果
   • 检测异常认证行为
   • 提供认证审计功能

4.15.3 SFTP 认证实现

1. 认证机制：
   • 复用 SSH 认证机制，减少重复实现
   • 支持密码和公钥认证
   • 保持与 SSH 认证的一致性
2. 权限控制：
   • 基于 SSH 服务器的权限控制
   • 支持文件操作的权限检查
   • 防止越权访问
3. 数据安全：
   • 加密传输文件数据
   • 验证文件完整性
   • 防止数据泄露

4.15.4 WebSocket 连接认证

1. 连接认证：
   • 验证 WebSocket 连接的来源
   • 支持基于令牌的连接认证
   • 防止未授权的连接
2. 消息认证：
   • 验证消息的完整性和真实性
   • 防止消息篡改
   • 支持消息签名机制
3. 速率限制：
   • 限制 WebSocket 连接的速率
   • 防止 DoS 攻击
   • 保护系统资源

4.16 监控和运维机制

4.16.1 监控指标

1. 系统指标：
   • CPU 使用率
   • 内存使用率
   • 磁盘使用率
   • 网络流量
2. 服务指标：
   • WebSocket 连接数
   • WebRTC 连接数
   • SSH 会话数
   • SFTP 会话数
   • 隧道转发会话数
3. 性能指标：
   • 连接建立时间
   • 数据传输延迟
   • 操作响应时间
   • 错误率
4. 健康检查：
   • 服务可用性
   • 连接状态
   • 资源使用情况
   • 系统负载

4.16.2 运维管理

1. 配置管理：
   • 集中管理配置
   • 支持配置的版本控制
   • 支持配置的热更新
2. 日志管理：
   • 集中管理日志
   • 支持日志的级别控制
   • 支持日志的轮转和归档
   • 提供日志分析工具
3. 告警机制：
   • 基于阈值的告警
   • 多渠道告警通知
   • 告警的分级和聚合
   • 告警的自动处理
4. 部署管理：
   • 支持容器化部署
   • 支持自动化部署
   • 支持滚动更新
   • 支持回滚机制

4.16.3 故障排查

1. 诊断工具：
   • 提供系统诊断工具
   • 支持连接测试
   • 支持性能测试
2. 故障定位：
   • 提供详细的错误信息
   • 支持日志追踪

5. 系统演进策略

5.1 第一阶段到第二阶段的演进

架构演进

1. 信令服务器：
   • 添加连接质量监控模块
   • 实现基本的负载均衡
   • 增强错误处理机制
2. WebRTC 连接管理：
   • 添加连接质量评估算法
   • 实现自动模式切换逻辑
   • 增强重连机制
3. 会话管理：
   • 添加会话负载均衡
   • 实现会话故障转移
   • 增强会话状态管理
4. 安全机制：
   • 实现完整的令牌认证
   • 添加 SSH 主机密钥验证
   • 实现敏感信息加密

技术迁移

1. 代码结构：
   • 保持核心代码结构不变
   • 采用插件式架构添加新功能
   • 确保向后兼容
2. 数据结构：
   • 扩展现有数据结构
   • 添加新的字段和方法
   • 确保数据兼容性
3. API 接口：
   • 保持现有 API 不变
   • 添加新的 API 接口
   • 支持 API 版本控制

关键挑战

1. 性能优化：
   • 实现数据压缩和批量处理
   • 优化网络传输
   • 减少资源消耗
2. 容错机制：
   • 实现完善的错误处理
   • 添加网络异常自动恢复
   • 确保系统稳定性
3. 安全增强：
   • 实现完整的认证和授权
   • 保护敏感信息
   • 防止安全漏洞

5.2 第二阶段到第三阶段的演进

架构演进

1. 信令服务器集群：
   • 实现集群发现和管理
   • 部署多节点信令服务器
   • 实现数据同步和一致性
2. 远程代理集群：
   • 实现代理自动发现和注册
   • 部署多节点远程代理
   • 实现智能负载均衡
3. 监控系统：
   • 部署完整的监控堆栈
   • 实现全系统指标收集
   • 配置智能告警规则
4. 高级特性：
   • 实现多租户支持
   • 开发 RESTful API
   • 构建管理界面

技术迁移

1. 集群管理：
   • 引入集群管理工具（如 etcd）
   • 实现服务发现机制
   • 配置负载均衡器
2. 监控集成：
   • 集成 Prometheus 和 Grafana
   • 实现自定义指标
   • 配置告警渠道
3. API 开发：
   • 实现 RESTful API 框架
   • 开发 API 文档
   • 实现 API 认证和授权
4. 前端开发：
   • 构建管理界面
   • 实现实时监控
   • 支持配置管理

关键挑战

1. 集群一致性：
   • 确保集群数据一致性
   • 处理网络分区
   • 实现节点故障转移
2. 扩展性：
   • 支持水平扩展
   • 处理大规模并发
   • 优化资源使用
3. 可靠性：
   • 实现高可用架构
   • 减少单点故障
   • 提高系统稳定性
4. 可维护性：
   • 实现自动化部署
   • 支持配置管理
   • 提供监控和告警

5.3 演进保障措施

1. 架构设计原则

• 模块化设计：采用模块化架构，便于功能扩展
• 接口标准化：定义标准接口，确保组件兼容性
• 向后兼容：确保新功能不破坏现有功能
• 可测试性：设计可测试的系统，确保质量

2. 技术债务管理

• 代码重构：定期进行代码重构，保持代码质量
• 技术评估：定期评估技术栈，及时更新
• 文档维护：保持文档与代码同步
• 测试覆盖：确保测试覆盖关键功能

3. 部署策略

• 滚动更新：采用滚动更新，减少服务中断
• 蓝绿部署：支持蓝绿部署，确保零 downtime
• 灰度发布：实现灰度发布，降低风险
• 回滚机制：确保能够快速回滚

4. 监控和告警

• 全链路监控：实现端到端监控
• 智能告警：配置智能告警规则
• 故障预测：基于历史数据预测故障
• 性能分析：定期进行性能分析

5.4 演进时间表

5.5 成功指标

第一阶段

• 功能完整性：实现所有基础功能
• 稳定性：系统运行稳定，无严重错误
• 性能：满足基本性能要求
• 安全性：基本的安全机制

第二阶段

• 性能提升：性能指标显著改善
• 可靠性：系统能够自动恢复故障
• 安全性：完善的安全机制
• 可扩展性：支持中等规模部署

第三阶段

• 高可用性：系统可用性>99.9%
• 可扩展性：支持大规模部署
• 可维护性：完善的监控和管理工具
• 业务价值：满足企业级需求

 │ │  
 │ │  
┌─────────┴────────┐ ┌──────────────────┐ │  
│ 目标服务器 │◄───────────────┤ 流量转发 │ │  
│(SSH/SFTP/其他服务)│ │ (本地→远程) │ │  
└──────────────────┘ └──────────────────┘ └───────────────►

架构图说明：

1. 客户端层：
   • APP 客户端：支持自动模式、P2P 模式和中继模式，仅通过本地通信访问本地代理，不直接连接信令服务
   • 浏览器客户端：支持直连模式和代理模式，直接通过 WebSocket 访问信令服务
   • 本地代理：提供 TCP/UDP 隧道中转服务，作为 APP 客户端与信令服务/远程代理之间的唯一桥梁
2. 核心服务层：
   • 信令服务/WEB 服务：统一的 WebSocket 连接入口，负责代理注册、连接建立、信令交换
   • coturn 服务：提供 STUN 服务用于 NAT 穿透，TURN 服务用于 P2P 连接失败时的中继
3. 目标接入层：
   • 远程代理：部署在目标网络，接收来自本地代理或 coturn 的流量并转发到目标服务器
   • 目标服务器：提供最终服务的服务器，如 SSH、SFTP、Web 服务等
4. 通信方式：
   • APP 与本地代理：通过本地通信（如 TCP/UDP）进行数据交换
   • 本地代理/浏览器与信令服务：通过 WebSocket 进行信令交换
   • 本地代理与远程代理：优先使用 WebRTC P2P 数据通道，P2P 失败时使用 WebRTC Relay 数据通道
5. STUN/TURN 服务器使用机制：
   • STUN 服务器：本地代理和远程代理分别使用自己配置文件中的 STUN 服务器
   • TURN 服务器：本地代理和远程代理统一使用远程代理配置文件中的 TURN 服务器
   • TURN 配置获取：本地代理通过信令服务器从远程代理获取 TURN 服务器配置
6. 流量路径：
   • APP 流量：APP 客户端 → 本地代理 → 远程代理 → 目标服务器（P2P 模式，使用各自的 STUN 服务器）
   • APP 流量：APP 客户端 → 本地代理 → coturn 服务 → 远程代理 → 目标服务器（中继模式，统一使用远程代理的 TURN 服务器）
   • 浏览器直连模式：浏览器 → 信令服务 → 目标服务器
   • 浏览器代理模式：浏览器 → 信令服务 → 远程代理 → 目标服务器

6. 技术栈