rlwj-lab/aiops
0
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(ws): A3 WebSocket 统一连接管理 — 心跳/注册表/监控/优雅关闭

Browse Source 
- 新增 pkg/wshub/manager.go 统一 WebSocket 连接管理器 (WSManager)
- 6 个 WebSocket handler 全部迁移: WebShell/kubectl/PodExec/Audit/Metrics/Pipeline
- 心跳机制: ping(30s) + pong handler + read deadline(60s) 自动检测死连接
- 连接注册表: 元数据(类型/用户/远程地址/连接时间/最后活跃)
- 每用户连接限制 MaxConnsPerUser=15 防资源耗尽
- 监控端点: GET /api/v1/ws/stats + GET /api/v1/ws/connections
- 优雅关闭: CloseAll() 发送 CloseGoingAway 帧并关闭所有连接
- 消除 3 个重复 websocket.Upgrader 变量统一为 WSManager 内部 upgrader
- 6/6 A3 测试通过, 17/17 回归测试通过
This commit is contained in:
attacker committed 2026-06-27 07:20:11 +08:00
1 parent 00a98e210d
commit e4f1018ca1
13 files changed
+508 -58
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

backend/controller/audit_hub.go
+12 -11
View File
@@ -3,23 +3,26 @@ package controller
import (
"log"
"net/http"
"sync"
"ezops/middleware"
"ezops/pkg/wshub"
"github.com/gin-gonic/gin"
"github.com/gorilla/websocket"
)
// AuditHub 终端审计流中心 — 管理所有活跃会话的审计订阅者
type AuditHub struct {
mu sync.RWMutex
watchers map[uint]map[chan []byte]struct{} // sessionID -> set of watcher channels
wsMgr *wshub.WSManager
}
// NewAuditHub 创建审计 Hub
func NewAuditHub() *AuditHub {
func NewAuditHub(wsMgr *wshub.WSManager) *AuditHub {
return &AuditHub{
watchers: make(map[uint]map[chan []byte]struct{}),
wsMgr: wsMgr,
}
}
@@ -76,20 +79,18 @@ func (h *AuditHub) Cleanup(sessionID uint) {
}
}
var auditUpgrader = websocket.Upgrader{
CheckOrigin: func(r *http.Request) bool { return true },
ReadBufferSize: 1024,
WriteBufferSize: 1024,
}
// ServeAuditStream 处理 /ws/audit/:sessionId WebSocket — 实时推送终端输出
func (h *AuditHub) ServeAuditStream(c *gin.Context, sessionID uint, historyData string, sessionInfo map[string]interface{}) {
conn, err := auditUpgrader.Upgrade(c.Writer, c.Request, nil)
userID := middleware.GetUserID(c)
username := middleware.GetUsername(c)
conn, info, err := h.wsMgr.Upgrade(c, wshub.TypeAudit, userID, username)
if err != nil {
log.Printf("[AuditStream] WS 升级失败 session=%d: %v", sessionID, err)
return
}
defer conn.Close()
defer h.wsMgr.Unregister(info)
h.wsMgr.StartHeartbeat(conn, info)
// 发送会话元信息
conn.WriteJSON(map[string]interface{}{
backend/controller/k8s_pod.go
+8 -3
View File
@@ -11,8 +11,10 @@ import (
"strings"
"time"
"ezops/middleware"
"ezops/model"
k8sclient "ezops/pkg/kubernetesclient"
"ezops/pkg/wshub"
"github.com/gin-gonic/gin"
"github.com/gorilla/websocket"
@@ -212,12 +214,15 @@ func (h *KubernetesHandler) ExecTerminal(c *gin.Context) {
}
defer k8sConn.Close()
// Upgrade frontend connection to WebSocket
frontendConn, err := upgrader.Upgrade(c.Writer, c.Request, nil)
// Upgrade frontend connection to WebSocket (tracked by WSManager)
userID := middleware.GetUserID(c)
username := middleware.GetUsername(c)
frontendConn, info, err := h.wsMgr.Upgrade(c, wshub.TypePodExec, userID, username)
if err != nil {
return
}
defer frontendConn.Close()
defer h.wsMgr.Unregister(info)
h.wsMgr.StartHeartbeat(frontendConn, info)
done := make(chan struct{}, 2)
backend/controller/kubectl_shell.go
+13 -6
View File
@@ -12,8 +12,10 @@ import (
"strconv"
"syscall"
"ezops/middleware"
"ezops/model"
"ezops/pkg/toolinstaller"
"ezops/pkg/wshub"
"github.com/creack/pty"
"github.com/gin-gonic/gin"
@@ -23,13 +25,14 @@ import (
// KubectlShellHandler kubectl WebSocket 终端处理（PTY 模式）
type KubectlShellHandler struct {
db *gorm.DB
toolInstaller *toolinstaller.ToolInstaller
db *gorm.DB
toolInstaller *toolinstaller.ToolInstaller
wsMgr *wshub.WSManager
}
// NewKubectlShellHandler creates handler
func NewKubectlShellHandler(db *gorm.DB, ti *toolinstaller.ToolInstaller) *KubectlShellHandler {
return &KubectlShellHandler{db: db, toolInstaller: ti}
func NewKubectlShellHandler(db *gorm.DB, ti *toolinstaller.ToolInstaller, wsMgr *wshub.WSManager) *KubectlShellHandler {
return &KubectlShellHandler{db: db, toolInstaller: ti, wsMgr: wsMgr}
}
// wsWriter wraps a websocket.Conn as an io.Writer (each write = one WSMessage)
@@ -68,12 +71,16 @@ func (h *KubectlShellHandler) Terminal(c *gin.Context) {
return
}
conn, err := upgrader.Upgrade(c.Writer, c.Request, nil)
userID := middleware.GetUserID(c)
username := middleware.GetUsername(c)
conn, info, err := h.wsMgr.Upgrade(c, wshub.TypeKubectl, userID, username)
if err != nil {
log.Printf("[KubectlShell] WebSocket upgrade failed: %v", err)
return
}
defer conn.Close()
defer h.wsMgr.Unregister(info)
h.wsMgr.StartHeartbeat(conn, info)
// Write kubeconfig to a temp file (isolated per session)
tmpFile, err := os.CreateTemp("", "kubeconfig-*.yaml")
backend/controller/kubernetes.go
+5 -3
View File
@@ -8,18 +8,20 @@ import (
"ezops/model"
k8sclient "ezops/pkg/kubernetesclient"
"ezops/pkg/wshub"
"github.com/gin-gonic/gin"
)
// KubernetesHandler K8s处理器
type KubernetesHandler struct {
db *gorm.DB
db *gorm.DB
wsMgr *wshub.WSManager
}
// NewKubernetesHandler 创建K8s处理器
func NewKubernetesHandler(db *gorm.DB) *KubernetesHandler {
return &KubernetesHandler{db: db}
func NewKubernetesHandler(db *gorm.DB, wsMgr *wshub.WSManager) *KubernetesHandler {
return &KubernetesHandler{db: db, wsMgr: wsMgr}
}
// ============================================================================
backend/controller/metrics_ws.go
+13 -5
View File
@@ -5,6 +5,9 @@ import (
"log"
"sync"
"ezops/middleware"
"ezops/pkg/wshub"
"github.com/gin-gonic/gin"
"github.com/gorilla/websocket"
)
@@ -85,17 +88,21 @@ func (h *MetricsHub) Broadcast(update MetricsUpdate) {
// MetricsWSHandler 处理 /ws/metrics 的 WebSocket 连接 // Logan.Li
type MetricsWSHandler struct {
hub *MetricsHub
hub *MetricsHub
wsMgr *wshub.WSManager
}
// NewMetricsWSHandler 创建 WebSocket metrics 处理器
func NewMetricsWSHandler(hub *MetricsHub) *MetricsWSHandler {
return &MetricsWSHandler{hub: hub}
func NewMetricsWSHandler(hub *MetricsHub, wsMgr *wshub.WSManager) *MetricsWSHandler {
return &MetricsWSHandler{hub: hub, wsMgr: wsMgr}
}
// ServeWS 升级 HTTP → WebSocket，注册到 Hub，保持连接
func (h *MetricsWSHandler) ServeWS(c *gin.Context) {
conn, err := upgrader.Upgrade(c.Writer, c.Request, nil)
userID := middleware.GetUserID(c)
username := middleware.GetUsername(c)
conn, info, err := h.wsMgr.Upgrade(c, wshub.TypeMetrics, userID, username)
if err != nil {
log.Printf("[MetricsWS] WebSocket 升级失败: %v", err)
return
@@ -104,8 +111,9 @@ func (h *MetricsWSHandler) ServeWS(c *gin.Context) {
h.hub.Register(conn)
defer func() {
h.hub.Unregister(conn)
conn.Close()
h.wsMgr.Unregister(info)
}()
h.wsMgr.StartHeartbeat(conn, info)
// 保持连接，读取消息（客户端可能发 ping）
for {
backend/controller/webshell.go
+18 -10
View File
@@ -15,9 +15,14 @@ import (
"golang.org/x/crypto/ssh"
"gorm.io/gorm"
"ezops/middleware"
"ezops/model"
"ezops/pkg/wshub"
)
// upgrader is kept for backward compatibility (k8s_pod.go/kubectl_shell.go reference it).
// The WSManager has its own internal upgrader; this global is aliased for handlers
// that haven't been migrated yet or need low-level access.
var upgrader = websocket.Upgrader{
CheckOrigin: func(r *http.Request) bool {
return true
@@ -87,11 +92,12 @@ func (r *asciicastRecorder) Len() int { return r.buf.Len() }
type WebShellHandler struct {
db *gorm.DB
auditHub *AuditHub
wsMgr *wshub.WSManager
clients sync.Map // sessionID → *SessionContext
}
func NewWebShellHandler(db *gorm.DB, auditHub *AuditHub) *WebShellHandler {
return &WebShellHandler{db: db, auditHub: auditHub}
func NewWebShellHandler(db *gorm.DB, auditHub *AuditHub, wsMgr *wshub.WSManager) *WebShellHandler {
return &WebShellHandler{db: db, auditHub: auditHub, wsMgr: wsMgr}
}
// KillSession 强制终止指定终端会话
@@ -148,21 +154,23 @@ func (h *WebShellHandler) Terminal(c *gin.Context) {
return
}
conn, err := upgrader.Upgrade(c.Writer, c.Request, nil)
// Extract user identity BEFORE upgrade (needed for WSManager registration).
userID := middleware.GetUserID(c)
username := middleware.GetUsername(c)
conn, info, err := h.wsMgr.Upgrade(c, wshub.TypeTerminal, userID, username)
if err != nil {
log.Printf("[WebShell] WS upgrade failed: %v", err)
return
}
defer conn.Close()
defer h.wsMgr.Unregister(info)
h.wsMgr.StartHeartbeat(conn, info)
var userIDPtr *uint
if uid, exists := c.Get("userID"); exists {
if uidVal, ok := uid.(uint); ok {
userIDPtr = &uidVal
}
if userID > 0 {
userIDPtr = &userID
}
username, _ := c.Get("username")
usernameStr, _ := username.(string)
usernameStr := username
termSession := model.TerminalSession{
UserID: userIDPtr,
backend/controller/ws_pipeline_log.go
+11 -8
View File
@@ -8,6 +8,8 @@ import (
"strings"
"time"
"ezops/middleware"
"ezops/pkg/wshub"
ezredis "ezops/pkg/redis"
"github.com/gin-gonic/gin"
@@ -15,19 +17,16 @@ import (
"gorm.io/gorm"
)
var wsUpgrader = websocket.Upgrader{
CheckOrigin: func(r *http.Request) bool { return true },
}
// WSPipelineLogHandler WebSocket 流水线日志推流
type WSPipelineLogHandler struct {
db *gorm.DB
cache ezredis.Cache
wsMgr *wshub.WSManager
}
// NewWSPipelineLogHandler 创建 WebSocket 日志处理器
func NewWSPipelineLogHandler(db *gorm.DB, cache ezredis.Cache) *WSPipelineLogHandler {
return &WSPipelineLogHandler{db: db, cache: cache}
func NewWSPipelineLogHandler(db *gorm.DB, cache ezredis.Cache, wsMgr *wshub.WSManager) *WSPipelineLogHandler {
return &WSPipelineLogHandler{db: db, cache: cache, wsMgr: wsMgr}
}
// StreamLog WebSocket 端点：/ws/pipeline/:runId/log
@@ -39,11 +38,15 @@ func (h *WSPipelineLogHandler) StreamLog(c *gin.Context) {
return
}
ws, err := wsUpgrader.Upgrade(c.Writer, c.Request, nil)
userID := middleware.GetUserID(c)
username := middleware.GetUsername(c)
ws, info, err := h.wsMgr.Upgrade(c, wshub.TypePipeline, userID, username)
if err != nil {
return
}
defer ws.Close()
defer h.wsMgr.Unregister(info)
h.wsMgr.StartHeartbeat(ws, info)
logKey := fmt.Sprintf("pipeline:run:%d:logs", uint(runID))
ctx := c.Request.Context()
backend/pkg/wshub/errors.go
+6
View File
@@ -0,0 +1,6 @@
package wshub
import "errors"
// ErrTooManyConnections is returned when a user exceeds MaxConnsPerUser.
var ErrTooManyConnections = errors.New("too many websocket connections for user")
backend/pkg/wshub/manager.go
+299
View File
@@ -0,0 +1,299 @@
// Package wshub provides a unified WebSocket connection manager for the AIOps platform.
// It centralizes connection lifecycle management: registration, heartbeat (ping/pong),
// read/write deadlines, metrics, and graceful shutdown.
//
// All WebSocket handlers (WebShell, kubectl, Pod exec, audit stream, metrics push,
// pipeline log stream) share a single WSManager instance, enabling:
// - Dead-client detection via ping/pong + read deadlines
// - Central connection registry with metadata (type, user, remote addr, uptime)
// - Real-time monitoring via /api/v1/ws/connections and /api/v1/ws/stats
// - Graceful shutdown (CloseAll closes every tracked connection)
// - Per-user connection limits (resource exhaustion protection)
package wshub
import (
"net/http"
"sync"
"sync/atomic"
"time"
"github.com/gin-gonic/gin"
"github.com/gorilla/websocket"
)
// Connection types — identifies which feature a WebSocket serves.
const (
TypeTerminal = "terminal" // WebShell SSH terminal
TypeKubectl = "kubectl" // kubectl command terminal
TypePodExec = "pod_exec" // K8s pod exec terminal
TypeAudit = "audit" // Audit real-time stream (live monitor)
TypeMetrics = "metrics" // Dashboard metrics push
TypePipeline = "pipeline" // Pipeline run log stream
)
// Config tunes the manager behavior.
type Config struct {
// PingInterval how often to send ping frames to clients.
PingInterval time.Duration
// PongTimeout is the max wait for a pong before treating the connection as dead.
PongTimeout time.Duration
// WriteTimeout is the max time for a single write operation.
WriteTimeout time.Duration
// MaxConnsPerUser limits how many concurrent WS connections a single user can hold.
// 0 = unlimited.
MaxConnsPerUser int
// ReadBufferSize / WriteBufferSize for the internal upgrader.
ReadBufferSize int
WriteBufferSize int
}
// DefaultConfig returns production-safe defaults.
func DefaultConfig() Config {
return Config{
PingInterval: 30 * time.Second,
PongTimeout: 60 * time.Second,
WriteTimeout: 10 * time.Second,
MaxConnsPerUser: 15,
ReadBufferSize: 1024,
WriteBufferSize: 1024,
}
}
// ConnInfo holds metadata for a tracked WebSocket connection.
type ConnInfo struct {
ID uint64
Type string
UserID uint
Username string
RemoteAddr string
UserAgent string
ConnectTime time.Time
LastActivity time.Time
conn *websocket.Conn
mgr *WSManager
}
// Uptime returns how long the connection has been open.
func (ci *ConnInfo) Uptime() time.Duration {
return time.Since(ci.ConnectTime)
}
// WSManager is the central WebSocket connection manager.
// Create one per application (typically in router/routes.go) and inject it into
// every WebSocket handler.
type WSManager struct {
cfg Config
upgrader websocket.Upgrader
conns sync.Map // id → *ConnInfo
next uint64 // atomic counter for connection IDs
mu sync.Mutex
closed bool
}
// New creates a WSManager with the given config.
func New(cfg Config) *WSManager {
if cfg.PingInterval <= 0 {
cfg = DefaultConfig()
}
return &WSManager{
cfg: cfg,
upgrader: websocket.Upgrader{
CheckOrigin: func(r *http.Request) bool {
return true // JWT auth is enforced by middleware before upgrade
},
ReadBufferSize: cfg.ReadBufferSize,
WriteBufferSize: cfg.WriteBufferSize,
},
}
}
// Upgrader returns the underlying gorilla upgrader for handlers that need
// low-level access (e.g. custom subprotocols). Most handlers should use Upgrade() instead.
func (m *WSManager) Upgrader() *websocket.Upgrader {
return &m.upgrader
}
// Upgrade performs the HTTP→WebSocket upgrade, registers the connection,
// and returns the raw conn + ConnInfo. The caller MUST defer Unregister(info).
//
// connType must be one of the Type* constants. userID/username come from JWT context.
func (m *WSManager) Upgrade(c *gin.Context, connType string, userID uint, username string) (*websocket.Conn, *ConnInfo, error) {
// Enforce per-user connection limit (resource exhaustion protection).
if m.cfg.MaxConnsPerUser > 0 && userID > 0 {
if m.countByUser(userID) >= m.cfg.MaxConnsPerUser {
c.JSON(http.StatusTooManyRequests, gin.H{
"code": 429,
"message": "WebSocket 连接数超出限制，请关闭其他终端后重试",
})
return nil, nil, ErrTooManyConnections
}
}
conn, err := m.upgrader.Upgrade(c.Writer, c.Request, nil)
if err != nil {
return nil, nil, err
}
id := atomic.AddUint64(&m.next, 1)
info := &ConnInfo{
ID: id,
Type: connType,
UserID: userID,
Username: username,
RemoteAddr: c.ClientIP(),
UserAgent: c.GetHeader("User-Agent"),
ConnectTime: time.Now(),
LastActivity: time.Now(),
conn: conn,
mgr: m,
}
m.conns.Store(id, info)
return conn, info, nil
}
// StartHeartbeat sets up ping/pong + read deadline for a connection.
// It launches a goroutine that sends pings at PingInterval and resets the read
// deadline when a pong is received. If no pong arrives within PongTimeout, the
// connection is forcibly closed (the handler's ReadMessage will return an error,
// unblocking its read loop).
//
// MUST be called before the handler enters its read loop.
func (m *WSManager) StartHeartbeat(conn *websocket.Conn, info *ConnInfo) {
// Pong handler — resets the read deadline + updates lastActivity.
conn.SetPongHandler(func(string) error {
info.LastActivity = time.Now()
_ = conn.SetReadDeadline(time.Now().Add(m.cfg.PongTimeout))
return nil
})
// Initial read deadline.
_ = conn.SetReadDeadline(time.Now().Add(m.cfg.PongTimeout))
go func() {
ticker := time.NewTicker(m.cfg.PingInterval)
defer ticker.Stop()
for range ticker.C {
// Check if connection is still registered (not unregistered by handler).
if _, ok := m.conns.Load(info.ID); !ok {
return
}
_ = conn.SetWriteDeadline(time.Now().Add(m.cfg.WriteTimeout))
if err := conn.WriteMessage(websocket.PingMessage, nil); err != nil {
return // write failed → connection is dead, stop pinging
}
}
}()
}
// SetWriteDeadline helper — sets a write deadline on the connection for a single write.
func (m *WSManager) SetWriteDeadline(conn *websocket.Conn) {
_ = conn.SetWriteDeadline(time.Now().Add(m.cfg.WriteTimeout))
}
// Unregister removes a connection from the registry and closes the underlying socket.
// Safe to call multiple times (idempotent).
func (m *WSManager) Unregister(info *ConnInfo) {
if info == nil {
return
}
if _, loaded := m.conns.LoadAndDelete(info.ID); loaded {
_ = info.conn.Close()
}
}
// CloseAll closes every tracked connection. Called during graceful shutdown.
func (m *WSManager) CloseAll() {
m.mu.Lock()
defer m.mu.Unlock()
if m.closed {
return
}
m.closed = true
m.conns.Range(func(key, val any) bool {
m.conns.Delete(key)
if info, ok := val.(*ConnInfo); ok && info != nil {
// Send a close frame so clients disconnect cleanly.
_ = info.conn.WriteMessage(
websocket.CloseMessage,
websocket.FormatCloseMessage(websocket.CloseGoingAway, "server shutdown"),
)
_ = info.conn.Close()
}
return true
})
}
// Stats returns aggregated connection statistics.
type Stats struct {
Total int `json:"total"`
ByType map[string]int `json:"by_type"`
ByUser map[string]int `json:"by_user"`
ByTypeUser map[string]int `json:"by_type_user"` // "type:user" → count
}
// GetStats returns current aggregate statistics.
func (m *WSManager) GetStats() Stats {
s := Stats{ByType: make(map[string]int), ByUser: make(map[string]int), ByTypeUser: make(map[string]int)}
m.conns.Range(func(_, val any) bool {
if info, ok := val.(*ConnInfo); ok {
s.Total++
s.ByType[info.Type]++
key := info.Username
if key == "" {
key = "anonymous"
}
s.ByUser[key]++
s.ByTypeUser[info.Type+":"+key]++
}
return true
})
return s
}
// ConnectionDetail is the JSON representation of a tracked connection (for monitoring).
type ConnectionDetail struct {
ID uint64 `json:"id"`
Type string `json:"type"`
UserID uint `json:"user_id"`
Username string `json:"username"`
RemoteAddr string `json:"remote_addr"`
ConnectTime time.Time `json:"connect_time"`
LastActivity time.Time `json:"last_activity"`
UptimeSec int64 `json:"uptime_sec"`
}
// ListConnections returns all active connections sorted by connect time (newest first).
func (m *WSManager) ListConnections() []ConnectionDetail {
list := []ConnectionDetail{} // initialized to avoid JSON null
m.conns.Range(func(_, val any) bool {
if info, ok := val.(*ConnInfo); ok {
list = append(list, ConnectionDetail{
ID: info.ID,
Type: info.Type,
UserID: info.UserID,
Username: info.Username,
RemoteAddr: info.RemoteAddr,
ConnectTime: info.ConnectTime,
LastActivity: info.LastActivity,
UptimeSec: int64(info.Uptime().Seconds()),
})
}
return true
})
return list
}
// countByUser returns the number of active connections for a given user.
func (m *WSManager) countByUser(userID uint) int {
count := 0
m.conns.Range(func(_, val any) bool {
if info, ok := val.(*ConnInfo); ok && info.UserID == userID {
count++
}
return true
})
return count
}
backend/router/routes.go
+31 -6
View File
@@ -8,6 +8,7 @@ import (
"ezops/service"
ezredis "ezops/pkg/redis"
"ezops/pkg/toolinstaller"
"ezops/pkg/wshub"
"fmt"
"strconv"
@@ -62,9 +63,13 @@ func Register(r *gin.Engine, db *gorm.DB, log *zap.Logger, cfg *config.Config, c
})
})
// === A3: 统一 WebSocket 连接管理器 === // Logan.Li
// 所有 WebSocket handler 共享同一个 WSManager（心跳、连接注册、监控、优雅关闭）
wsMgr := wshub.New(wshub.DefaultConfig())
// WebSocket终端 (JWT 鉴权，支持 ?token= 查询参数；终端会话录制) // Logan.Li
auditHub := controller.NewAuditHub()
webShellHandler := controller.NewWebShellHandler(db, auditHub)
auditHub := controller.NewAuditHub(wsMgr)
webShellHandler := controller.NewWebShellHandler(db, auditHub, wsMgr)
r.GET("/ws/terminal", middleware.JWTAuth(&cfg.JWT, db), webShellHandler.Terminal)
// WebSocket 审计实时流 — 在线会话实时查看 // Logan.Li
@@ -92,11 +97,11 @@ func Register(r *gin.Engine, db *gorm.DB, log *zap.Logger, cfg *config.Config, c
// WebSocket 实时指标推送（JWT 鉴权） // Logan.Li
metricsHub := controller.NewMetricsHub()
metricsWSHandler := controller.NewMetricsWSHandler(metricsHub)
metricsWSHandler := controller.NewMetricsWSHandler(metricsHub, wsMgr)
r.GET("/ws/metrics", middleware.JWTAuth(&cfg.JWT, db), metricsWSHandler.ServeWS)
// WebSocket 流水线日志推流
wsLogHandler := controller.NewWSPipelineLogHandler(db, redisCache)
wsLogHandler := controller.NewWSPipelineLogHandler(db, redisCache, wsMgr)
r.GET("/ws/pipeline/:runId/log", wsLogHandler.StreamLog)
r.GET("/api/v1/pipelines/runs/:runId/log-stream", wsLogHandler.GetLogHistory)
@@ -106,7 +111,7 @@ func Register(r *gin.Engine, db *gorm.DB, log *zap.Logger, cfg *config.Config, c
r.GET("/api/v1/pipelines/runs/:runId/files/download", workspaceFilesHandler.DownloadFile)
// WebSocket K8s exec 交互终端 // Logan.Li
k8sHandler := controller.NewKubernetesHandler(db)
k8sHandler := controller.NewKubernetesHandler(db, wsMgr)
r.GET("/ws/kubernetes-exec/:id/namespaces/:namespace/pods/:podName", middleware.JWTAuth(&cfg.JWT, db), k8sHandler.ExecTerminal)
// ToolInstaller（工具懒加载服务 — kubectl/maven/node/helm）// Logan.Li
@@ -116,9 +121,29 @@ func Register(r *gin.Engine, db *gorm.DB, log *zap.Logger, cfg *config.Config, c
svcs := service.NewServices(db, redisCache, cfg.JWT.Secret)
// WebSocket kubectl 命令行终端 // Logan.Li
kubectlShellHandler := controller.NewKubectlShellHandler(db, ti)
kubectlShellHandler := controller.NewKubectlShellHandler(db, ti, wsMgr)
r.GET("/ws/kubectl", middleware.JWTAuth(&cfg.JWT, db), kubectlShellHandler.Terminal)
// === A3: WebSocket 连接监控端点 === // Logan.Li
wsAPI := api.Group("/ws", middleware.JWTAuth(&cfg.JWT, db))
{
// GET /api/v1/ws/connections — 列出所有活跃 WS 连接
wsAPI.GET("/connections", func(c *gin.Context) {
connections := wsMgr.ListConnections()
c.JSON(200, gin.H{
"code": 200,
"data": connections,
})
})
// GET /api/v1/ws/stats — 聚合统计（总数 + 按类型/用户分布）
wsAPI.GET("/stats", func(c *gin.Context) {
c.JSON(200, gin.H{
"code": 200,
"data": wsMgr.GetStats(),
})
})
}
// 公开路由
authHandler := controller.NewUserHandler(db, cfg)
api.POST("/auth/login", authHandler.Login)