Merge pull request #65 from komari-monitor/dev

fix: #57 api.Records引入线程安全的泛型映射

README.md

@@ -85,6 +85,7 @@ Komari 是一款轻量级的自托管服务器监控工具，旨在提供简单
 
 ## 鸣谢
  - 感谢我自己能这么闲
+ - 广告位招租喵
 
 ## 引用
  - [gorm.io](https://gorm.io/)

api/Common.go

@@ -15,7 +15,7 @@ import (
 )
 
 var (
-	Records map[string][]common.Report = make(map[string][]common.Report)
+	Records = utils.NewSafeMap[string, []common.Report]()
 )
 
 type TerminalSession struct {
@@ -31,8 +31,10 @@ var TerminalSessions = make(map[string]*TerminalSession)
 func SaveClientReportToDB() error {
 	lastMinute := time.Now().Add(-time.Minute * 1).Unix()
 	record := []models.Record{}
+	var err error
+
 	// 遍历所有的客户端记录
-	for uuid, reports := range Records {
+	Records.Range(func(uuid string, reports []common.Report) bool {
 		// 删除一分钟前的记录
 		filtered := reports[:0]
 		for _, r := range reports {
@@ -40,19 +42,24 @@ func SaveClientReportToDB() error {
 				filtered = append(filtered, r)
 			}
 		}
-		Records[uuid] = filtered
-		r := utils.AverageReport(uuid, time.Now(), filtered)
+		Records.Store(uuid, filtered)
 
+		if uuid == "" {
+			return true
+		}
+
+		r := utils.AverageReport(uuid, time.Now(), filtered)
 		record = append(record, r)
 
 		db := dbcore.GetDBInstance()
-		err := db.Model(&models.Record{}).Where("client = ?", uuid).Create(record).Error
+		err = db.Model(&models.Record{}).Create(record).Error
 		if err != nil {
-			return err
+			return false
 		}
-	}
+		return true
+	})
 
-	return nil
+	return err
 }
 
 type Response struct {

api/admin/exec.go

@@ -25,7 +25,7 @@ func Exec(c *gin.Context) {
 		api.RespondError(c, 400, "Invalid or missing request body: "+err.Error())
 		return
 	}
-	for uuid := range ws.ConnectedClients {
+	for uuid := range ws.GetConnectedClients() {
 		if contain(req.Clients, uuid) {
 			onlineClients = append(onlineClients, uuid)
 		} else {
@@ -53,7 +53,7 @@ func Exec(c *gin.Context) {
 		send.TaskId = taskId
 
 		payload, _ := json.Marshal(send)
-		client := ws.ConnectedClients[uuid]
+		client := ws.GetConnectedClients()[uuid]
 		if client != nil {
 			client.WriteMessage(websocket.TextMessage, payload)
 		} else {

api/admin/notification/offline.go

@@ -79,15 +79,15 @@ func EditOfflineNotification(c *gin.Context) {
 			api.RespondError(c, 400, "Client UUID cannot be empty")
 			return
 		}
-		if noti.GracePeriod <= 0 || noti.Cooldown <= 0 {
-			api.RespondError(c, 400, "GracePeriod and Cooldown must be positive integers")
+		if noti.GracePeriod <= 0 {
+			api.RespondError(c, 400, "GracePeriod must be a positive integer")
 			return
 		}
 	}
 	err := dbcore.GetDBInstance().Model(&models.OfflineNotification{}).
 		Clauses(clause.OnConflict{
 			Columns:   []clause.Column{{Name: "client"}},
-			DoUpdates: clause.AssignmentColumns([]string{"enable", "cooldown", "grace_period"}),
+			DoUpdates: clause.AssignmentColumns([]string{"enable", "grace_period"}),
 		}).
 		Select("*").
 		Create(notifications).Error

api/admin/ping.go

@@ -0,0 +1,80 @@
+package admin
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+	"github.com/komari-monitor/komari/api"
+	"github.com/komari-monitor/komari/database/models"
+	"github.com/komari-monitor/komari/database/tasks"
+)
+
+// POST body: clients []string, target, task_type string, interval int
+func AddPingTask(c *gin.Context) {
+	var req struct {
+		Clients  []string `json:"clients" binding:"required"`
+		Name     string   `json:"name" binding:"required"`
+		Target   string   `json:"target" binding:"required"`
+		TaskType string   `json:"type" binding:"required"`     // icmp, tcp, http
+		Interval int      `json:"interval" binding:"required"` // 间隔时间，单位秒
+	}
+
+	if err := c.ShouldBindJSON(&req); err != nil {
+		api.RespondError(c, http.StatusBadRequest, err.Error())
+		return
+	}
+
+	if taskID, err := tasks.AddPingTask(req.Clients, req.Name, req.Target, req.TaskType, req.Interval); err != nil {
+		api.RespondError(c, http.StatusInternalServerError, err.Error())
+	} else {
+		api.RespondSuccess(c, gin.H{"task_id": taskID})
+	}
+}
+
+// POST body: id []uint
+func DeletePingTask(c *gin.Context) {
+	var req struct {
+		ID []uint `json:"id" binding:"required"`
+	}
+	if err := c.ShouldBindJSON(&req); err != nil {
+		api.RespondError(c, http.StatusBadRequest, err.Error())
+		return
+	}
+
+	if err := tasks.DeletePingTask(req.ID); err != nil {
+		api.RespondError(c, http.StatusInternalServerError, err.Error())
+	} else {
+		api.RespondSuccess(c, nil)
+	}
+}
+
+// POST body: id []uint, updates map[string]interface{}
+func EditPingTask(c *gin.Context) {
+	var req struct {
+		Tasks []*models.PingTask `json:"tasks" binding:"required"`
+	}
+
+	if err := c.ShouldBindJSON(&req); err != nil {
+		api.RespondError(c, http.StatusBadRequest, "Invalid request data")
+		return
+	}
+
+	if err := tasks.EditPingTask(req.Tasks); err != nil {
+		api.RespondError(c, http.StatusInternalServerError, err.Error())
+	} else {
+		// for _, task := range req.Tasks {
+		// 	tasks.DeletePingRecords([]uint{task.Id})
+		// }
+		api.RespondSuccess(c, nil)
+	}
+}
+
+func GetAllPingTasks(c *gin.Context) {
+	tasks, err := tasks.GetAllPingTasks()
+	if err != nil {
+		api.RespondError(c, http.StatusInternalServerError, err.Error())
+		return
+	}
+
+	api.RespondSuccess(c, tasks)
+}

api/admin/test/test.go

@@ -7,14 +7,14 @@ import (
 	"github.com/komari-monitor/komari/api"
 	"github.com/komari-monitor/komari/database/config"
 	"github.com/komari-monitor/komari/utils/geoip"
-	"github.com/komari-monitor/komari/utils/telegram"
+	"github.com/komari-monitor/komari/utils/messageSender"
 )
 
-func TestTelegram(c *gin.Context) {
+func TestSendMessage(c *gin.Context) {
 	message := "Komari test message."
-	err := telegram.SendTextMessage(message)
+	err := messageSender.SendTextMessage(message)
 	if err != nil {
-		api.RespondError(c, 500, "Failed to send Telegram message: "+err.Error())
+		api.RespondError(c, 500, "Failed to send message: "+err.Error())
 		return
 	}
 	api.RespondSuccess(c, nil)

api/client/report.go

@@ -15,6 +15,8 @@ import (
 	"github.com/komari-monitor/komari/api"
 	"github.com/komari-monitor/komari/common"
 	"github.com/komari-monitor/komari/database/clients"
+	"github.com/komari-monitor/komari/database/models"
+	"github.com/komari-monitor/komari/database/tasks"
 	"github.com/komari-monitor/komari/utils/notification"
 	"github.com/komari-monitor/komari/ws"
 )
@@ -48,7 +50,7 @@ func UploadReport(c *gin.Context) {
 	}
 	// Update report with method and token
 
-	ws.LatestReport[report.UUID] = &report
+	ws.GetLatestReport()[report.UUID] = &report
 
 	c.Request.Body = io.NopCloser(bytes.NewBuffer(bodyBytes)) // Restore the body for further use
 	c.JSON(200, gin.H{"status": "success"})
@@ -66,11 +68,12 @@ func WebSocketReport(c *gin.Context) {
 		},
 	}
 	// Upgrade the HTTP connection to a WebSocket connection
-	conn, err := upgrader.Upgrade(c.Writer, c.Request, nil)
+	unsafeConn, err := upgrader.Upgrade(c.Writer, c.Request, nil)
 	if err != nil {
 		c.JSON(http.StatusBadRequest, gin.H{"status": "error", "error": "Failed to upgrade to WebSocket"})
 		return
 	}
+	conn := ws.NewSafeConn(unsafeConn)
 	defer conn.Close()
 
 	_, message, err := conn.ReadMessage()
@@ -106,14 +109,14 @@ func WebSocketReport(c *gin.Context) {
 	}
 
 	// 只允许一个客户端的连接
-	if _, exists := ws.ConnectedClients[uuid]; exists {
+	if _, exists := ws.GetConnectedClients()[uuid]; exists {
 		conn.WriteJSON(gin.H{"status": "error", "error": "Token already in use"})
 		return
 	}
-	ws.ConnectedClients[uuid] = conn
+	ws.SetConnectedClients(uuid, conn)
 	go notification.OnlineNotification(uuid)
 	defer func() {
-		delete(ws.ConnectedClients, uuid)
+		ws.DeleteConnectedClients(uuid)
 		notification.OfflineNotification(uuid)
 	}()
 
@@ -123,29 +126,67 @@ func WebSocketReport(c *gin.Context) {
 			break
 		}
 
-		report := common.Report{}
-		err = json.Unmarshal(message, &report)
-		if err != nil {
-			break
+		type MessageType struct {
+			Type string `json:"type"`
 		}
-		report.UpdatedAt = time.Now()
-		err = SaveClientReport(uuid, report)
+		var msgType MessageType
+		err = json.Unmarshal(message, &msgType)
 		if err != nil {
-			conn.WriteJSON(gin.H{"status": "error", "error": fmt.Sprintf("%v", err)})
+			conn.WriteJSON(gin.H{"status": "error", "error": "Invalid JSON"})
+			continue
+		}
+		switch msgType.Type {
+		case "", "report":
+			report := common.Report{}
+			err = json.Unmarshal(message, &report)
+			if err != nil {
+				conn.WriteJSON(gin.H{"status": "error", "error": "Invalid report format"})
+				continue
+			}
+			report.UpdatedAt = time.Now()
+			err = SaveClientReport(uuid, report)
+			if err != nil {
+				conn.WriteJSON(gin.H{"status": "error", "error": fmt.Sprintf("%v", err)})
+				continue
+			}
+			ws.SetLatestReport(uuid, &report)
+		case "ping_result":
+			var reqBody struct {
+				PingTaskID uint      `json:"task_id"`
+				PingResult int       `json:"value"`
+				PingType   string    `json:"ping_type"`
+				FinishedAt time.Time `json:"finished_at"`
+			}
+			err = json.Unmarshal(message, &reqBody)
+			if err != nil {
+				conn.WriteJSON(gin.H{"status": "error", "error": "Invalid ping result format"})
+				continue
+			}
+			pingResult := models.PingRecord{
+				Client: uuid,
+				TaskId: reqBody.PingTaskID,
+				Value:  reqBody.PingResult,
+				Time:   reqBody.FinishedAt,
+			}
+			tasks.SavePingRecord(pingResult)
+		default:
+			log.Printf("Unknown message type: %s", msgType.Type)
+			conn.WriteJSON(gin.H{"status": "error", "error": "Unknown message type"})
 		}
 
-		ws.LatestReport[uuid] = &report
 	}
 }
 
 func SaveClientReport(uuid string, report common.Report) error {
-	if api.Records[uuid] == nil {
-		api.Records[uuid] = []common.Report{}
+	reports, _ := api.Records.Get(uuid)
+	if reports == nil {
+		reports = []common.Report{}
 	}
 	if report.CPU.Usage < 0.01 {
 		report.CPU.Usage = 0.01
 	}
-	api.Records[uuid] = append(api.Records[uuid], report)
+	reports = append(reports, report)
+	api.Records.Set(uuid, reports)
 
 	return nil
 }

api/latestRecord.go

@@ -10,5 +10,6 @@ func GetClientRecentRecords(c *gin.Context) {
 		RespondError(c, 400, "UUID is required")
 		return
 	}
-	RespondSuccess(c, Records[uuid])
+	records, _ := Records.Get(uuid)
+	RespondSuccess(c, records)
 }

api/public.go

@@ -13,13 +13,16 @@ func GetPublicSettings(c *gin.Context) {
 	}
 	// Return public settings including CORS
 	RespondSuccess(c, gin.H{
-		"sitename":               cst.Sitename,
-		"description":            cst.Description,
-		"custom_head":            cst.CustomHead,
-		"custom_body":            cst.CustomBody,
-		"oauth_enable":           cst.OAuthEnabled,
-		"disable_password_login": cst.DisablePasswordLogin,
-		"allow_cors":             cst.AllowCors,
+		"sitename":                  cst.Sitename,
+		"description":               cst.Description,
+		"custom_head":               cst.CustomHead,
+		"custom_body":               cst.CustomBody,
+		"oauth_enable":              cst.OAuthEnabled,
+		"disable_password_login":    cst.DisablePasswordLogin,
+		"allow_cors":                cst.AllowCors,
+		"record_enabled":            cst.RecordEnabled,
+		"record_preserve_time":      cst.RecordPreserveTime,
+		"ping_record_preserve_time": cst.PingRecordPreserveTime,
 	})
 
 }

api/record/record.go

@@ -0,0 +1,109 @@
+package record
+
+import (
+	"strconv"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/komari-monitor/komari/api"
+	records "github.com/komari-monitor/komari/database/records"
+	"github.com/komari-monitor/komari/database/tasks"
+)
+
+func GetRecordsByUUID(c *gin.Context) {
+	uuid := c.Query("uuid")
+	hours := c.Query("hours")
+	if uuid == "" {
+		api.RespondError(c, 400, "UUID is required")
+		return
+	}
+	if hours == "" {
+		hours = "4"
+	}
+
+	hoursInt, err := strconv.Atoi(hours)
+	if err != nil {
+		api.RespondError(c, 400, "Invalid hours parameter")
+		return
+	}
+
+	records, err := records.GetRecordsByClientAndTime(uuid, time.Now().Add(-time.Duration(hoursInt)*time.Hour), time.Now())
+	if err != nil {
+		api.RespondError(c, 500, "Failed to fetch records: "+err.Error())
+		return
+	}
+	api.RespondSuccess(c, gin.H{
+		"records": records,
+		"count":   len(records),
+	})
+}
+
+// GET query: uuid string, hours int
+func GetPingRecords(c *gin.Context) {
+	uuid := c.Query("uuid")
+	hours := c.Query("hours")
+
+	if uuid == "" {
+		api.RespondError(c, 400, "UUID is required")
+		return
+	}
+	if hours == "" {
+		hours = "4"
+	}
+
+	hoursInt, err := strconv.Atoi(hours)
+	if err != nil {
+		api.RespondError(c, 400, "Invalid hours parameter")
+		return
+	}
+
+	records, err := tasks.GetPingRecordsByClientAndTime(uuid, time.Now().Add(-time.Duration(hoursInt)*time.Hour), time.Now())
+	if err != nil {
+		api.RespondError(c, 500, "Failed to fetch records: "+err.Error())
+		return
+	}
+
+	response := gin.H{
+		"records": records,
+		"count":   len(records),
+	}
+
+	if len(records) > 0 {
+		// 获取当前属于该 uuid 的 pingTasks
+		pingTasks, err := tasks.GetAllPingTasks()
+		if err != nil {
+			api.RespondError(c, 500, "Failed to fetch ping tasks: "+err.Error())
+			return
+		}
+
+		taskIdSet := make(map[uint]struct{})
+		for _, r := range records {
+			taskIdSet[r.TaskId] = struct{}{}
+		}
+
+		tasksList := make([]gin.H, 0, len(pingTasks))
+		for _, t := range pingTasks {
+			// 只保留分配给该 uuid 的任务
+			found := false
+			for _, client := range t.Clients {
+				if client == uuid {
+					found = true
+					break
+				}
+			}
+			if !found {
+				continue
+			}
+			// 只返回有记录的任务
+			if _, ok := taskIdSet[t.Id]; ok {
+				tasksList = append(tasksList, gin.H{
+					"id":   t.Id,
+					"name": t.Name,
+				})
+			}
+		}
+		response["tasks"] = tasksList
+	}
+
+	api.RespondSuccess(c, response)
+}

api/terminal.go

@@ -62,7 +62,7 @@ func RequestTerminal(c *gin.Context) {
 		return nil
 	})
 
-	if ws.ConnectedClients[uuid] == nil {
+	if ws.GetConnectedClients()[uuid] == nil {
 		conn.WriteMessage(1, []byte("Client offline!\n被控端离线!"))
 		conn.Close()
 		TerminalSessionsMutex.Lock()
@@ -70,7 +70,7 @@ func RequestTerminal(c *gin.Context) {
 		TerminalSessionsMutex.Unlock()
 		return
 	}
-	err = ws.ConnectedClients[uuid].WriteJSON(gin.H{
+	err = ws.GetConnectedClients()[uuid].WriteJSON(gin.H{
 		"message":    "terminal",
 		"request_id": id,
 	})

cmd/server.go

@@ -18,6 +18,7 @@ import (
 	"github.com/komari-monitor/komari/api/admin/test"
 	"github.com/komari-monitor/komari/api/admin/update"
 	"github.com/komari-monitor/komari/api/client"
+	"github.com/komari-monitor/komari/api/record"
 	"github.com/komari-monitor/komari/cmd/flags"
 	"github.com/komari-monitor/komari/database/accounts"
 	"github.com/komari-monitor/komari/database/config"
@@ -27,6 +28,7 @@ import (
 	"github.com/komari-monitor/komari/database/records"
 	"github.com/komari-monitor/komari/database/tasks"
 	"github.com/komari-monitor/komari/public"
+	"github.com/komari-monitor/komari/utils"
 	"github.com/komari-monitor/komari/utils/geoip"
 	"github.com/komari-monitor/komari/ws"
 	"github.com/spf13/cobra"
@@ -41,7 +43,14 @@ var ServerCmd = &cobra.Command{
 	Short: "Start the server",
 	Long:  `Start the server`,
 	Run: func(cmd *cobra.Command, args []string) {
+		// #region 初始化
+		if err := os.MkdirAll("./data", os.ModePerm); err != nil {
+			log.Fatalf("Failed to create data directory: %v", err)
+		}
 		InitDatabase()
+		if utils.VersionHash != "unknown" {
+			gin.SetMode(gin.ReleaseMode)
+		}
 		go geoip.InitGeoIp()
 		go DoScheduledWork()
 
@@ -82,7 +91,7 @@ var ServerCmd = &cobra.Command{
 		r.Any("/ping", func(c *gin.Context) {
 			c.String(200, "pong")
 		})
-
+		// #region 公开路由
 		r.POST("/api/login", api.Login)
 		r.GET("/api/me", api.GetMe)
 		r.GET("/api/clients", ws.GetClients)
@@ -94,6 +103,9 @@ var ServerCmd = &cobra.Command{
 		r.GET("/api/version", api.GetVersion)
 		r.GET("/api/recent/:uuid", api.GetClientRecentRecords)
 
+		r.GET("/api/records/load", record.GetRecordsByUUID)
+		r.GET("/api/records/ping", record.GetPingRecords)
+		// #region Agent
 		tokenAuthrized := r.Group("/api/clients", api.TokenAuthMiddleware())
 		{
 			tokenAuthrized.GET("/report", client.WebSocketReport) // websocket
@@ -102,14 +114,14 @@ var ServerCmd = &cobra.Command{
 			tokenAuthrized.GET("/terminal", client.EstablishConnection)
 			tokenAuthrized.POST("/task/result", client.TaskResult)
 		}
-
+		// #region 管理员
 		adminAuthrized := r.Group("/api/admin", api.AdminAuthMiddleware())
 		{
 			// test
 			testGroup := adminAuthrized.Group("/test")
 			{
-				testGroup.GET("/telegram", test.TestTelegram)
 				testGroup.GET("/geoip", test.TestGeoIp)
+				testGroup.POST("/sendMessage", test.TestSendMessage)
 			}
 			// update
 			updateGroup := adminAuthrized.Group("/update")
@@ -190,12 +202,22 @@ var ServerCmd = &cobra.Command{
 				notificationGroup.POST("/offline/enable", notification.EnableOfflineNotification)
 				notificationGroup.POST("/offline/disable", notification.DisableOfflineNotification)
 			}
+
+			pingTaskGroup := adminAuthrized.Group("/ping")
+			{
+				pingTaskGroup.GET("/", admin.GetAllPingTasks)
+				pingTaskGroup.POST("/add", admin.AddPingTask)
+				pingTaskGroup.POST("/delete", admin.DeletePingTask)
+				pingTaskGroup.POST("/edit", admin.EditPingTask)
+
+			}
+
 		}
 
 		public.Static(r.Group("/"), func(handlers ...gin.HandlerFunc) {
 			r.NoRoute(handlers...)
 		})
-		// 静态文件服务
+		// #region 静态文件服务
 		public.UpdateIndex(conf)
 		config.Subscribe(func(event config.ConfigEvent) {
 			public.UpdateIndex(event.New)
@@ -254,19 +276,23 @@ func InitDatabase() {
 	}
 }
 
+// #region 定时任务
 func DoScheduledWork() {
+	tasks.ReloadPingSchedule()
 	ticker := time.NewTicker(time.Minute * 30)
-	ticker1 := time.NewTicker(60 * time.Second)
-	records.DeleteRecordBefore(time.Now().Add(-time.Hour * 24 * 30))
+	minute := time.NewTicker(60 * time.Second)
+	//records.DeleteRecordBefore(time.Now().Add(-time.Hour * 24 * 30))
 	records.CompactRecord()
+	cfg, _ := config.Get()
 	for {
 		select {
 		case <-ticker.C:
-			records.DeleteRecordBefore(time.Now().Add(-time.Hour * 24 * 30))
+			records.DeleteRecordBefore(time.Now().Add(-time.Hour * time.Duration(cfg.RecordPreserveTime)))
 			records.CompactRecord()
-			tasks.ClearTaskResultsByTimeBefore(time.Now().Add(-time.Hour * 24 * 30))
+			tasks.ClearTaskResultsByTimeBefore(time.Now().Add(-time.Hour * time.Duration(cfg.RecordPreserveTime)))
+			tasks.DeletePingRecordsBefore(time.Now().Add(-time.Hour * time.Duration(cfg.PingRecordPreserveTime)))
 			logOperation.RemoveOldLogs()
-		case <-ticker1.C:
+		case <-minute.C:
 			api.SaveClientReportToDB()
 		}
 	}

database/dbcore/dbcore.go

@@ -82,43 +82,6 @@ var (
 	once     sync.Once
 )
 
-// 初始化数据库
-// 对于 SQLite：true 如果数据库文件存在，false 如果数据库文件不存在并被创建
-// 对于 MySQL/其他数据库：总是返回 true
-// func InitDatabase() bool {
-// 	// 默认使用 SQLite 如果未指定类型
-// 	if flags.DatabaseType == "" || flags.DatabaseType == "sqlite" {
-// 		if _, err := os.Stat(flags.DatabaseFile); os.IsNotExist(err) {
-// 			log.Printf("SQLite database file %q does not exist, creating...", flags.DatabaseFile)
-// 			dbDir := filepath.Dir(flags.DatabaseFile)
-// 			if dbDir != "" {
-// 				if err := os.MkdirAll(dbDir, 0755); err != nil {
-// 					log.Fatalf("Failed to create database file directory %q: %v", dbDir, err)
-// 				}
-// 			}
-// 			file, err := os.Create(flags.DatabaseFile)
-// 			if err != nil {
-// 				log.Fatalf("Failed to create SQLite database file %q: %v", flags.DatabaseFile, err)
-// 			}
-// 			if err := file.Close(); err != nil {
-// 				log.Fatalf("Failed to close database file %q: %v", flags.DatabaseFile, err)
-// 			}
-// 			return false
-// 		} else if err != nil {
-// 			log.Fatalf("Failed to check database file %q: %v", flags.DatabaseFile, err)
-// 		}
-// 		return true
-// 	} else if flags.DatabaseType == "mysql" {
-// 		// 对于 MySQL，我们不需要创建文件，只需检查连接信息是否有效
-// 		log.Printf("Using MySQL database: %s@%s:%s/%s",
-// 			flags.DatabaseUser, flags.DatabaseHost, flags.DatabasePort, flags.DatabaseName)
-// 		return true
-// 	} else {
-// 		log.Fatalf("Unsupported database type: %s", flags.DatabaseType)
-// 		return false
-// 	}
-// }
-
 func GetDBInstance() *gorm.DB {
 	once.Do(func() {
 		var err error
@@ -171,10 +134,18 @@ func GetDBInstance() *gorm.DB {
 			&models.Clipboard{},
 			&models.LoadNotification{},
 			&models.OfflineNotification{},
+			&models.PingRecord{},
+			&models.PingTask{},
 		)
 		if err != nil {
 			log.Fatalf("Failed to create tables: %v", err)
 		}
+		err = instance.Table("records_long_term").AutoMigrate(
+			&models.Record{},
+		)
+		if err != nil {
+			log.Printf("Failed to create records_long_term table, it may already exist: %v", err)
+		}
 		err = instance.AutoMigrate(
 			&models.Session{},
 		)

database/models/config.go

@@ -19,12 +19,17 @@ type Config struct {
 	CustomHead string `json:"custom_head" gorm:"type:longtext"`
 	CustomBody string `json:"custom_body" gorm:"type:longtext"`
 	// Telegram Bot 配置
-	TelegramEnabled  bool   `json:"telegram_enabled" gorm:"default:false"`
+	// TelegramEnabled  bool   `json:"telegram_enabled" gorm:"default:false"`
 	TelegramEndpoint string `json:"telegram_endpoint" gorm:"type:varchar(255);default:'https://api.telegram.org/bot'"`
 	TelegramBotToken string `json:"telegram_bot_token" gorm:"type:varchar(255)"`
 	TelegramChatID   string `json:"telegram_chat_id" gorm:"type:varchar(255)"`
 	// 通知
-	NotificationEnabled bool `json:"notification_enabled" gorm:"default:false"` // 通知总开关
-	CreatedAt           time.Time
-	UpdatedAt           time.Time
+	NotificationEnabled bool   `json:"notification_enabled" gorm:"default:false"` // 通知总开关
+	NotificationMethod  string `json:"notification_method" gorm:"type:varchar(64);default:'none'"`
+	// Record
+	RecordEnabled          bool `json:"record_enabled" gorm:"default:true"`          // 是否启用记录功能
+	RecordPreserveTime     int  `json:"record_preserve_time" gorm:"default:720"`     // 记录保留时间，单位小时，默认30天
+	PingRecordPreserveTime int  `json:"ping_record_preserve_time" gorm:"default:72"` // Ping 记录保留时间，单位小时，默认3天
+	CreatedAt              time.Time
+	UpdatedAt              time.Time
 }

database/models/models.go

@@ -1,6 +1,9 @@
 package models
 
 import (
+	"database/sql/driver"
+	"encoding/json"
+	"fmt"
 	"time"
 )
 
@@ -81,3 +84,19 @@ type Record struct {
 	Connections    int       `json:"connections"`
 	ConnectionsUdp int       `json:"connections_udp"`
 }
+
+// StringArray represents a slice of strings stored as JSON in the database
+// StringArray 存储为 JSON 的字符串切片类型
+type StringArray []string
+
+func (sa *StringArray) Scan(value interface{}) error {
+	bytes, ok := value.([]byte)
+	if !ok {
+		return fmt.Errorf("failed to scan StringArray: value is not []byte")
+	}
+	return json.Unmarshal(bytes, sa)
+}
+
+func (sa StringArray) Value() (driver.Value, error) {
+	return json.Marshal(sa)
+}

database/models/notification.go

@@ -1,20 +1,24 @@
 package models
 
+import "time"
+
 // Notification 定义了通知相关的数据库模型
 type OfflineNotification struct {
-	Client      string `json:"client" gorm:"type:varchar(36);not null;index;unique;constraint:OnDelete:CASCADE"`
-	Enable      bool   `json:"enable" gorm:"type:boolean;default:false"`
-	Cooldown    int    `json:"cooldown" gorm:"type:int;not null;default:1800"`    // 冷却时间（秒），默认 30 分钟
-	GracePeriod int    `json:"grace_period" gorm:"type:int;not null;default:180"` // 宽限期（秒），默认 3 分钟
+	Client string `json:"client" gorm:"type:varchar(36);not null;index;unique;constraint:OnDelete:CASCADE,OnUpdate:CASCADE;foreignKey:client;references:UUID"`
+	Enable bool   `json:"enable" gorm:"type:boolean;default:false"`
+	//Cooldown     int       `json:"cooldown" gorm:"type:int;not null;default:1800"`                // 冷却时间（秒），默认 30 分钟
+	GracePeriod  int       `json:"grace_period" gorm:"type:int;not null;default:180"` // 宽限期（秒），默认 3 分钟
+	LastNotified time.Time `json:"last_notified"`                                     // 上次通知时间
 }
 
 // LoadNotification 定义了基于资源占用达标时间比的负载通知规则
 type LoadNotification struct {
-	Client    string  `json:"client" gorm:"type:varchar(36);not null;index;constraint:OnDelete:CASCADE"`
-	Enable    bool    `json:"enable" gorm:"type:boolean;default:false"`
-	Metric    string  `json:"metric" gorm:"type:varchar(50);not null;default:'cpu'"`     // 监控指标，如 cpu, ram, load
-	Threshold float32 `json:"threshold" gorm:"type:decimal(5,2);not null;default:80.00"` // 阈值百分比
-	Window    int     `json:"window" gorm:"type:int;not null;default:300"`               // 观测窗口（秒）
-	Ratio     float32 `json:"ratio" gorm:"type:decimal(5,2);not null;default:0.80"`      // 达标时间比
-	Cooldown  int     `json:"cooldown" gorm:"type:int;not null;default:1800"`            // 冷却时间（秒）
+	Client       string    `json:"client" gorm:"type:varchar(36);not null;index;unique;constraint:OnDelete:CASCADE,OnUpdate:CASCADE;foreignKey:client;references:UUID"`
+	Enable       bool      `json:"enable" gorm:"type:boolean;default:false"`
+	Metric       string    `json:"metric" gorm:"type:varchar(50);not null;default:'cpu'"`     // 监控指标，如 cpu, ram, load
+	Threshold    float32   `json:"threshold" gorm:"type:decimal(5,2);not null;default:80.00"` // 阈值百分比
+	Window       int       `json:"window" gorm:"type:int;not null;default:300"`               // 观测窗口（秒）
+	Ratio        float32   `json:"ratio" gorm:"type:decimal(5,2);not null;default:0.80"`      // 达标时间比
+	Cooldown     int       `json:"cooldown" gorm:"type:int;not null;default:1800"`            // 冷却时间（秒）
+	LastNotified time.Time `json:"last_notified"`                                             // 上次通知时间
 }

database/models/pingTask.go

@@ -0,0 +1,19 @@
+package models
+
+import "time"
+
+type PingRecord struct {
+	Client string    `json:"client" gorm:"type:varchar(36);not null;index;constraint:OnDelete:CASCADE,OnUpdate:CASCADE;foreignKey:client;references:UUID"`
+	TaskId uint      `json:"task_id" gorm:"not null;index;constraint:OnDelete:CASCADE,OnUpdate:CASCADE;foreignKey:TaskId;references:Id"`
+	Time   time.Time `json:"time" gorm:"index;not null"`
+	Value  int       `json:"value" gorm:"type:int;not null"` // Ping 值，单位毫秒
+}
+
+type PingTask struct {
+	Id       uint        `json:"id,omitempty" gorm:"primaryKey;autoIncrement"`
+	Name     string      `json:"name" gorm:"type:varchar(255);not null;index"`
+	Clients  StringArray `json:"clients" gorm:"type:longtext"`
+	Type     string      `json:"type" gorm:"type:varchar(12);not null;default:'icmp'"` // icmp tcp http
+	Target   string      `json:"target" gorm:"type:varchar(255);not null"`
+	Interval int         `json:"interval" gorm:"type:int;not null;default:60"` // 间隔时间
+}

database/models/task.go

@@ -1,27 +1,9 @@
 package models
 
 import (
-	"database/sql/driver"
-	"encoding/json"
-	"fmt"
 	"time"
 )
 
-// StringArray represents a slice of strings stored as JSON in the database
-type StringArray []string
-
-func (sa *StringArray) Scan(value interface{}) error {
-	bytes, ok := value.([]byte)
-	if !ok {
-		return fmt.Errorf("failed to scan StringArray: value is not []byte")
-	}
-	return json.Unmarshal(bytes, sa)
-}
-
-func (sa StringArray) Value() (driver.Value, error) {
-	return json.Marshal(sa)
-}
-
 type Task struct {
 	TaskId  string      `json:"task_id" gorm:"type:varchar(36);primaryKey;unique"`
 	Clients StringArray `json:"clients" gorm:"type:longtext"`

database/records/records.go

@@ -2,6 +2,8 @@ package records
 
 import (
 	"log"
+	"sort"
+	"strings"
 	"time"
 
 	"gorm.io/gorm"
@@ -18,7 +20,10 @@ func RecordOne(rec models.Record) error {
 
 func DeleteAll() error {
 	db := dbcore.GetDBInstance()
-	return db.Exec("DELETE FROM Record").Error
+	if err := db.Exec("DELETE FROM records_long_term").Error; err != nil {
+		return err
+	}
+	return db.Exec("DELETE FROM records").Error
 }
 
 func GetLatestRecord(uuid string) (Record []models.Record, err error) {
@@ -29,98 +34,105 @@ func GetLatestRecord(uuid string) (Record []models.Record, err error) {
 
 func DeleteRecordBefore(before time.Time) error {
 	db := dbcore.GetDBInstance()
+	db.Table("records_long_term").Where("time < ?", before).Delete(&models.Record{})
 	return db.Where("time < ?", before).Delete(&models.Record{}).Error
 }
 
-// 计算区间 [0.02, 0.98] 的平均值
-func QuantileMean(values []float32) float32 {
-	if len(values) == 0 {
-		return 0
-	}
-	// 排序数据
-	sorted := make([]float32, len(values))
-	copy(sorted, values)
-	for i := 0; i < len(sorted)-1; i++ {
-		for j := i + 1; j < len(sorted); j++ {
-			if sorted[i] > sorted[j] {
-				sorted[i], sorted[j] = sorted[j], sorted[i]
-			}
+func GetRecordsByClientAndTime(uuid string, start, end time.Time) ([]models.Record, error) {
+	db := dbcore.GetDBInstance()
+	var records []models.Record
+
+	threeHoursAgo := time.Now().Add(-3 * time.Hour)
+
+	var recentRecords []models.Record
+	recentStart := start
+	if end.After(threeHoursAgo) {
+		if recentStart.Before(threeHoursAgo) {
+			recentStart = threeHoursAgo
+		}
+		err := db.Where("client = ? AND time >= ? AND time <= ?", uuid, recentStart, end).Order("time ASC").Find(&recentRecords).Error
+		if err != nil {
+			log.Printf("Error fetching recent records for client %s between %s and %s: %v", uuid, recentStart, end, err)
+			return nil, err
 		}
 	}
-	// 区间边缘index
-	lower := int(0.02 * float64(len(sorted)))
-	upper := int(0.98 * float64(len(sorted)))
-	if lower >= upper || lower >= len(sorted) {
-		return 0
+
+	var long_term []models.Record
+	err := db.Table("records_long_term").Where("client = ? AND time >= ? AND time <= ?", uuid, start, end).Order("time ASC").Find(&long_term).Error
+	if err != nil {
+		log.Printf("Error fetching long-term records for client %s between %s and %s: %v", uuid, start, end, err)
+		return recentRecords, nil
 	}
 
-	sum := float32(0)
-	count := 0
-	for i := lower; i < upper && i < len(sorted); i++ {
-		sum += sorted[i]
-		count++
+	if len(long_term) == 0 {
+		// 没有查到long_term，返回全部recentRecords
+		records = append(records, recentRecords...)
+		return records, nil
 	}
-	if count == 0 {
-		return 0
+
+	// 查到了long_term，recentRecords按15分钟分组，每组只保留一条（取最新一条）
+	grouped := make(map[string]models.Record)
+	for _, rec := range recentRecords {
+		key := rec.Time.Truncate(15 * time.Minute).Format(time.RFC3339)
+		if old, ok := grouped[key]; !ok || rec.Time.After(old.Time) {
+			grouped[key] = rec
+		}
 	}
-	return sum / float32(count)
+	var groupedList []models.Record
+	for _, rec := range grouped {
+		groupedList = append(groupedList, rec)
+	}
+	sort.Slice(groupedList, func(i, j int) bool {
+		return groupedList[i].Time.Before(groupedList[j].Time)
+	})
+	records = append(records, groupedList...)
+	records = append(records, long_term...)
+	return records, nil
 }
 
-// 压缩数据库，针对每个ClientUUID，10分钟内的数据不动，24小时内的数据精简为每15分钟一条，3天为每30分钟一条，7天为每1小时一条，30天为每12小时一条。所有精简的数据是取 [0.02,0.98] 区间内的平均值
+func GetAllRecords() ([]models.Record, error) {
+	db := dbcore.GetDBInstance()
+	var records []models.Record
+	var long_term []models.Record
+	err := db.Table("records").Order("time ASC").Find(&records).Error
+	if err != nil {
+		log.Printf("Error fetching all records: %v", err)
+		return nil, err
+	}
+	err = db.Table("records_long_term").Order("time ASC").Find(&long_term).Error
+	if err != nil {
+		log.Printf("Error fetching long-term records: %v", err)
+		return records, nil
+	}
+	records = append(records, long_term...)
+	return records, nil
+}
+
+// 压缩数据库
 func CompactRecord() error {
 	db := dbcore.GetDBInstance()
-	//log.Printf("Compacting records...")
-	var clientUUIDs []string
-	if err := db.Model(&models.Record{}).Distinct("client").Pluck("client", &clientUUIDs).Error; err != nil {
+	err := migrateOldRecords(db)
+	if err != nil {
+		log.Printf("Error migrating old records: %v", err)
 		return err
 	}
 
-	now := time.Now()
-	tenMinutesAgo := now.Add(-10 * time.Minute)
-	oneDayAgo := now.Add(-24 * time.Hour)
-	threeDaysAgo := now.Add(-3 * 24 * time.Hour)
-	sevenDaysAgo := now.Add(-7 * 24 * time.Hour)
-	thirtyDaysAgo := now.Add(-30 * 24 * time.Hour)
-
-	for _, clientUUID := range clientUUIDs {
-		// Process each time range with specific aggregation intervals
-		if err := processTimeRange(db, clientUUID, thirtyDaysAgo, sevenDaysAgo, 12*time.Hour, now); err != nil {
-			log.Printf("Error compacting 30d-7d for client %s: %v", clientUUID, err)
-			continue
+	if flags.DatabaseType == "sqlite" {
+		if err := db.Exec("VACUUM").Error; err != nil {
+			log.Printf("Error vacuuming database: %v", err)
 		}
-		if err := processTimeRange(db, clientUUID, sevenDaysAgo, threeDaysAgo, 1*time.Hour, now); err != nil {
-			log.Printf("Error compacting 7d-3d for client %s: %v", clientUUID, err)
-			continue
-		}
-		if err := processTimeRange(db, clientUUID, threeDaysAgo, oneDayAgo, 30*time.Minute, now); err != nil {
-			log.Printf("Error compacting 3d-1d for client %s: %v", clientUUID, err)
-			continue
-		}
-		if err := processTimeRange(db, clientUUID, oneDayAgo, tenMinutesAgo, 15*time.Minute, now); err != nil {
-			log.Printf("Error compacting 1d-10m for client %s: %v", clientUUID, err)
-			continue
-		}
-	}
-	if flags.DatabaseType != "sqlite" {
-		return nil // Only vacuum for SQLite
-	}
-	if err := db.Exec("VACUUM").Error; err != nil {
-		log.Printf("Error vacuuming the database: %v", err)
 	}
 	log.Printf("Record compaction completed")
 	return nil
 }
 
-func processTimeRange(db *gorm.DB, clientUUID string, start, end time.Time, interval time.Duration, now time.Time) error {
-	// Round start time to the nearest interval
-	start = start.Truncate(interval)
-	end = end.Truncate(interval)
+func migrateOldRecords(db *gorm.DB) error {
+	// 计算 4 小时前的时间
+	fourHoursAgo := time.Now().Add(-4 * time.Hour)
 
-	// Get all records in the time range
+	// 查询 records 表中超过 4 小时的记录
 	var records []models.Record
-	if err := db.Where("client = ? AND time >= ? AND time < ?", clientUUID, start, end).
-		Order("time ASC").
-		Find(&records).Error; err != nil {
+	if err := db.Table("records").Where("time < ?", fourHoursAgo).Find(&records).Error; err != nil {
 		return err
 	}
 
@@ -128,109 +140,163 @@ func processTimeRange(db *gorm.DB, clientUUID string, start, end time.Time, inte
 		return nil
 	}
 
-	// Group records by interval
-	type aggregatedRecord struct {
-		StartTime time.Time
-		Records   []models.Record
+	// 按 Client 和 15 分钟时间段分组，并存储所有记录以计算分位数
+	type groupData struct {
+		Cpu            []float32
+		Gpu            []float32
+		Load           []float32
+		Temp           []float32
+		Ram            []int64
+		RamTotal       []int64
+		Swap           []int64
+		SwapTotal      []int64
+		Disk           []int64
+		DiskTotal      []int64
+		NetIn          []int64
+		NetOut         []int64
+		NetTotalUp     []int64
+		NetTotalDown   []int64
+		Process        []int
+		Connections    []int
+		ConnectionsUdp []int
 	}
-	var aggregatedRecords []aggregatedRecord
-	currentGroup := aggregatedRecord{StartTime: start}
-	currentGroup.Records = make([]models.Record, 0)
 
+	groupedRecords := make(map[string]*groupData)
 	for _, record := range records {
-		groupTime := record.Time.Truncate(interval)
-		if !groupTime.Equal(currentGroup.StartTime) {
-			if len(currentGroup.Records) > 0 {
-				aggregatedRecords = append(aggregatedRecords, currentGroup)
+		key := record.Client + "_" + record.Time.Truncate(15*time.Minute).Format(time.RFC3339)
+		if _, ok := groupedRecords[key]; !ok {
+			groupedRecords[key] = &groupData{}
+		}
+		data := groupedRecords[key]
+		data.Cpu = append(data.Cpu, record.Cpu)
+		data.Gpu = append(data.Gpu, record.Gpu)
+		data.Load = append(data.Load, record.Load)
+		data.Temp = append(data.Temp, record.Temp)
+		data.Ram = append(data.Ram, record.Ram)
+		data.RamTotal = append(data.RamTotal, record.RamTotal)
+		data.Swap = append(data.Swap, record.Swap)
+		data.SwapTotal = append(data.SwapTotal, record.SwapTotal)
+		data.Disk = append(data.Disk, record.Disk)
+		data.DiskTotal = append(data.DiskTotal, record.DiskTotal)
+		data.NetIn = append(data.NetIn, record.NetIn)
+		data.NetOut = append(data.NetOut, record.NetOut)
+		data.NetTotalUp = append(data.NetTotalUp, record.NetTotalUp)
+		data.NetTotalDown = append(data.NetTotalDown, record.NetTotalDown)
+		data.Process = append(data.Process, record.Process)
+		data.Connections = append(data.Connections, record.Connections)
+		data.ConnectionsUdp = append(data.ConnectionsUdp, record.ConnectionsUdp)
+	}
+
+	getPercentile := func(values []float64, percentile float64) float64 {
+		if len(values) == 0 {
+			return 0
+		}
+		sortedValues := make([]float64, len(values))
+		copy(sortedValues, values)
+		sort.Float64s(sortedValues)
+		index := float64(len(sortedValues)-1) * percentile
+		lowerIndex := int(index)
+		if lowerIndex >= len(sortedValues)-1 {
+			return sortedValues[len(sortedValues)-1]
+		}
+		frac := index - float64(lowerIndex)
+		return sortedValues[lowerIndex] + frac*(sortedValues[lowerIndex+1]-sortedValues[lowerIndex])
+	}
+
+	getIntPercentile := func(values []int64, percentile float64) int64 {
+		if len(values) == 0 {
+			return 0
+		}
+		floats := make([]float64, len(values))
+		for i, v := range values {
+			floats[i] = float64(v)
+		}
+		return int64(getPercentile(floats, percentile))
+	}
+
+	getInt32Percentile := func(values []int, percentile float64) int {
+		if len(values) == 0 {
+			return 0
+		}
+		floats := make([]float64, len(values))
+		for i, v := range values {
+			floats[i] = float64(v)
+		}
+		return int(getPercentile(floats, percentile))
+	}
+
+	return db.Transaction(func(tx *gorm.DB) error {
+		for key, data := range groupedRecords {
+			// 解析 Client 和时间
+			parts := strings.Split(key, "_")
+			clientUUID := parts[0]
+			timeSlot, err := time.Parse(time.RFC3339, strings.Join(parts[1:], "_"))
+			if err != nil {
+				return err
 			}
-			currentGroup = aggregatedRecord{StartTime: groupTime}
-			currentGroup.Records = []models.Record{record}
-		} else {
-			currentGroup.Records = append(currentGroup.Records, record)
-		}
-	}
-	if len(currentGroup.Records) > 0 {
-		aggregatedRecords = append(aggregatedRecords, currentGroup)
-	}
 
-	// Begin transaction
-	tx := db.Begin()
-	if tx.Error != nil {
-		return tx.Error
-	}
+			cpuFloats := make([]float64, len(data.Cpu))
+			for i, v := range data.Cpu {
+				cpuFloats[i] = float64(v)
+			}
+			gpuFloats := make([]float64, len(data.Gpu))
+			for i, v := range data.Gpu {
+				gpuFloats[i] = float64(v)
+			}
+			loadFloats := make([]float64, len(data.Load))
+			for i, v := range data.Load {
+				loadFloats[i] = float64(v)
+			}
+			tempFloats := make([]float64, len(data.Temp))
+			for i, v := range data.Temp {
+				tempFloats[i] = float64(v)
+			}
+			high_percentile := 0.8
+			// 检查 records_long_term 表中是否已存在相同的记录
+			var existingCount int64
+			if err := tx.Table("records_long_term").Where("client = ? AND time = ?", clientUUID, timeSlot).Count(&existingCount).Error; err != nil {
+				return err
+			}
 
-	// Delete original records in the time range
-	if err := tx.Where("client = ? AND time >= ? AND time < ?", clientUUID, start, end).Delete(&models.Record{}).Error; err != nil {
-		tx.Rollback()
-		return err
-	}
+			newRec := models.Record{
+				Client:         clientUUID,
+				Time:           timeSlot,
+				Cpu:            float32(getPercentile(cpuFloats, high_percentile)),
+				Gpu:            float32(getPercentile(gpuFloats, high_percentile)),
+				Load:           float32(getPercentile(loadFloats, high_percentile)),
+				Temp:           float32(getPercentile(tempFloats, high_percentile)),
+				Ram:            getIntPercentile(data.Ram, high_percentile),
+				RamTotal:       getIntPercentile(data.RamTotal, high_percentile),
+				Swap:           getIntPercentile(data.Swap, high_percentile),
+				SwapTotal:      getIntPercentile(data.SwapTotal, high_percentile),
+				Disk:           getIntPercentile(data.Disk, high_percentile),
+				DiskTotal:      getIntPercentile(data.DiskTotal, high_percentile),
+				NetIn:          getIntPercentile(data.NetIn, high_percentile),
+				NetOut:         getIntPercentile(data.NetOut, high_percentile),
+				NetTotalUp:     getIntPercentile(data.NetTotalUp, high_percentile),
+				NetTotalDown:   getIntPercentile(data.NetTotalDown, high_percentile),
+				Process:        getInt32Percentile(data.Process, high_percentile),
+				Connections:    getInt32Percentile(data.Connections, high_percentile),
+				ConnectionsUdp: getInt32Percentile(data.ConnectionsUdp, high_percentile),
+			}
 
-	// Insert aggregated records
-	for _, agg := range aggregatedRecords {
-		if len(agg.Records) == 0 {
-			continue
+			// 如果记录已存在则更新，否则创建新记录
+			if existingCount > 0 {
+				if err := tx.Table("records_long_term").Where("client = ? AND time = ?", clientUUID, timeSlot).Updates(&newRec).Error; err != nil {
+					return err
+				}
+			} else {
+				if err := tx.Table("records_long_term").Create(&newRec).Error; err != nil {
+					return err
+				}
+			}
 		}
 
-		// Calculate averages and sums
-		var sumCPU, sumGPU, sumLOAD, sumTEMP float32
-		var sumRAM, sumRAMTotal, sumSWAP, sumSWAPTotal, sumDISK, sumDISKTotal int64
-		var sumNETIn, sumNETOut, sumNETTotalUp, sumNETTotalDown int64
-		var sumPROCESS, sumConnections, sumConnectionsUDP int
-		count := len(agg.Records)
-
-		for _, r := range agg.Records {
-			sumCPU += r.Cpu
-			sumGPU += r.Gpu
-			sumLOAD += r.Load
-			sumTEMP += r.Temp
-			sumRAM += r.Ram
-			sumRAMTotal += r.RamTotal
-			sumSWAP += r.Swap
-			sumSWAPTotal += r.SwapTotal
-			sumDISK += r.Disk
-			sumDISKTotal += r.DiskTotal
-			sumNETIn += r.NetIn
-			sumNETOut += r.NetOut
-			sumNETTotalUp += r.NetTotalUp
-			sumNETTotalDown += r.NetTotalDown
-			sumPROCESS += r.Process
-			sumConnections += r.Connections
-			sumConnectionsUDP += r.ConnectionsUdp
-		}
-
-		// Create new aggregated record
-		newRecord := models.Record{
-			Client:         clientUUID,
-			Time:           agg.StartTime,
-			Cpu:            sumCPU / float32(count),
-			Gpu:            sumGPU / float32(count),
-			Ram:            sumRAM / int64(count),
-			RamTotal:       sumRAMTotal / int64(count),
-			Swap:           sumSWAP / int64(count),
-			SwapTotal:      sumSWAPTotal / int64(count),
-			Load:           sumLOAD / float32(count),
-			Temp:           sumTEMP / float32(count),
-			Disk:           sumDISK / int64(count),
-			DiskTotal:      sumDISKTotal / int64(count),
-			NetIn:          sumNETIn / int64(count),
-			NetOut:         sumNETOut / int64(count),
-			NetTotalUp:     sumNETTotalUp / int64(count),
-			NetTotalDown:   sumNETTotalDown / int64(count),
-			Process:        sumPROCESS / count,
-			Connections:    sumConnections / count,
-			ConnectionsUdp: sumConnectionsUDP / count,
-		}
-
-		if err := tx.Create(&newRecord).Error; err != nil {
-			tx.Rollback()
+		// 删除 records 表中的旧数据
+		if err := tx.Table("records").Where("time < ?", fourHoursAgo).Delete(&models.Record{}).Error; err != nil {
 			return err
 		}
-	}
 
-	return tx.Commit().Error
-}
-
-func Save(rec models.Record) error {
-	db := dbcore.GetDBInstance()
-	return db.Create(&rec).Error
+		return nil
+	})
 }

database/records/records_test.go

@@ -0,0 +1,130 @@
+package records
+
+import (
+	"encoding/csv"
+	"os"
+	"strconv"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"gorm.io/driver/sqlite"
+	"gorm.io/gorm"
+
+	"github.com/komari-monitor/komari/database/models"
+)
+
+var uuid = "7901508c-304f-49aa-b84f-957c33ae6f8a"
+
+var _ = func() bool {
+	// 确保 Test 环境中使用 sqlite 内存数据库
+	return true
+}()
+
+// TestCompactRecord tests the database compaction logic by inserting 4h30m of data (one record per minute),
+// then running migrateOldRecords and verifying the aggregation and cleanup.
+func TestCompactRecord(t *testing.T) {
+	const totalMinutes = 12*60 + 30
+	now := time.Now()
+	threshold := now.Add(-4 * time.Hour)
+
+	// 使用 sqlite 内存数据库并迁移表结构
+	db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
+	assert.NoError(t, err)
+	assert.NoError(t, db.AutoMigrate(&models.Record{}))
+	assert.NoError(t, db.Table("records_long_term").AutoMigrate(&models.Record{}))
+
+	expectedGroups := make(map[time.Time]struct{})
+	expectedRemain := 0
+
+	// 插入数据
+	for i := 0; i < totalMinutes; i++ {
+		recTime := now.Add(-time.Duration(i) * time.Minute)
+		rec := models.Record{Client: uuid, Time: recTime, Cpu: float32(i), Gpu: float32(i), Load: float32(i), Temp: float32(i), Ram: int64(i)}
+		err := db.Create(&rec).Error
+		assert.NoError(t, err)
+
+		if recTime.Before(threshold) {
+			slot := recTime.Truncate(time.Hour)
+			expectedGroups[slot] = struct{}{}
+		} else {
+			expectedRemain++
+		}
+	}
+
+	// 导出原始数据到 CSV
+	os.MkdirAll("../../data", 0755)
+	var origRecs []models.Record
+	db.Order("time desc").Find(&origRecs)
+	fOrig, err := os.Create("../../data/original.csv")
+	assert.NoError(t, err)
+	defer fOrig.Close()
+	wOrig := csv.NewWriter(fOrig)
+	defer wOrig.Flush()
+	wOrig.Write([]string{"Client", "Time", "Cpu", "Gpu", "Load", "Temp", "Ram"})
+	for _, r := range origRecs {
+		wOrig.Write([]string{
+			r.Client,
+			r.Time.Format(time.RFC3339),
+			strconv.FormatFloat(float64(r.Cpu), 'f', -1, 32),
+			strconv.FormatFloat(float64(r.Gpu), 'f', -1, 32),
+			strconv.FormatFloat(float64(r.Load), 'f', -1, 32),
+			strconv.FormatFloat(float64(r.Temp), 'f', -1, 32),
+			strconv.FormatInt(r.Ram, 10),
+		})
+	}
+
+	// 运行压缩（迁移）逻辑
+	err = migrateOldRecords(db)
+	assert.NoError(t, err)
+
+	// 验证 long-term 表中的聚合记录数
+	var longCount int64
+	assert.NoError(t, db.Table("records_long_term").Count(&longCount).Error)
+	assert.Equal(t, int64(len(expectedGroups)), longCount)
+
+	// 验证原始表中剩余记录数
+	var remainCount int64
+	assert.NoError(t, db.Table("records").Count(&remainCount).Error)
+	assert.Equal(t, int64(expectedRemain), remainCount+1)
+
+	// 导出压缩后的数据到 CSV
+	var compRecs []models.Record
+	db.Table("records_long_term").Order("time desc").Find(&compRecs)
+	fComp, err := os.Create("../../data/compressed.csv")
+	assert.NoError(t, err)
+	defer fComp.Close()
+	wComp := csv.NewWriter(fComp)
+	defer wComp.Flush()
+	wComp.Write([]string{"Client", "Time", "Cpu", "Gpu", "Load", "Temp", "Ram"})
+	for _, r := range compRecs {
+		wComp.Write([]string{
+			r.Client,
+			r.Time.Format(time.RFC3339),
+			strconv.FormatFloat(float64(r.Cpu), 'f', -1, 32),
+			strconv.FormatFloat(float64(r.Gpu), 'f', -1, 32),
+			strconv.FormatFloat(float64(r.Load), 'f', -1, 32),
+			strconv.FormatFloat(float64(r.Temp), 'f', -1, 32),
+			strconv.FormatInt(r.Ram, 10),
+		})
+	}
+
+	db.Table("records").Order("time desc").Find(&compRecs)
+	fComp, err = os.Create("../../data/compressed_records.csv")
+	assert.NoError(t, err)
+	defer fComp.Close()
+	wComp = csv.NewWriter(fComp)
+	defer wComp.Flush()
+	wComp.Write([]string{"Client", "Time", "Cpu", "Gpu", "Load", "Temp", "Ram"})
+	for _, r := range compRecs {
+		wComp.Write([]string{
+			r.Client,
+			r.Time.Format(time.RFC3339),
+			strconv.FormatFloat(float64(r.Cpu), 'f', -1, 32),
+			strconv.FormatFloat(float64(r.Gpu), 'f', -1, 32),
+			strconv.FormatFloat(float64(r.Load), 'f', -1, 32),
+			strconv.FormatFloat(float64(r.Temp), 'f', -1, 32),
+			strconv.FormatInt(r.Ram, 10),
+		})
+	}
+}

database/tasks/ping.go

@@ -0,0 +1,103 @@
+package tasks
+
+import (
+	"time"
+
+	"github.com/komari-monitor/komari/database/dbcore"
+	"github.com/komari-monitor/komari/database/models"
+	"github.com/komari-monitor/komari/utils"
+	"gorm.io/gorm"
+)
+
+func AddPingTask(clients []string, name string, target, task_type string, interval int) (uint, error) {
+	db := dbcore.GetDBInstance()
+	task := models.PingTask{
+		Clients:  clients,
+		Name:     name,
+		Type:     task_type,
+		Target:   target,
+		Interval: interval,
+	}
+	if err := db.Create(&task).Error; err != nil {
+		return 0, err
+	}
+	ReloadPingSchedule()
+	return task.Id, nil
+}
+
+func DeletePingTask(id []uint) error {
+	db := dbcore.GetDBInstance()
+	result := db.Where("id IN ?", id).Delete(&models.PingTask{})
+	if result.RowsAffected == 0 {
+		return gorm.ErrRecordNotFound
+	}
+	ReloadPingSchedule()
+	return result.Error
+}
+
+func EditPingTask(tasks []*models.PingTask) error {
+	db := dbcore.GetDBInstance()
+	for _, task := range tasks {
+		result := db.Model(&models.PingTask{}).Where("id = ?", task.Id).Updates(task)
+		if result.RowsAffected == 0 {
+			return gorm.ErrRecordNotFound
+		}
+	}
+	ReloadPingSchedule()
+	return nil
+}
+
+func GetAllPingTasks() ([]models.PingTask, error) {
+	db := dbcore.GetDBInstance()
+	var tasks []models.PingTask
+	if err := db.Find(&tasks).Error; err != nil {
+		return nil, err
+	}
+	return tasks, nil
+}
+
+func SavePingRecord(record models.PingRecord) error {
+	db := dbcore.GetDBInstance()
+	return db.Create(&record).Error
+}
+
+func GetPingRecords(client string) ([]models.PingRecord, error) {
+	db := dbcore.GetDBInstance()
+	var records []models.PingRecord
+	if err := db.Where("client = ?", client).Order("time DESC").Find(&records).Error; err != nil {
+		return nil, err
+	}
+	return records, nil
+}
+
+func DeletePingRecordsBefore(time time.Time) error {
+	db := dbcore.GetDBInstance()
+	err := db.Where("time < ?", time).Delete(&models.PingRecord{}).Error
+	return err
+}
+
+func DeletePingRecords(id []uint) error {
+	db := dbcore.GetDBInstance()
+	result := db.Where("task_id IN ?", id).Delete(&models.PingRecord{})
+	if result.RowsAffected == 0 {
+		return gorm.ErrRecordNotFound
+	}
+	return result.Error
+}
+
+func ReloadPingSchedule() error {
+	db := dbcore.GetDBInstance()
+	var pingTasks []models.PingTask
+	if err := db.Find(&pingTasks).Error; err != nil {
+		return err
+	}
+	return utils.ReloadPingSchedule(pingTasks)
+}
+func GetPingRecordsByClientAndTime(uuid string, start, end time.Time) ([]models.PingRecord, error) {
+	db := dbcore.GetDBInstance()
+	var records []models.PingRecord
+	if err := db.Where("client = ? AND time >= ? AND time <= ?", uuid, start, end).Order("time DESC").Find(&records).Error; err != nil {
+		return nil, err
+	}
+	return records, nil
+}

public/public.go

@@ -4,6 +4,7 @@ import (
 	"embed"
 	"errors"
 	"fmt"
+	"html"
 	"io"
 	"io/fs"
 	"log"
@@ -47,13 +48,22 @@ func initIndex() {
 	RawIndexFile = string(index)
 }
 func UpdateIndex(cfg models.Config) {
+	var titleReplacement string
+	if cfg.Sitename == "Komari" {
+		titleReplacement = "<title>Komari Monitor</title>"
+	} else {
+		titleReplacement = fmt.Sprintf("<title>%s - Komari Monitor</title>", html.EscapeString(cfg.Sitename))
+	}
+
 	replaceMap := map[string]string{
-		"</head>": cfg.CustomHead + "</head>",
-		"</body>": cfg.CustomBody + "</body>",
+		"<title>Komari Monitor</title>": titleReplacement,
+		"A simple server monitor tool.": cfg.Description,
+		"</head>":                       cfg.CustomHead + "</head>",
+		"</body>":                       cfg.CustomBody + "</body>",
 	}
 	updated := RawIndexFile
 	for k, v := range replaceMap {
-		updated = strings.Replace(updated, k, v, 1)
+		updated = strings.Replace(updated, k, v, -1)
 	}
 	IndexFile = updated
 }

todo.md

@@ -22,11 +22,11 @@
 
 - [x] Github单点登录、绑定、解绑
 
-- [ ] 2FA
+- [x] 2FA
 
 - [ ] 负载通知
 
-- [ ] 离线通知
+- [x] 离线通知
 
 - [ ] DDNS
 
@@ -36,4 +36,4 @@
 
 - [x] 自动更新
 
-- [ ] 慢速模式
+- [x] 慢速模式（调整interval）

utils/messageSender/sender.go

@@ -0,0 +1,22 @@
+package messageSender
+
+import (
+	"errors"
+
+	"github.com/komari-monitor/komari/database/config"
+)
+
+func SendTextMessage(message string) error {
+	cfg, _ := config.Get()
+	if !cfg.NotificationEnabled {
+		return nil
+	}
+	switch cfg.NotificationMethod {
+	case "none":
+		return nil
+	case "telegram":
+		return TelegramSendTextMessage(message)
+	default:
+		return errors.New("unsupported notification method: " + cfg.NotificationMethod)
+	}
+}

utils/messageSender/telegram.go

@@ -1,4 +1,4 @@
-package telegram
+package messageSender
 
 import (
 	"encoding/json"
@@ -10,7 +10,7 @@ import (
 	"github.com/komari-monitor/komari/database/config"
 )
 
-func SendMessage(message, msgType string) error {
+func TelegramSendMessage(message, msgType string) error {
 	var lastErr error
 	for i := 0; i < 3; i++ {
 		conf, err := config.Get()
@@ -19,7 +19,7 @@ func SendMessage(message, msgType string) error {
 			continue
 		}
 
-		if !conf.TelegramEnabled || message == "" {
+		if message == "" {
 			return errors.New("telegram is disabled or message is empty")
 		}
 
@@ -63,14 +63,14 @@ func SendMessage(message, msgType string) error {
 }
 
 // SendTextMessage sends a text message via Telegram API
-func SendTextMessage(message string) error {
-	return SendMessage(message, "text")
+func TelegramSendTextMessage(message string) error {
+	return TelegramSendMessage(message, "text")
 }
 
 // SendMarkdownMessage sends a message formatted in Markdown via Telegram API
-func SendMarkdownMessage(message string) error {
-	return SendMessage(message, "MarkdownV2")
+func TelegramSendMarkdownMessage(message string) error {
+	return TelegramSendMessage(message, "MarkdownV2")
 }
-func SendHTMLMessage(message string) error {
-	return SendMessage(message, "HTML")
+func TelegramSendHTMLMessage(message string) error {
+	return TelegramSendMessage(message, "HTML")
 }

utils/notification/offline.go

@@ -10,18 +10,15 @@ import (
 	"github.com/komari-monitor/komari/database/config"
 	"github.com/komari-monitor/komari/database/dbcore"
 	"github.com/komari-monitor/komari/database/models"
-	"github.com/komari-monitor/komari/utils/telegram"
+	"github.com/komari-monitor/komari/utils/messageSender"
 )
 
 var (
-	lastNotified       = make(map[string]time.Time)
-	lastOnlineNotified = make(map[string]time.Time)
-	pendingOffline     = make(map[string]time.Time)
-
-	mu sync.Mutex
+	pendingOffline = make(map[string]time.Time)
+	mu             sync.Mutex
 )
 
-// OfflineNotification sends an offline notification for the client if enabled and not sent in cooldown period
+// OfflineNotification sends an offline notification for the client if enabled and not sent in grace period
 func OfflineNotification(clientID string) {
 	client, err := clients.GetClientByUUID(clientID)
 	if err != nil {
@@ -48,11 +45,7 @@ func OfflineNotification(clientID string) {
 		return
 	}
 
-	cooldownDuration := time.Duration(noti_conf.Cooldown) * time.Second
 	gracePeriod := time.Duration(noti_conf.GracePeriod) * time.Second
-	if cooldownDuration <= 0 {
-		cooldownDuration = 30 * time.Minute // default cooldown if not set
-	}
 	if gracePeriod <= 0 {
 		gracePeriod = 5 * time.Minute // default grace period if not set
 	}
@@ -73,25 +66,20 @@ func OfflineNotification(clientID string) {
 		if ts, ok := pendingOffline[clientID]; !ok || !ts.Equal(start) {
 			return
 		}
-		// check cooldown
-		if last, ok := lastNotified[clientID]; ok && time.Since(last) < cooldownDuration {
-			delete(pendingOffline, clientID)
-			return
-		}
 		// record notification time and clear pending
-		lastNotified[clientID] = time.Now()
 		delete(pendingOffline, clientID)
 
-		message := fmt.Sprintf("🔴<code>%s</code> is offline", client.Name)
+		message := fmt.Sprintf("🔴%s is offline", client.Name)
 		go func(msg string) {
-			if err := telegram.SendHTMLMessage(msg); err != nil {
+			if err := messageSender.SendTextMessage(msg); err != nil {
 				log.Println("Failed to send offline notification:", err)
 			}
 		}(message)
+		_ = db.Model(&models.OfflineNotification{}).Where("client = ?", clientID).Update("last_notified", now)
 	}(now)
 }
 
-// OnlineNotification sends an online notification for the client if enabled and not sent in cooldown period
+// OnlineNotification sends an online notification for the client if enabled
 func OnlineNotification(clientID string) {
 	client, err := clients.GetClientByUUID(clientID)
 	if err != nil {
@@ -110,40 +98,15 @@ func OnlineNotification(clientID string) {
 	if !noti_conf.Enable {
 		return
 	}
-	cooldownDuration := time.Duration(noti_conf.Cooldown) * time.Second
-	gracePeriod := time.Duration(noti_conf.GracePeriod) * time.Second
-	if cooldownDuration <= 0 {
-		cooldownDuration = 30 * time.Minute // default cooldown if not set
-	}
-	if gracePeriod <= 0 {
-		gracePeriod = 5 * time.Minute // default grace period if not set
-	}
 	// clear any pending offline debounce
 	mu.Lock()
 	delete(pendingOffline, clientID)
 	mu.Unlock()
 
-	now := time.Now()
-
-	mu.Lock()
-	defer mu.Unlock()
-
-	// if never went offline before, skip first online notification
-	if _, wasOffline := lastNotified[clientID]; !wasOffline {
-		return
-	}
-	// cooldown for online notifications
-	if last, exists := lastOnlineNotified[clientID]; exists && now.Sub(last) < cooldownDuration {
-		return
-	}
-	// send online notification
-	message := fmt.Sprintf("🟢<code>%s</code> is online", client.Name)
+	message := fmt.Sprintf("🟢%s is online", client.Name)
 	go func(msg string) {
-		if err := telegram.SendHTMLMessage(msg); err != nil {
+		if err := messageSender.SendTextMessage(msg); err != nil {
 			log.Println("Failed to send online notification:", err)
 		}
 	}(message)
-
-	lastOnlineNotified[clientID] = now
-	delete(lastNotified, clientID)
 }

utils/pingSchedule.go

@@ -0,0 +1,94 @@
+package utils
+
+import (
+	"sync"
+	"time"
+
+	"github.com/komari-monitor/komari/database/models"
+	"github.com/komari-monitor/komari/ws"
+)
+
+// PingTaskManager 管理定时器和任务
+type PingTaskManager struct {
+	mu       sync.Mutex
+	tickers  map[int]*time.Ticker
+	tasks    map[int][]models.PingTask
+	stopChan chan struct{}
+}
+
+var manager = &PingTaskManager{
+	tickers:  make(map[int]*time.Ticker),
+	tasks:    make(map[int][]models.PingTask),
+	stopChan: make(chan struct{}),
+}
+
+// Reload 重载时间表
+func (m *PingTaskManager) Reload(pingTasks []models.PingTask) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	// 停止所有现有定时器
+	for _, ticker := range m.tickers {
+		ticker.Stop()
+	}
+	m.tickers = make(map[int]*time.Ticker)
+	m.tasks = make(map[int][]models.PingTask)
+
+	// 按Interval分组任务
+	taskGroups := make(map[int][]models.PingTask)
+	for _, task := range pingTasks {
+		taskGroups[task.Interval] = append(taskGroups[task.Interval], task)
+	}
+
+	// 为每个唯一的Interval创建定时器
+	for interval, tasks := range taskGroups {
+		ticker := time.NewTicker(time.Duration(interval) * time.Second)
+		m.tickers[interval] = ticker
+		m.tasks[interval] = tasks
+
+		go func(ticker *time.Ticker, tasks []models.PingTask) {
+			for {
+				select {
+				case <-ticker.C:
+					for _, task := range tasks {
+						go executePingTask(task)
+					}
+				case <-m.stopChan:
+					return
+				}
+			}
+		}(ticker, tasks)
+	}
+
+	return nil
+}
+
+// executePingTask 执行单个PingTask
+func executePingTask(task models.PingTask) {
+	clients := ws.GetConnectedClients()
+	var message struct {
+		TaskID  uint   `json:"ping_task_id"`
+		Message string `json:"message"`
+		Type    string `json:"ping_type"`
+		Target  string `json:"ping_target"`
+	}
+	for _, clientUUID := range task.Clients {
+		if conn, exists := clients[clientUUID]; exists {
+			if conn == nil {
+				continue
+			}
+			message.Message = "ping"
+			message.TaskID = task.Id
+			message.Type = task.Type
+			message.Target = task.Target
+			if err := conn.WriteJSON(message); err != nil {
+				continue
+			}
+		}
+	}
+}
+
+// ReloadPingSchedule 加载或重载时间表
+func ReloadPingSchedule(pingTasks []models.PingTask) error {
+	return manager.Reload(pingTasks)
+}

utils/safaMap.go

@@ -0,0 +1,88 @@
+package utils
+
+import (
+	"sync"
+)
+
+// SafeMap 是一个线程安全的泛型映射类型
+// 使用 sync.RWMutex 来确保并发访问的安全性
+type SafeMap[K comparable, V any] struct {
+	mu    sync.RWMutex // 读写锁，用于保护 items 的并发访问
+	items map[K]V      // 存储键值对的底层映射
+}
+
+// NewSafeMap 创建一个新的 SafeMap 实例
+// 返回一个指向 SafeMap 的指针
+func NewSafeMap[K comparable, V any]() *SafeMap[K, V] {
+	return &SafeMap[K, V]{
+		items: make(map[K]V), // 初始化底层映射
+	}
+}
+
+// Set 添加或更新映射中的键值对
+// 使用写锁保护操作
+func (sm *SafeMap[K, V]) Set(key K, value V) {
+	sm.mu.Lock()
+	defer sm.mu.Unlock()
+	sm.items[key] = value
+}
+
+// Store 添加或更新映射中的键值对
+// 是 Set 方法的别名
+func (sm *SafeMap[K, V]) Store(key K, value V) {
+	sm.Set(key, value)
+}
+
+// Get 根据键从映射中检索值
+// 返回值和一个布尔值，指示键是否存在
+func (sm *SafeMap[K, V]) Get(key K) (V, bool) {
+	sm.mu.RLock()
+	defer sm.mu.RUnlock()
+
+	value, exists := sm.items[key]
+	return value, exists
+}
+
+// Delete 从映射中移除指定键的键值对
+// 使用写锁保护操作
+func (sm *SafeMap[K, V]) Delete(key K) {
+	sm.mu.Lock()
+	defer sm.mu.Unlock()
+
+	delete(sm.items, key)
+}
+
+// Keys 返回映射中所有键的切片
+// 使用读锁保护操作
+func (sm *SafeMap[K, V]) Keys() []K {
+	sm.mu.RLock()
+	defer sm.mu.RUnlock()
+
+	keys := make([]K, 0, len(sm.items))
+	for key := range sm.items {
+		keys = append(keys, key)
+	}
+	return keys
+}
+
+// Len 返回映射中键值对的数量
+// 使用读锁保护操作
+func (sm *SafeMap[K, V]) Len() int {
+	sm.mu.RLock()
+	defer sm.mu.RUnlock()
+
+	return len(sm.items)
+}
+
+// Range 遍历映射中的所有键值对
+// 接受一个函数作为参数，如果函数返回 false，则停止遍历
+func (sm *SafeMap[K, V]) Range(f func(key K, value V) bool) {
+	sm.mu.RLock()
+	defer sm.mu.RUnlock()
+
+	for key, value := range sm.items {
+		if !f(key, value) {
+			break
+		}
+	}
+}

ws/clients.go

@@ -47,15 +47,15 @@ func GetClients(c *gin.Context) {
 			continue
 		}
 		// 已建立连接的客户端uuid列表
-		for key := range ConnectedClients {
+		for key := range GetConnectedClients() {
 			resp.Online = append(resp.Online, key)
 		}
 		// 清除UUID，简化报告单
-		for _, report := range LatestReport {
+		resp.Data = GetLatestReport()
+		for _, report := range resp.Data {
 			report.UUID = ""
 		}
-		resp.Data = LatestReport
-		for _, report := range LatestReport {
+		for _, report := range resp.Data {
 			if report.CPU.Usage == 0 {
 				report.CPU.Usage = 0.01
 			}

ws/existingConnection.go

@@ -1,12 +1,58 @@
 package ws
 
 import (
+	"sync"
+
 	"github.com/gorilla/websocket"
 	"github.com/komari-monitor/komari/common"
 )
 
 var (
-	ConnectedClients = make(map[string]*websocket.Conn)
+	connectedClients = make(map[string]*SafeConn)
 	ConnectedUsers   = []*websocket.Conn{}
-	LatestReport     = make(map[string]*common.Report)
+	latestReport     = make(map[string]*common.Report)
+	mu               = sync.RWMutex{}
 )
+
+func GetConnectedClients() map[string]*SafeConn {
+	mu.RLock()
+	defer mu.RUnlock()
+	clientsCopy := make(map[string]*SafeConn)
+	for k, v := range connectedClients {
+		clientsCopy[k] = v
+	}
+	return clientsCopy
+}
+
+func SetConnectedClients(uuid string, conn *SafeConn) {
+	mu.Lock()
+	defer mu.Unlock()
+	connectedClients[uuid] = conn
+}
+func DeleteConnectedClients(uuid string) {
+	mu.Lock()
+	defer mu.Unlock()
+	if conn, exists := connectedClients[uuid]; exists {
+		conn.Close()
+	}
+	delete(connectedClients, uuid)
+}
+func GetLatestReport() map[string]*common.Report {
+	mu.RLock()
+	defer mu.RUnlock()
+	reportCopy := make(map[string]*common.Report)
+	for k, v := range latestReport {
+		reportCopy[k] = v
+	}
+	return reportCopy
+}
+func SetLatestReport(uuid string, report *common.Report) {
+	mu.Lock()
+	defer mu.Unlock()
+	latestReport[uuid] = report
+}
+func DeleteLatestReport(uuid string) {
+	mu.Lock()
+	defer mu.Unlock()
+	delete(latestReport, uuid)
+}

ws/safeConn.go

@@ -0,0 +1,52 @@
+package ws
+
+import (
+	"sync"
+	"time"
+
+	"github.com/gorilla/websocket"
+)
+
+type SafeConn struct {
+	conn *websocket.Conn
+	mu   sync.Mutex
+}
+
+func NewSafeConn(conn *websocket.Conn) *SafeConn {
+	return &SafeConn{
+		conn: conn,
+		mu:   sync.Mutex{},
+	}
+}
+
+func (sc *SafeConn) WriteMessage(messageType int, data []byte) error {
+	sc.mu.Lock()
+	defer sc.mu.Unlock()
+	return sc.conn.WriteMessage(messageType, data)
+}
+
+func (sc *SafeConn) WriteJSON(v interface{}) error {
+	sc.mu.Lock()
+	defer sc.mu.Unlock()
+	return sc.conn.WriteJSON(v)
+}
+
+func (sc *SafeConn) Close() error {
+	sc.mu.Lock()
+	defer sc.mu.Unlock()
+	return sc.conn.Close()
+}
+func (sc *SafeConn) ReadMessage() (int, []byte, error) {
+	return sc.conn.ReadMessage()
+}
+func (sc *SafeConn) ReadJSON(v interface{}) error {
+	return sc.conn.ReadJSON(v)
+}
+func (sc *SafeConn) SetReadDeadline(t time.Time) error {
+	return sc.conn.SetReadDeadline(t)
+}
+func (sc *SafeConn) GetConn() *websocket.Conn {
+	sc.mu.Lock()
+	defer sc.mu.Unlock()
+	return sc.conn
+}