Files

169 lines
4.7 KiB
Go

// monitor_handler.go Day 40(A-3.13/A-3.14):通道实时监控与日志端点。
// - GET /channels/monitor 快照(HTTP 轮询兜底,与 WS 同源);
// - GET /channels/monitor/ws WebSocket 2s 推送实时曲线(单 Hub 广播,gorilla/websocket);
// - GET /channels/:id/logs 通道日志分页(A-3.14 连接/提交/回执完整记录)。
package v1
import (
"context"
"net/http"
"strconv"
"sync"
"time"
"github.com/gin-gonic/gin"
"github.com/gorilla/websocket"
"go-sms/internal/model/entity"
"go-sms/internal/pkg/response"
"go-sms/internal/service/channel"
)
// wsPushInterval WS 推送周期(验收:每 2s 数据更新)。
const wsPushInterval = 2 * time.Second
// wsUpgrader HTTP→WS 升级器(同源检查放宽:前后端分离端口)。
var wsUpgrader = websocket.Upgrader{
CheckOrigin: func(r *http.Request) bool { return true },
}
// monitorHandler 监控接口。
type monitorHandler struct{ svc *channel.Service }
// registerMonitorRoutes 注册监控路由(登录保护;只读不加权限门,运维大盘全员可见)。
func registerMonitorRoutes(protected *gin.RouterGroup, svc *channel.Service) {
h := &monitorHandler{svc: svc}
protected.GET("/channels/monitor", h.snapshot)
protected.GET("/channels/monitor/ws", h.wsStream)
protected.GET("/channels/:id/logs", h.logs)
}
// snapshot GET /channels/monitor:全通道实时快照(与 WS 帧同构)。
func (h *monitorHandler) snapshot(c *gin.Context) {
snap, err := h.svc.MonitorSnapshot(c.Request.Context())
if err != nil {
bizResp(c, err)
return
}
if snap == nil {
snap = []channel.ChannelSnapshot{}
}
response.Success(c, snap)
}
// wsStream GET /channels/monitor/ws:升级为 WS 并加入广播 Hub(2s 一帧全通道快照)。
func (h *monitorHandler) wsStream(c *gin.Context) {
conn, err := wsUpgrader.Upgrade(c.Writer, c.Request, nil)
if err != nil {
return // Upgrade 已回写 400
}
snapFn := func() any {
snap, err := h.svc.MonitorSnapshot(context.Background())
if err != nil || snap == nil {
return []channel.ChannelSnapshot{}
}
return snap
}
monitorHub.Join(conn, snapFn)
}
// ---- Hub:单实例广播中心(每 wsPushInterval 一帧;连接各自写超时隔离) ----
// wsClient 一个 WS 连接。
type wsClient struct {
conn *websocket.Conn
snap func() any // 快照函数(连接时捕获,数据源同构)
close chan struct{}
}
// monitorHub 全局广播中心(gateway 单实例;多副本时前端按副本负载均衡连接即可)。
var monitorHub = &hub{clients: map[*wsClient]struct{}{}}
type hub struct {
mu sync.Mutex
clients map[*wsClient]struct{}
started bool
}
// Join 接入连接并确保广播循环运行。
func (h *hub) Join(conn *websocket.Conn, snap func() any) {
cl := &wsClient{conn: conn, snap: snap, close: make(chan struct{})}
h.mu.Lock()
h.clients[cl] = struct{}{}
needStart := !h.started
h.started = true
h.mu.Unlock()
if needStart {
go h.loop()
}
go cl.readLoop() // 消费对端帧( pong/close ),检测断开
}
// loop 广播循环:周期向全部连接推送快照;写失败即摘除。
func (h *hub) loop() {
tick := time.NewTicker(wsPushInterval)
defer tick.Stop()
for range tick.C {
h.mu.Lock()
clients := make([]*wsClient, 0, len(h.clients))
for cl := range h.clients {
clients = append(clients, cl)
}
h.mu.Unlock()
if len(clients) == 0 {
continue // 无连接不采数据(快照查询零成本)
}
// 快照一次,广播给全部连接(同帧同值,便于多端对齐)。
snap := clients[0].snap()
for _, cl := range clients {
_ = cl.conn.SetWriteDeadline(time.Now().Add(3 * time.Second))
if err := cl.conn.WriteJSON(snap); err != nil {
h.remove(cl)
continue
}
}
}
}
// remove 摘除连接并关闭。
func (h *hub) remove(cl *wsClient) {
h.mu.Lock()
if _, ok := h.clients[cl]; ok {
delete(h.clients, cl)
close(cl.close)
_ = cl.conn.Close()
}
h.mu.Unlock()
}
// readLoop 消费对端帧直到断开(写超时/网络断由写侧摘除;此处兜底 close)。
func (cl *wsClient) readLoop() {
defer monitorHub.remove(cl)
cl.conn.SetReadLimit(512)
for {
if _, _, err := cl.conn.ReadMessage(); err != nil {
return
}
}
}
// logs GET /channels/:id/logs?kind=&page=&page_size=:通道日志(A-3.14)。
func (h *monitorHandler) logs(c *gin.Context) {
id, _ := strconv.ParseInt(c.Param("id"), 10, 64)
if _, err := h.svc.Get(c.Request.Context(), id); err != nil {
bizResp(c, err)
return
}
page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
pageSize, _ := strconv.Atoi(c.DefaultQuery("page_size", "20"))
list, total, err := h.svc.ListLogs(c.Request.Context(), id, c.Query("kind"), page, pageSize)
if err != nil {
bizResp(c, err)
return
}
if list == nil {
list = []entity.ChannelLog{}
}
response.Success(c, gin.H{"channel_id": id, "total": total, "list": list})
}