Client/server
5
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

feat(api): enhance server status handling with protocol support and refactor related logic

Browse Source
This commit is contained in:
Chang lue Tsen
2025-09-01 04:17:33 -04:00
parent 6dc1bee14c
commit 3012a68339
18 changed files with 261 additions and 1428 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/logic/admin/server/filterServerListLogic.go
+49 -50
View File
@@ -55,7 +55,7 @@ func (l *FilterServerListLogic) FilterServerList(req *types.FilterServerListRequ
tool.DeepCopy(&protocols, dst)
server.Protocols = protocols
// handler status
server.Status = l.handlerServerStatus(datum.Id)
server.Status = l.handlerServerStatus(datum.Id, protocols)
list = append(list, server)
}
@@ -65,58 +65,57 @@ func (l *FilterServerListLogic) FilterServerList(req *types.FilterServerListRequ
}, nil
}
func (l *FilterServerListLogic) handlerServerStatus(id int64) types.ServerStatus {
var result types.ServerStatus
nodeStatus, err := l.svcCtx.NodeCache.GetNodeStatus(l.ctx, id)
if err != nil {
if !errors.Is(err, redis.Nil) {
l.Errorw("[handlerServerStatus] GetNodeStatus Error: ", logger.Field("error", err.Error()), logger.Field("node_id", id))
}
return result
}
result = types.ServerStatus{
Mem: nodeStatus.Mem,
Cpu: nodeStatus.Cpu,
Disk: nodeStatus.Disk,
Online: make([]types.ServerOnlineUser, 0),
}
// parse online users
onlineUser, err := l.svcCtx.NodeCache.GetNodeOnlineUser(l.ctx, id)
if err != nil {
l.Errorw("[handlerServerStatus] GetNodeOnlineUser Error: ", logger.Field("error", err.Error()), logger.Field("node_id", id))
return result
}
var onlineList []types.ServerOnlineUser
var onlineMap = make(map[int64]types.ServerOnlineUser)
// group by user_id
for subId, info := range onlineUser {
data, err := l.svcCtx.UserModel.FindOneUserSubscribe(l.ctx, subId)
func (l *FilterServerListLogic) handlerServerStatus(id int64, protocols []types.Protocol) []types.ServerStatus {
var result []types.ServerStatus
for _, protocol := range protocols {
nodeStatus, err := l.svcCtx.NodeModel.StatusCache(l.ctx, id, protocol.Type)
if err != nil {
l.Errorw("[handlerServerStatus] FindOneSubscribe Error: ", logger.Field("error", err.Error()))
continue
}
if online, exist := onlineMap[data.UserId]; !exist {
onlineMap[data.UserId] = types.ServerOnlineUser{
IP: info,
UserId: data.UserId,
Subscribe: data.Subscribe.Name,
SubscribeId: data.SubscribeId,
Traffic: data.Traffic,
ExpiredAt: data.ExpireTime.UnixMilli(),
if !errors.Is(err, redis.Nil) {
l.Errorw("[handlerServerStatus] GetNodeStatus Error: ", logger.Field("error", err.Error()), logger.Field("node_id", id))
}
} else {
online.IP = append(online.IP, info...)
onlineMap[data.UserId] = online
return result
}
status := types.ServerStatus{
Mem: nodeStatus.Mem,
Cpu: nodeStatus.Cpu,
Disk: nodeStatus.Disk,
Protocol: protocol.Type,
Online: make([]types.ServerOnlineUser, 0),
}
// parse online users
onlineUser, err := l.svcCtx.NodeModel.OnlineUserSubscribe(l.ctx, id, protocol.Type)
if err != nil {
l.Errorw("[handlerServerStatus] GetNodeOnlineUser Error: ", logger.Field("error", err.Error()), logger.Field("node_id", id))
return result
}
var onlineList []types.ServerOnlineUser
var onlineMap = make(map[int64]types.ServerOnlineUser)
// group by user_id
for subId, info := range onlineUser {
data, err := l.svcCtx.UserModel.FindOneUserSubscribe(l.ctx, subId)
if err != nil {
l.Errorw("[handlerServerStatus] FindOneSubscribe Error: ", logger.Field("error", err.Error()))
continue
}
if online, exist := onlineMap[data.UserId]; !exist {
onlineMap[data.UserId] = types.ServerOnlineUser{
IP: info,
UserId: data.UserId,
Subscribe: data.Subscribe.Name,
SubscribeId: data.SubscribeId,
Traffic: data.Traffic,
ExpiredAt: data.ExpireTime.UnixMilli(),
}
} else {
online.IP = append(online.IP, info...)
onlineMap[data.UserId] = online
}
}
for _, online := range onlineMap {
onlineList = append(onlineList, online)
}
status.Online = onlineList
result = append(result, status)
}
for _, online := range onlineMap {
onlineList = append(onlineList, online)
}
result.Online = onlineList
return result
}
internal/logic/server/pushOnlineUsersLogic.go
+12 -8
View File
@@ -5,7 +5,7 @@ import (
"errors"
"fmt"
"github.com/perfect-panel/server/internal/model/cache"
"github.com/perfect-panel/server/internal/model/node"
"github.com/perfect-panel/server/internal/svc"
"github.com/perfect-panel/server/internal/types"
"github.com/perfect-panel/server/pkg/logger"
@@ -46,20 +46,24 @@ func (l *PushOnlineUsersLogic) PushOnlineUsers(req *types.OnlineUsersRequest) er
return fmt.Errorf("server not found: %w", err)
}
userOnlineIp := make([]cache.NodeOnlineUser, 0)
var onlineUsers node.OnlineUserSubscribe
for _, user := range req.Users {
userOnlineIp = append(userOnlineIp, cache.NodeOnlineUser{
SID: user.SID,
IP: user.IP,
})
if online, ok := onlineUsers[user.SID]; ok {
// If user already exists, update IP if different
online = append(online, user.IP)
onlineUsers[user.SID] = online
} else {
// New user, add to map
onlineUsers[user.SID] = []string{user.IP}
}
}
err = l.svcCtx.NodeCache.AddOnlineUserIP(l.ctx, userOnlineIp)
err = l.svcCtx.NodeModel.UpdateOnlineUserSubscribe(l.ctx, req.ServerId, req.Protocol, onlineUsers)
if err != nil {
l.Errorw("[PushOnlineUsers] cache operation error", logger.Field("error", err))
return err
}
err = l.svcCtx.NodeCache.UpdateNodeOnlineUser(l.ctx, req.ServerId, userOnlineIp)
err = l.svcCtx.NodeModel.UpdateOnlineUserSubscribeGlobal(l.ctx, onlineUsers)
if err != nil {
l.Errorw("[PushOnlineUsers] cache operation error", logger.Field("error", err))
internal/logic/server/serverPushStatusLogic.go
+2 -2
View File
@@ -4,7 +4,7 @@ import (
"context"
"errors"
"github.com/perfect-panel/server/internal/model/cache"
"github.com/perfect-panel/server/internal/model/node"
"github.com/perfect-panel/server/internal/svc"
"github.com/perfect-panel/server/internal/types"
"github.com/perfect-panel/server/pkg/logger"
@@ -32,7 +32,7 @@ func (l *ServerPushStatusLogic) ServerPushStatus(req *types.ServerPushStatusRequ
l.Errorw("[PushOnlineUsers] FindOne error", logger.Field("error", err))
return errors.New("server not found")
}
err = l.svcCtx.NodeCache.UpdateNodeStatus(l.ctx, req.ServerId, cache.NodeStatus{
err = l.svcCtx.NodeModel.UpdateStatusCache(l.ctx, req.ServerId, req.Protocol, &node.Status{
Cpu: req.Cpu,
Mem: req.Mem,
Disk: req.Disk,
internal/logic/server/serverPushUserTrafficLogic.go
-15
View File
@@ -5,7 +5,6 @@ import (
"encoding/json"
"github.com/hibiken/asynq"
"github.com/perfect-panel/server/internal/model/cache"
"github.com/perfect-panel/server/internal/svc"
"github.com/perfect-panel/server/internal/types"
"github.com/perfect-panel/server/pkg/logger"
@@ -40,23 +39,9 @@ func (l *ServerPushUserTrafficLogic) ServerPushUserTraffic(req *types.ServerPush
// Create traffic task
var request task.TrafficStatistics
var userTraffic []cache.UserTraffic
request.ServerId = serverInfo.Id
tool.DeepCopy(&request.Logs, req.Traffic)
tool.DeepCopy(&userTraffic, req.Traffic)
// update today traffic rank
err = l.svcCtx.NodeCache.AddNodeTodayTraffic(l.ctx, serverInfo.Id, userTraffic)
if err != nil {
l.Errorw("[ServerPushUserTraffic] AddNodeTodayTraffic error", logger.Field("error", err))
return errors.New("add node today traffic error")
}
for _, user := range req.Traffic {
if err = l.svcCtx.NodeCache.AddUserTodayTraffic(l.ctx, user.SID, user.Upload, user.Download); err != nil {
l.Errorw("[ServerPushUserTraffic] AddUserTodayTraffic error", logger.Field("error", err))
continue
}
}
// Push traffic task
val, _ := json.Marshal(request)
t := asynq.NewTask(task.ForthwithTrafficStatistics, val, asynq.MaxRetry(3))