feat: SignalServer bug

Author: barry-ran

SignalingServer/cmd/signaling/main.go

@@ -83,16 +83,17 @@ func main() {
 	}
 
 	// Initialize handlers
-	apiHandler := handler.NewAPIHandler(deviceService, authService, presetService, settingsService, cfg)
+	apiHandler := handler.NewAPIHandler(deviceService, authService, presetService, settingsService, cfg, db)
 	wsHandler := handler.NewWSHandler(deviceService, authService, db, redisClient)
-	
+
 	apiHandler.SetWSHandler(wsHandler)
 
 	gin.SetMode(gin.ReleaseMode)
 	router := gin.New()
 	router.Use(gin.Recovery())
 	router.Use(middleware.LoggerMiddleware())
 	router.Use(middleware.CORSMiddleware(settingsService))
+	router.Use(apiHandler.APIRequestCounterMiddleware())
 
 	apiKeyAuth := middleware.NewAPIKeyAuth(settingsService)
 

SignalingServer/internal/handler/api_handler.go

@@ -12,6 +12,7 @@ import (
 	"quickdesk/signaling/internal/models"
 	"quickdesk/signaling/internal/service"
 	"runtime"
+	"sync/atomic"
 	"time"
 
 	"github.com/gin-gonic/gin"
@@ -20,6 +21,7 @@ import (
 	"github.com/shirou/gopsutil/v3/host"
 	"github.com/shirou/gopsutil/v3/mem"
 	psnet "github.com/shirou/gopsutil/v3/net"
+	"gorm.io/gorm"
 )
 
 type APIHandler struct {
@@ -29,23 +31,34 @@ type APIHandler struct {
 	settingsService *service.SettingsService
 	config          *config.Config
 	wsHandler       *WSHandler
+	db              *gorm.DB
+	apiRequestCount int64
 	lastNetIO       psnet.IOCountersStat
 	lastNetIOTime   time.Time
 	uploadSpeed     float64
 	downloadSpeed   float64
 }
 
-func NewAPIHandler(deviceService *service.DeviceService, authService *service.AuthService, presetService *service.PresetService, settingsService *service.SettingsService, cfg *config.Config) *APIHandler {
+func NewAPIHandler(deviceService *service.DeviceService, authService *service.AuthService, presetService *service.PresetService, settingsService *service.SettingsService, cfg *config.Config, db *gorm.DB) *APIHandler {
 	return &APIHandler{
 		deviceService:   deviceService,
 		authService:     authService,
 		presetService:   presetService,
 		settingsService: settingsService,
 		config:          cfg,
+		db:              db,
 		lastNetIOTime:   time.Now(),
 	}
 }
 
+// APIRequestCounterMiddleware increments the API request counter for each request
+func (h *APIHandler) APIRequestCounterMiddleware() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		atomic.AddInt64(&h.apiRequestCount, 1)
+		c.Next()
+	}
+}
+
 // SetWSHandler sets the WebSocket handler reference (called after WSHandler is created)
 func (h *APIHandler) SetWSHandler(ws *WSHandler) {
 	h.wsHandler = ws
@@ -438,11 +451,39 @@ func (h *APIHandler) GetConnectionStatus(c *gin.Context) {
 		"currentConnections":   wsConnections,
 		"todayConnections":     wsConnections,
 		"webSocketConnections": wsConnections,
-		"apiRequests":          0,
+		"apiRequests":          atomic.LoadInt64(&h.apiRequestCount),
 	})
 }
 
 // GetActivity handles GET /admin/activity
 func (h *APIHandler) GetActivity(c *gin.Context) {
-	c.JSON(http.StatusOK, []gin.H{})
+	var histories []models.ConnectionHistory
+	h.db.Order("created_at DESC").Limit(50).Find(&histories)
+
+	activity := make([]gin.H, 0, len(histories))
+	for _, hist := range histories {
+		action := "远程连接"
+		details := fmt.Sprintf("用户 %d 连接设备 %s", hist.UserID, hist.DeviceID)
+		if hist.DeviceName != "" {
+			details = fmt.Sprintf("用户 %d 连接设备 %s (%s)", hist.UserID, hist.DeviceID, hist.DeviceName)
+		}
+		if hist.ErrorMsg != "" {
+			details += " - " + hist.ErrorMsg
+		}
+
+		status := hist.Status
+		if status == "" {
+			status = "success"
+		}
+
+		activity = append(activity, gin.H{
+			"time":     hist.CreatedAt.Format("2006-01-02 15:04:05"),
+			"deviceId": hist.DeviceID,
+			"action":   action,
+			"details":  details,
+			"status":   status,
+		})
+	}
+
+	c.JSON(http.StatusOK, gin.H{"activity": activity})
 }

SignalingServer/internal/handler/ws_handler.go

@@ -29,8 +29,11 @@ const (
 
 // WebSocket message types
 type WSMessage struct {
-	Type     string `json:"type"`
-	Password string `json:"password,omitempty"`
+	Type       string `json:"type"`
+	Password   string `json:"password,omitempty"`
+	OS         string `json:"os,omitempty"`
+	OSVersion  string `json:"os_version,omitempty"`
+	AppVersion string `json:"app_version,omitempty"`
 }
 
 var upgrader = websocket.Upgrader{
@@ -130,25 +133,30 @@ func (h *WSHandler) HandleWebSocket(c *gin.Context) {
 
 	// Host connection: Auto-register if not exists, create temp password
 	if !isClient {
+		// Read device info from query params
+		osInfo := c.DefaultQuery("os", "Unknown")
+		osVersion := c.DefaultQuery("os_version", "Unknown")
+		appVersion := c.DefaultQuery("app_version", "Unknown")
+
 		// Check if device exists
 		_, err := h.deviceService.GetByDeviceID(c.Request.Context(), deviceID)
 		if err != nil {
 			// Device doesn't exist, register it
 			log.Printf("Device %s not registered, auto-registering...", deviceID)
 			req := &service.RegisterDeviceRequest{
-				OS:         "Unknown",
-				OSVersion:  "Unknown",
-				AppVersion: "1.0.0",
+				OS:         osInfo,
+				OSVersion:  osVersion,
+				AppVersion: appVersion,
 			}
-			
+
 			// Use provided device_id
 			device, err := h.deviceService.RegisterDeviceWithID(c.Request.Context(), deviceID, req)
 			if err != nil {
 				log.Printf("Failed to register device: %v", err)
 				c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to register device"})
 				return
 			}
-			
+
 			// Generate and set temporary password
 			tempPassword := h.authService.GenerateTemporaryPassword()
 			if accessCode == "" {
@@ -158,10 +166,13 @@ func (h *WSHandler) HandleWebSocket(c *gin.Context) {
 			if err != nil {
 				log.Printf("Failed to set temporary password: %v", err)
 			}
-			
+
 			log.Printf("Device registered: device_id=%s, temp_password=%s", device.DeviceID, accessCode)
 		} else {
-			// Device exists, update temporary password if provided
+			// Device exists, update device info and temporary password
+			if osInfo != "Unknown" || osVersion != "Unknown" || appVersion != "Unknown" {
+				h.deviceService.UpdateDeviceInfo(c.Request.Context(), deviceID, osInfo, osVersion, appVersion)
+			}
 			if accessCode != "" {
 				err = h.authService.SetTemporaryPassword(c.Request.Context(), deviceID, accessCode)
 				if err != nil {
@@ -297,6 +308,18 @@ func (h *WSHandler) HandleWebSocket(c *gin.Context) {
 				}
 				continue // Don't forward this message to clients
 			}
+			if !isClient && wsMsg.Type == "set_device_info" {
+				// Host is reporting its device info (OS, version, etc.)
+				if wsMsg.OS != "" || wsMsg.OSVersion != "" || wsMsg.AppVersion != "" {
+					h.deviceService.UpdateDeviceInfo(context.Background(), deviceID, wsMsg.OS, wsMsg.OSVersion, wsMsg.AppVersion)
+					log.Printf("Device info updated for %s: os=%s, os_version=%s, app_version=%s",
+						deviceID, wsMsg.OS, wsMsg.OSVersion, wsMsg.AppVersion)
+					h.sendToConnection(conn, map[string]interface{}{
+						"type": "device_info_set",
+					})
+				}
+				continue
+			}
 		}
 
 		// Forward message

SignalingServer/internal/repository/device_repo.go

@@ -42,9 +42,13 @@ func (r *DeviceRepository) Update(ctx context.Context, device *models.Device) er
 
 // SetOnline updates the online status of a device
 func (r *DeviceRepository) SetOnline(ctx context.Context, deviceID string, online bool) error {
+	updates := map[string]interface{}{"online": online}
+	if online {
+		updates["last_seen"] = time.Now()
+	}
 	return r.db.WithContext(ctx).Model(&models.Device{}).
 		Where("device_id = ?", deviceID).
-		Update("online", online).Error
+		Updates(updates).Error
 }
 
 // UpdateLastSeen updates the last_seen timestamp of a device
@@ -54,6 +58,26 @@ func (r *DeviceRepository) UpdateLastSeen(ctx context.Context, deviceID string)
 		Update("last_seen", time.Now()).Error
 }
 
+// UpdateDeviceInfo updates OS, OSVersion, and AppVersion for a device
+func (r *DeviceRepository) UpdateDeviceInfo(ctx context.Context, deviceID, os, osVersion, appVersion string) error {
+	updates := map[string]interface{}{}
+	if os != "" {
+		updates["os"] = os
+	}
+	if osVersion != "" {
+		updates["os_version"] = osVersion
+	}
+	if appVersion != "" {
+		updates["app_version"] = appVersion
+	}
+	if len(updates) == 0 {
+		return nil
+	}
+	return r.db.WithContext(ctx).Model(&models.Device{}).
+		Where("device_id = ?", deviceID).
+		Updates(updates).Error
+}
+
 // List retrieves devices with pagination
 func (r *DeviceRepository) List(ctx context.Context, offset, limit int) ([]models.Device, error) {
 	var devices []models.Device

SignalingServer/internal/service/device_service.go

@@ -85,9 +85,16 @@ func (s *DeviceService) RegisterDevice(ctx context.Context, req *RegisterDeviceR
 	if req.DeviceID != "" {
 		existingDevice, err := s.repo.GetByDeviceID(ctx, req.DeviceID)
 		if err == nil {
-			// Device exists, update last_seen and return
+			// Device exists, update last_seen and device info
 			log.Printf("Device already exists: device_id=%s", req.DeviceID)
 			s.repo.UpdateLastSeen(ctx, req.DeviceID)
+			// Update device info if provided (handles app upgrades)
+			if req.OS != "" || req.OSVersion != "" || req.AppVersion != "" {
+				s.repo.UpdateDeviceInfo(ctx, req.DeviceID, req.OS, req.OSVersion, req.AppVersion)
+				existingDevice.OS = req.OS
+				existingDevice.OSVersion = req.OSVersion
+				existingDevice.AppVersion = req.AppVersion
+			}
 			return existingDevice, false, nil
 		}
 		if err != gorm.ErrRecordNotFound {
@@ -181,4 +188,11 @@ func (s *DeviceService) IsDeviceOnline(ctx context.Context, deviceID string) (bo
 // GetAllDevices returns all devices
 func (s *DeviceService) GetAllDevices(ctx context.Context) ([]models.Device, error) {
 	return s.repo.GetAll(ctx)
+}
+
+// UpdateDeviceInfo updates OS, OSVersion, and AppVersion for a device
+func (s *DeviceService) UpdateDeviceInfo(ctx context.Context, deviceID, os, osVersion, appVersion string) {
+	if err := s.repo.UpdateDeviceInfo(ctx, deviceID, os, osVersion, appVersion); err != nil {
+		log.Printf("Failed to update device info for %s: %v", deviceID, err)
+	}
 }

SignalingServer/web/src/views/HomePage.vue

@@ -142,29 +142,7 @@ const connectionStatus = ref({
   apiRequests: 0
 })
 
-const activityList = ref([
-  {
-    time: '2026-03-06 14:45:35',
-    deviceId: '642407192',
-    action: '设备登录',
-    details: '设备 642407192 成功登录',
-    status: 'success'
-  },
-  {
-    time: '2026-03-06 14:40:12',
-    deviceId: '123456789',
-    action: '设备注册',
-    details: '新设备 123456789 注册成功',
-    status: 'success'
-  },
-  {
-    time: '2026-03-06 14:35:45',
-    deviceId: '987654321',
-    action: '密码验证',
-    details: '设备 987654321 密码验证失败',
-    status: 'failed'
-  }
-])
+const activityList = ref([])
 
 function rowClassName({ row }) {
   return row.status === 'success' ? 'success-row' : 'failed-row'
@@ -214,8 +192,12 @@ let systemStatusTimer = null
 
 async function refreshSystemStatus() {
   try {
-    const systemData = await getSystemStatus()
+    const [systemData, connectionData] = await Promise.all([
+      getSystemStatus(),
+      getConnectionStatus()
+    ])
     systemStatus.value = systemData
+    connectionStatus.value = connectionData
     updateOverview(systemData)
   } catch (e) {
     console.error('Failed to refresh system status:', e.message)
@@ -224,7 +206,7 @@ async function refreshSystemStatus() {
 
 function startSystemStatusAutoRefresh() {
   if (systemStatusTimer) clearInterval(systemStatusTimer)
-  systemStatusTimer = setInterval(refreshSystemStatus, 1000)
+  systemStatusTimer = setInterval(refreshSystemStatus, 5000)
 }
 
 function stopSystemStatusAutoRefresh() {